diff --git a/lectures/lecture-02/1 - Scopes, Types, etc.ipynb b/lectures/lecture-02/1 - Scopes, Types, etc.ipynb new file mode 100755 index 0000000..d743cf4 --- /dev/null +++ b/lectures/lecture-02/1 - Scopes, Types, etc.ipynb @@ -0,0 +1,3510 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Review\n", + "\n", + "One key idea in programming is a **variable**. A variable is a name that refers to a value. It lets us reference the value, even if we do not know what it is. We can **assign** to variables in Python using the `=` symbol.\n", + "\n", + "Even though we are still working with simple code, we have already learned two key ideas of programming that let us build more complex systems through modularity.\n", + "\n", + "The first is **functions**. We learned that code is organized in **blocks**.\n", + "\n", + "The second idea is **scope**.\n", + "\n", + "We also learned about **exceptions**." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "x = 0\n", + "\n", + "def foo(a):\n", + " return a\n", + "\n", + "z = foo(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "32\n", + "3.125\n", + "0\n", + "32\n" + ] + } + ], + "source": [ + "x = 0\n", + "\n", + "def foo(x):\n", + " y = 100/x\n", + " print(x)\n", + " print(y)\n", + " return y\n", + "\n", + "y = 32\n", + "z = foo(y)\n", + "print(x)\n", + "print(y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Coding style\n", + "\n", + "It is great if your code runs successfully! However, you are likely to want to run it again. (And even if not, it is good to practice \"Doin' It Right\".) Therefore, it is good to optimize it for readability and reuse. There is certainly a sense of style in software coding. It's good to develop your own sense of good style.\n", + "\n", + "There is more one way to write correct code. (In fact, there are infinitely many ways.)\n", + "\n", + "Depending on the programming language, and often depending on the project or environment, there are standard, \"idiomatic\" ways of doing things. You should prefer those - they make your code easier to read for others - and also yourself in the future.\n", + "\n", + "It is useful to spend time refining code so that it looks simple and, ideally, *is* simple. Of course this is not always possible.\n", + "\n", + "One stylistic rule that holds pretty much in every programming language is the principle \"Don't Repeat Yourself\" (DRY). If you need to change something, ideally you will only need to change it in one place in your code. Another way of saying this is that there should only be a \"single source of truth\".\n", + "\n", + "The python package \"black\" is commonly used linter for making code style changes to an idiomatic format.\n", + "\n", + "### Style suggestions\n", + "\n", + "- In general: simplify\n", + "- Remove irrelevant code (e.g. `plt.show;`)\n", + "- Remove irrelevant comments (e.g. `# YOUR CODE HERE`)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Types\n", + "\n", + "Every value in Python has a **type**. You don't usually *see* the types written, but it is critically important to understand what types are used in code you are working on. Python checks *exactly* how something is typed and, according to strict rules, decides what type the value will have. For example, these will all be different types:\n", + "\n", + "```python\n", + "10\n", + "10.0\n", + "'10'\n", + "```\n", + "\n", + "\n", + "## Types of types\n", + "\n", + "So far, we have mostly worked with whole numbers called **integers** - in python, an `int`. We briefly saw `None` and some strings. You may have also seen **floating point numbers** (`float` in python).\n", + "\n", + "Let's practice with some of these types.\n", + "\n", + "## Playing with types" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "10" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "int" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10.0" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "10.0" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "float" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(10.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "int" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = 10\n", + "type(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "str" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(\"10\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "str" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type('10')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "my_string = \"Hello, My name is Angela Merkel\"" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "my_string = \"übersetzen\"" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "Übersetzung = \"translation\"" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "übersetzen\n" + ] + } + ], + "source": [ + "print(my_string)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the data is like this: \"gcatcccggg\"\n" + ] + } + ], + "source": [ + "my_string = 'the data is like this: \"gcatcccggg\"'\n", + "print(my_string)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (1042171736.py, line 1)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m Cell \u001b[0;32mIn[15], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m my_string = \"the data is like this: \"gcatcccggg\"\"\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" + ] + } + ], + "source": [ + "my_string = \"the data is like this: \"gcatcccggg\"\"\n", + "print(my_string)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the data is like this: \"gcatcccggg\"\n" + ] + } + ], + "source": [ + "my_string = \"the data is like this: \\\"gcatcccggg\\\"\"\n", + "print(my_string)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the data is like this: \\gcatcccggg\"\n" + ] + } + ], + "source": [ + "my_string = \"the data is like this: \\\\gcatcccggg\\\"\"\n", + "print(my_string)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the data is like this: 'gcatcccggg'\n" + ] + } + ], + "source": [ + "my_string = 'the data is like this: \\'gcatcccggg\\''\n", + "print(my_string)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (57043761.py, line 1)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m Cell \u001b[0;32mIn[19], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m my_string = 'the data is like this: 'gcatcccggg''\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" + ] + } + ], + "source": [ + "my_string = 'the data is like this: 'gcatcccggg''\n", + "print(my_string)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the data is like this: 'gcatcccggg'\n" + ] + } + ], + "source": [ + "my_string = \"the data is like this: 'gcatcccggg'\"\n", + "print(my_string)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the data is like this: \\ 'gcatcccggg'\n" + ] + } + ], + "source": [ + "my_string = \"the data is like this: \\\\ 'gcatcccggg'\"\n", + "print(my_string)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "x=10" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n" + ] + } + ], + "source": [ + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1234" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1234" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def myprint(x):\n", + " print(x)\n", + " return 32" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hello\n" + ] + }, + { + "data": { + "text/plain": [ + "32" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "myprint(\"hello\")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hello\n" + ] + } + ], + "source": [ + "myprint(\"hello\");" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "10" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "# In Jupyter, `_` is a special variable, which means the output value of the previously run cell.\n", + "y=_" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "x=x+1" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "11\n" + ] + } + ], + "source": [ + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "z=x=x+1" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "z" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# None type\n", + "\n", + "The `None` type is used when there is no value. It is actually very common in Python. For example a function which does not return anything actually returns the value `None`." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n" + ] + } + ], + "source": [ + "x=None\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "NoneType" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=None\n", + "type(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "None" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "10" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n", + "None\n" + ] + } + ], + "source": [ + "x=print(10)\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "x" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "x=10" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Operators\n", + "\n", + "Many of the most commonly used operations (like addition) could be written as function calls, but instead have special symbols (like `+`)." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "3+4" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "int.__add__(3,4)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'abcdef'" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"abc\" + \"def\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "str.__add__(\"abc\", \"def\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Complex expressions\n", + "\n", + "Often we write expressions in which multiple operations happen in one line of code" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "14" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "4 * 3 + 2" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "14" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 + 4 * 3" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "x = 4 * 3 + 2" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "14" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "x = x * 2" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "28" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "14" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y=4*3+2\n", + "y" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "14" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tmp = 4*3\n", + "y = tmp+2\n", + "y" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "tmp = 'my super import data'\n", + "\n", + "y=4*(3+2)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "20" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'my super import data'" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tmp" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "tmp2 = 'my super import data'\n", + "\n", + "tmp=3+2\n", + "tmp2 = 4*tmp\n", + "y = tmp2" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "20" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tmp2" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20\n" + ] + } + ], + "source": [ + "print(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "14\n" + ] + } + ], + "source": [ + "print(4*3+2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# list type\n", + "\n", + "## list construction" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 2, 2, 2, 2, 'three', 4.0]\n" + ] + } + ], + "source": [ + "x = [1,2,2,2,2,2,\"three\", 4.0]\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[]\n" + ] + } + ], + "source": [ + "x=list()\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4]\n" + ] + } + ], + "source": [ + "x=[1,2,3,4]\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[]\n", + "[1]\n", + "[1, 2]\n", + "[1, 2, 3]\n", + "[1, 2, 3, 4]\n", + "None\n" + ] + } + ], + "source": [ + "x=[]\n", + "print(x)\n", + "\n", + "x.append(1)\n", + "print(x)\n", + "\n", + "x.append(2)\n", + "print(x)\n", + "\n", + "x.append(3)\n", + "print(x)\n", + "\n", + "z = x.append(4)\n", + "print(x)\n", + "\n", + "print(z)" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['red', 'green', 'blue']\n" + ] + } + ], + "source": [ + "x=[\"red\",\"green\",\"blue\"]\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['red', 101, 'green', 202, 'blue', 303]\n" + ] + } + ], + "source": [ + "x=[\"red\", 101, \"green\", 202, \"blue\", 303]\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['red', 101, 'green', 202, 'blue', 303, [1, 2, 3], 'lkasjdf\"laskdjfj']\n" + ] + } + ], + "source": [ + "x=[\"red\", 101, \"green\", 202, \"blue\", 303, [1,2,3], 'lkasjdf\"laskdjfj']\n", + "print(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## list indexing" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'red'" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=[\"red\",\"green\",\"blue\"]\n", + "x[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'green'" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=[\"red\",\"green\",\"blue\"]\n", + "x[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'blue'" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=[\"red\",\"green\",\"blue\"]\n", + "x[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'blue'" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=[\"red\",\"green\",\"blue\"]\n", + "x[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'violet'" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n", + "x[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'blue'" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n", + "x[-3]" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'yellow'" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y=2\n", + "x[y]" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "list indices must be integers or slices, not str", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[83], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mhello\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\n", + "\u001b[0;31mTypeError\u001b[0m: list indices must be integers or slices, not str" + ] + } + ], + "source": [ + "x['hello']" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "list indices must be integers or slices, not float", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[84], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1.23\u001b[39;49m\u001b[43m]\u001b[49m\n", + "\u001b[0;31mTypeError\u001b[0m: list indices must be integers or slices, not float" + ] + } + ], + "source": [ + "x[1.23]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## getting index of item in list" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n", + "x.index(\"blue\")" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "321 is not in list", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[86], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m321\u001b[39;49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mValueError\u001b[0m: 321 is not in list" + ] + } + ], + "source": [ + "x.index(321)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## setting an item in a list" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [], + "source": [ + "x[3]=3" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['red', 'orange', 'yellow', 3, 'blue', 'indigo', 'violet']" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## list slicing" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['red', 'orange', 'yellow']" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n", + "x[0:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'green'" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x[3]" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['red', 'orange', 'yellow']" + ] + }, + "execution_count": 92, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x[:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['red', 'orange', 'yellow']" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n", + "x[None:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['red', 'orange', 'yellow']" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x[0:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['green', 'blue', 'indigo', 'violet']" + ] + }, + "execution_count": 95, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n", + "x[3:]" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['green', 'blue', 'indigo', 'violet']" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n", + "x[3:None]" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['green', 'blue', 'indigo']" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n", + "x[3:-1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# tuples\n", + "## tuple construction" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "(1, 2, 3, 4)\n" + ] + } + ], + "source": [ + "x = (1,2,3,4)\n", + "print(type(x))\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "()\n" + ] + } + ], + "source": [ + "x = ()\n", + "print(type(x))\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "(1,)\n" + ] + } + ], + "source": [ + "x = (1,)\n", + "print(type(x))\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "1\n" + ] + } + ], + "source": [ + "x = (1)\n", + "print(type(x))\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "(1,)\n" + ] + } + ], + "source": [ + "x = 1,\n", + "print(type(x))\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "(1, 2, 3)\n" + ] + } + ], + "source": [ + "x = 1,2,3\n", + "print(type(x))\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "1\n" + ] + } + ], + "source": [ + "x = 1\n", + "print(type(x))\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "()\n" + ] + } + ], + "source": [ + "x = tuple()\n", + "print(type(x))\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "(1,)\n" + ] + } + ], + "source": [ + "x = tuple([1])\n", + "print(type(x))\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "(1, 2, 3, 4)\n" + ] + } + ], + "source": [ + "x = tuple([1,2,3,4])\n", + "print(type(x))\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "tuple expected at most 1 argument, got 4", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[115], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mtuple\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mtype\u001b[39m(x))\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(x)\n", + "\u001b[0;31mTypeError\u001b[0m: tuple expected at most 1 argument, got 4" + ] + } + ], + "source": [ + "x = tuple(1,2,3,4)\n", + "print(type(x))\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "(1,)\n" + ] + } + ], + "source": [ + "tmp = [1]\n", + "print(type(tmp))\n", + "x = tuple(tmp)\n", + "print(type(x))\n", + "print(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## tuple indexing and slicing" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'yellow'" + ] + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=(\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\")\n", + "x[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'violet'" + ] + }, + "execution_count": 118, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=(\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\")\n", + "x[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'blue'" + ] + }, + "execution_count": 119, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=(\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\")\n", + "x[-3]" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('red', 'orange', 'yellow')" + ] + }, + "execution_count": 120, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=(\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\")\n", + "x[0:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('red', 'orange', 'yellow')" + ] + }, + "execution_count": 121, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x[:3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## lists are *mutable*, tuples are not" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']\n", + "['red', 'orange', 'yellow', 3, 'blue', 'indigo', 'violet']\n" + ] + } + ], + "source": [ + "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n", + "print(x)\n", + "x[3]=3\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet')\n" + ] + }, + { + "ename": "TypeError", + "evalue": "'tuple' object does not support item assignment", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[123], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m x\u001b[38;5;241m=\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mred\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124morange\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124myellow\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgreen\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mblue\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mindigo\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mviolet\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(x)\n\u001b[0;32m----> 3\u001b[0m \u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3\u001b[39m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(x)\n", + "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" + ] + } + ], + "source": [ + "x=(\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\")\n", + "print(x)\n", + "x[3]=3\n", + "print(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### passing mutable lists to functions" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n" + ] + } + ], + "source": [ + "def modify_arg(a,b):\n", + " a.append(b)\n", + " # Notice that there is no return here!\n", + " # So, this function has an important \"side effect\",\n", + " # but the output is None.\n", + " \n", + "x = [1,2,3]\n", + "y = modify_arg(x, 4)\n", + "x\n", + "print(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4]" + ] + }, + "execution_count": 126, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## variables can be names pointing to an object in memory" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']\n", + "['red', 'orange', 'yellow', 3, 'blue', 'indigo', 'violet']\n" + ] + } + ], + "source": [ + "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n", + "y=x\n", + "print(x)\n", + "y[3]=3\n", + "print(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['red', 'orange', 'yellow', 3, 'blue', 'indigo', 'violet']\n" + ] + } + ], + "source": [ + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "0\n", + "3\n" + ] + } + ], + "source": [ + "x=0\n", + "y=x\n", + "print(x)\n", + "y=3\n", + "print(x)\n", + "print(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']\n", + "['red', 'orange', 'yellow', 3, 'blue', 'indigo', 'violet']\n" + ] + } + ], + "source": [ + "# View the previous example and then this one in pythontutor.com\n", + "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n", + "y=x.copy()\n", + "print(x)\n", + "y[3]=3\n", + "print(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']\n" + ] + } + ], + "source": [ + "print(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x=[1,2,3,0,4,1]\n", + "y=[0,4,0,3,3,0]\n", + "plt.plot(x,y,\"go-\");" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1t0lEQVR4nO3deVxU9f7H8dcs7KuCLCoq7guiuKPQZmmCpu27tlhZKpa3e2/W3bv9vPf+uv0STc3S9tIKMxU0rVzAHUXFDXdBZRGVHWaYmfP7A4a0UAGBMzN8no/HPB4xnsN8zuPQzGfO+3y/X42iKApCCCGEECrRql2AEEIIIVo2aUaEEEIIoSppRoQQQgihKmlGhBBCCKEqaUaEEEIIoSppRoQQQgihKmlGhBBCCKEqaUaEEEIIoSq92gXUhcVi4fz583h5eaHRaNQuRwghhBB1oCgKxcXFtG3bFq322tc/7KIZOX/+PCEhIWqXIYQQQogGyMrKon379tf8d7toRry8vICqg/H29la5GiGEEELURVFRESEhITWf49diF82INZrx9vaWZkQIIYSwMze6xUJuYBVCCCGEqqQZEUIIIYSqpBkRQgghhKqkGRFCCCGEqqQZEUIIIYSqpBkRQgghhKqkGRFCCCGEqqQZEUIIIYSqpBkRQgghhKpuqhmZPXs2Go2Gl19++brbbdq0iYEDB+Lq6krnzp1ZuHDhzbysEEIIIRxIg5uRXbt2sWjRIsLDw6+73alTp4iJiSE6Opq0tDRef/114uLiSEhIaOhLCyGEEMKBNKgZKSkp4fHHH+eDDz6gVatW19124cKFdOjQgXfffZdevXoxefJknnnmGd5+++0GFSyEEEIIx9KgZmTq1KnExsZy55133nDbbdu2MWrUqKueGz16NKmpqVRWVta6j8FgoKio6KqHEMLxKIrC16lZ7Dp9Se1ShBAqqnczsnTpUvbs2cPs2bPrtH1OTg6BgYFXPRcYGIjJZCI/P7/WfWbPno2Pj0/NIyQkpL5lCiHswLYTF/nDt/uZ/EkqRpNF7XKEECqpVzOSlZXFjBkz+Pzzz3F1da3zfr9eOlhRlFqft5o1axaFhYU1j6ysrPqUKYSwE6v2ZwNQWF7JluO1fzkRQjg+fX023r17N3l5eQwcOLDmObPZzObNm5k3bx4GgwGdTnfVPkFBQeTk5Fz1XF5eHnq9Hj8/v1pfx8XFBRcXl/qUJoSwMyazhbUHsmt+Xr0/m9t7BqhYkRBCLfVqRkaOHEl6evpVzz399NP07NmTP/7xj79pRAAiIyNZtWrVVc+tW7eOQYMG4eTk1ICShRCOYNvJi1wuq0Sv1WCyKKw7lIPBFIaL/rfvI0IIx1avmMbLy4uwsLCrHh4eHvj5+REWFgZURSwTJ06s2WfKlCmcOXOGmTNncvjwYZYsWcLixYt59dVXG/dIhBB2JbE6onlwUHsCvFworjCRckyiGiFaokafgTU7O5vMzMyan0NDQ0lKSmLjxo3079+fN998k/j4eO6///7GfmkhhJ2oNFtYe7Aqvh0b3paYvsHALw2KEKJlqVdMU5uNGzde9fPHH3/8m21uvfVW9uzZc7MvJYRwENtOXKSgrBI/D2eGhrbGWa/l462nWX8oF4PJLFGNEC2MrE0jhGh21isgd4cFoddpGdihFYHeLhQbTCQflahGiJZGmhEhRLO6MqKJDa+KZ7RazS9RTbpENUK0NNKMCCGa1Zbj+RSWV+Lv6czQ0F+G94+tbkzWH8qlotKsVnlCCBVIMyKEaFbWiGZMWDA67S8TH0aEtCLYx5USg4nNRy+oVZ4QQgXSjAghmo3RZOGHX0U0VhLVCNFySTMihGg2W47nU1Rhoo2XC4M7tf7Nv1sblB8lqhGiRZFmRAjRbFZXRzQxYUFXRTRWESG+tPN1o9RoZmOGRDVCtBTSjAghmoXBZGbdoaqIxhrH/JpGo2FMWBAgUY0QLYk0I0KIZrHleD7FFSYCvFwYVEtEY2WNan46LFGNEC2FNCNCiGZRE9H0Da41orHqXx3VlBnNbMzIa67yhBAqkmZECNHkDCYz6w/mAr8dRfNrGo2mZpvVslaNEC2CNCNCiCaXfDSfYoOJQG8XBnZodcPtY/tao5o8yo0S1Qjh6KQZEUI0OevNqDF9g9FeJ6KxCm/vQ/tWbpRXmtkgUY0QDk+aESFEk6qoNLP+UFVEM/YGEY3VlVFNokQ1Qjg8aUaEEE1q89ELlBhMBPu4EhFy44jGamzftgD8dCSXMqOpqcoTQtgAaUaEEE3KGtGMCatbRGMV1s6bkNZuVFRa+PmIRDVCODJpRoQQTaai0syPh+o2iubXNBoNsdVXR5JkAjQhHJo0I0KIJrPp6AVKjWba+rgSEeJb7/2t95j8fCSPUoNENUI4KmlGhBBNJnF//UbR/Fqftt509HOXqEYIByfNiBCiSVRUmvnxcMMiGquqqEZG1Qjh6KQZEUI0iY0ZeZQZzbTzdaN/AyIaK2sjsyEjjxKJaoRwSNKMCCGahHUq99jwYDSa+kc0Vr2DvQn198BgsvBT9ZUWIYRjkWZECNHoyo1mfjpcdY+HNWZpKIlqhHB80owIIRrdhow8yivNtG/lRnh7n5v+fdaoZuPRCxRXVN707xNC2BZpRoQQjc56BSO2781FNFY9g7zo7O+B0WSpueIihHAc0owIIRpVmdFUMwy3oaNofu2qtWpkAjQhHI40I0KIRrXhyAXKK82EtHajb7ubj2isrM3IpgyJaoRwNNKMCCEaVWL6eQBi+7ZtlIjGqkegF13aeGA0W2rmLxFCOAZpRoQQjabU8EtEM7aRIhqrqqimaq0aGVUjhGORZkQI0Wh+PpJHRaWFjn7u9Gnr3ei/39rgbD6aT2G5RDVCOAppRoQQjaaxR9H8WvdAL7oFeFZFNYckqhHCUdSrGVmwYAHh4eF4e3vj7e1NZGQka9asueb2GzduRKPR/OZx5MiRmy5cCGFbSgwmNmQ07iia2sioGiEcT72akfbt2/Ovf/2L1NRUUlNTueOOOxg/fjwHDx687n4ZGRlkZ2fXPLp163ZTRQshbM9Ph3MxmCyE+nvQO7jxIxor62ysyccuUFgmUY0QjqBezci4ceOIiYmhe/fudO/enbfeegtPT0+2b99+3f0CAgIICgqqeeh0upsqWghhe6wRTUzfoCaJaKy6BXrRPdCTSrPCukM5TfY6Qojm0+B7RsxmM0uXLqW0tJTIyMjrbhsREUFwcDAjR45kw4YNN/zdBoOBoqKiqx5CCNtVYjCx8egFoGpIb1OzvkaSRDVCOIR6NyPp6el4enri4uLClClT+O677+jdu3et2wYHB7No0SISEhJYvnw5PXr0YOTIkWzevPm6rzF79mx8fHxqHiEhIfUtUwjRjH46nIvRZKGzvwe9gr2a/PViw4MASD6WL1GNEA5AoyiKUp8djEYjmZmZFBQUkJCQwIcffsimTZuu2ZD82rhx49BoNKxcufKa2xgMBgwGQ83PRUVFhISEUFhYiLd302XRQoiGee7TVNYfymX6HV353agezfKad7+7mSM5xfzngXAeGiRfWISwRUVFRfj4+Nzw87veV0acnZ3p2rUrgwYNYvbs2fTr1485c+bUef9hw4Zx7Nix627j4uJSM2LH+hBC2Kbiiko2ZVRHNE04iubXrDeyygRoQti/m55nRFGUq65i3EhaWhrBwc33hiWEaFo/Hs7FaLbQpY0HPQKbPqKxiqlufLYcz+dyqbHZXlcI0fj09dn49ddfZ8yYMYSEhFBcXMzSpUvZuHEja9euBWDWrFmcO3eOTz/9FIB3332XTp060adPH4xGI59//jkJCQkkJCQ0/pEIIVRRM9FZeOOuRXMjXdp40ivYm8PZRaw7lMPDgzs022sLIRpXvZqR3NxcnnzySbKzs/Hx8SE8PJy1a9dy1113AZCdnU1mZmbN9kajkVdffZVz587h5uZGnz59SExMJCYmpnGPQgihisLySjYfzQcafy2auhgbHszh7CJW78+WZkQIO1bvG1jVUNcbYIQQzSth91l+980+ugV4sn7mrc3++qfyS7n97Y3otBp2vXEnrT2cm70GIcS1NdkNrEIIYWWdkj2mrzr3gVlnezVbFH44KBOgCWGvpBkRQjRIYXklyceafxTNr1lfWyZAE8J+STMihGiQ9YdyqTQrdA/0pHszjqL5NesQ360nLnKxpO4j+4QQtkOaESFEgyTuPw80z/Tv19PJ34OwdtaoJlfVWoQQDSPNiBCi3grLKkk+VjWKxjo1u5qsDVFi+nmVKxFCNIQ0I0KIevvhUA4mi0LPIC+6BqgX0VhZo5ptJy6SL1GNEHZHmhEhRL3VTHSm0iiaX+vg5054ex8sCqw9IKNqhLA30owIIerlcqmRLcerIpoYFUfR/JqsVSOE/ZJmRAhRL+uqI5pewd50aeOpdjk1rHOd7Dh1kbziCpWrEULUhzQjQoh6WV0T0ah/4+qVQlq70686qvlBohoh7Io0I0KIOrtcamTriYuAerOuXo91ArREmQBNCLsizYgQos5+OJiD2aLQO9ibzjYU0Vj9EtVckqhGCDsizYgQos6sVxzUnP79etq3cqd/iC+KjKoRwq5IMyKEqJOLJYaaiMZWhvTWZmx1o7RaRtUIYTekGRFC1MkPB3MxWxTC2nnTyd9D7XKuaUx1o7Tr9CVyiySqEcIeSDMihKgT61Traq9FcyPtfN0Y0KEqqlkjN7IKYRekGRFC3FB+iYFtdhDRWMWGW9eqkWZECHsgzYgQ4obWHsjBokB4ex86+LmrXc4NxVTPgbLr9GVyCiWqEcLWSTMihLgh6xTrtji3SG2CfdwY2LEVAElydUQImyfNiBDiui4UG9hxyn4iGitrrdKMCGH7pBkRQlzX2oNVEU2/9j6EtLb9iMbKehUn9cxlsgvLVa5GCHE90owIIa4rcX/1KBobnejsWoJ8XBncyRrVyARoQtgyaUaEENeUV1zBjlOXAPu5X+RK1qjG2lAJIWyTNCNCiGtaeyAHRYH+Ib60b2U/EY3VmL7BaDSwJ7OAcwUS1Qhhq6QZEUJck3VK9bF2FtFYBXq7MrhTa0AmQBPClkkzIoSoVW5RBbtOV0U0Y+wworGStWqEsH3SjAgharUmPRtFgQEdfGnn66Z2OQ12d1gQGg3szSrg7OUytcsRQtRCmhEhRK2sU6nb442rVwrwcmVITVQjo2qEsEXSjAghfiOnsILUM5cB+29G4IqoRu4bEcImSTMihPiNNQeqIpqBHVvR1o4jGqvRYUFoNbAvq4CsSxLVCGFrpBkRQvyGdS0ae5r+/XoCvFwZGuoHyPTwQtiiejUjCxYsIDw8HG9vb7y9vYmMjGTNmjXX3WfTpk0MHDgQV1dXOnfuzMKFC2+qYCFE08ouLHeoiMbKOoNsojQjQticejUj7du351//+hepqamkpqZyxx13MH78eA4ePFjr9qdOnSImJobo6GjS0tJ4/fXXiYuLIyEhoVGKF0I0PuvU6YM7tSLIx1XlahrP3dVRzf6zhWRelKhGCFtSr2Zk3LhxxMTE0L17d7p3785bb72Fp6cn27dvr3X7hQsX0qFDB95991169erF5MmTeeaZZ3j77bcbpXghROOrWYvGga6KAPh7uhDZpSqqkasjQtgWfUN3NJvNfPPNN5SWlhIZGVnrNtu2bWPUqFFXPTd69GgWL15MZWUlTk5Ote5nMBgwGAw1PxcVFTW0zOvKulTGFzsyMZjMTfL7hbA35wvK2ZNZAMCu05c542A3e+6ujp/+vfYIecUVKlcjhO0I8nblqRGdcNHrVHn9ejcj6enpREZGUlFRgaenJ9999x29e/eudducnBwCAwOvei4wMBCTyUR+fj7BwbV/85o9ezZ///vf61tavX22/QyLNp9s8tcRwh45+tWDj7acVrsEIWzKgI6tapZPaG71bkZ69OjB3r17KSgoICEhgUmTJrFp06ZrNiQajeaqnxVFqfX5K82aNYuZM2fW/FxUVERISEh9S72hiZEd2ZRxgYzcYgBauTvx0OAQ9Npr1yaEI3tvwwkAvFz0TBzeUeVqmob1GLUaePG2LipXI4Q68ouNfL07i+qPZO4b0I4BHVqpVk+9mxFnZ2e6du0KwKBBg9i1axdz5szh/fff/822QUFB5ORcPeNhXl4eer0ePz+/a76Gi4sLLi4u9S2t3tq3cuf7aSP4+6qDfLUzi8tllaRlFjD30QgCvR3nxj0h6uLs5TLe23ACjQZ++t2tBDjo/wPtW7kza3k6vYK9+f3onmqXI0Sz23o8n7ile1EUcHPS8Y/xfXhwUON/4a+Pm55nRFGUq+7vuFJkZCTr16+/6rl169YxaNCga94v0txcnXTMvi+cOY/0x8NZx85TlxgzJ5mNGXlqlyZEs7JOlT6kU2uHbUQARvcJQqfVcPB8EafyS9UuR4hmY7YovLP+KI8v3kF+iYHugZ6snDZC9UYE6tmMvP766yQnJ3P69GnS09N544032LhxI48//jhQFa9MnDixZvspU6Zw5swZZs6cyeHDh1myZAmLFy/m1VdfbdyjaATj+7dj1fQoegV7c6nUyFMf7eLfa49gMlvULk2IZmGdKt06dbqjau3hzPAuMgGaaFlyiyp4/MPtxP90DEWBhweF8P3UKLoFeqldGlDPZiQ3N5cnn3ySHj16MHLkSHbs2MHatWu56667AMjOziYzM7Nm+9DQUJKSkti4cSP9+/fnzTffJD4+nvvvv79xj6KRdG7jyXcvDefJYVVZ+YKNJ3hk0XbOF5SrXJkQTSvrUhn7sgrQaqqmTnd0NWvV7JdmRDi+zUcvEDMnme0nL+HurOPdh/vz7wfCcXNWZ+RMbTSK9Y5SG1ZUVISPjw+FhYV4e3s3y2sm7s/mtYT9FBtM+Lo78d8H+zGyV+CNdxTCDr2/6QSz1xwhsrMfXz0/TO1ymtzlUiOD3/oRk0Xhp9/dSpc2nmqXJESjM5ktvLP+KPM3Vt203SvYm/cei6BzM/691/XzW9amuYbY8GBWx0XRt50PBWWVPPtJKm8lHsJokthGOB7rMN5YB49orFp5ODOiqz8ASXJ1RDig7MJyHv1ge00j8vjQDnz30vBmbUTqQ5qR6+jo58G3L0by9IhOAHyQfIqH3t8mq34Kh5J5sYz9ZwvRaqqmTG8pZK0a4ag2HMkjZk4yu05fxtNFz7zHInjr3r64OtlOLPNr0ozcgItex1/H9eH9Jwfi7apnb1YBsfHJ/HAw58Y7C2EHrB/Gwzr74e/Z9EPqbcWo3oHotRqO5BRzPK9E7XKEuGmVZguzkw7z9Me7uFxWSVg7bxLjohgb3lbt0m5ImpE6Gt0niMS4aPqH+FJUYeKFz3bzt5UHZSp5YfeSWlhEY+Xr7kxUt+qoRq6OCDt39nIZD72/jferZxV/angnEl4cTkc/D5UrqxtpRuohpLU7X78QyXPRoQB8vPU0DyzYxpmLMleBsE9nLpaSfq46ounTciIaK+tigIly34iwY+sO5hAbn0JaZgFernoWPjGAv93TR7V1ZhpCmpF6ctZreSO2N4snDcLX3Yn0c4WMjU+RNzNhl6wRzfAu/vi1oIjGalTvIJx0GjJyizlWvSyEEPbCaLLw91UHef6z3RSWV9IvxJekuGjuDrO/q5zSjDTQyF6BJMVFM6hjK4oNJqZ+uYc/rUinolJiG2E/rE10S4torHzcnYju1gaQG1mFfcm8WMYDC7fWLPg4OSqUb16IJKS1u7qFNZA0Izehra8bXz0/jJeqF9v6fHsm987fyskLcjOcsH2n8ks5eL4InVbD6BYY0VhJVCPsTVJ6NrHxyew/W4iPmxMfThzEn8b2xllvvx/p9lu5jXDSafnD3T355JkhtPZw5nB2EePmpvD93nNqlybEdSXVRDR+tPZwVrka9dzZOxBnnZZjeSUclahG2LCKSjN/XnGAl77YQ7HBxMCOrUiaEc2dve1/Qk5pRhrJrd3bsGZGNENDW1NqNDNj6V5eS9hPuVFiG2GbrFOhO/paNDfi4+bELd2rRtXI9PDCVp3KL+X+BVv5bPsZAKbc2oWlzw+jna+bypU1DmlGGlGgtytfTB5K3MhuaDSwdFcWE97bwvE8+bYlbMuJCyUczi5Cr9UwqnfLjWisaiZA238eO1ghQ7QwK/edZ2x8MgfPF9Haw5mPnx7Ma2N64qRznI9wxzkSG6HXaZl5V3c+f3Yo/p4uZOQWM27uFr7dfVbt0oSoYZ0CfXhXf1q14IjGamSvqqjmxIVSMiSqETaiotLMrOXpxH2VRqnRzJDQ1iTFRXNbjwC1S2t00ow0kRFd/UmaEcWIrn6UV5p59Zt9/O7rfZQZTWqXJkTNyJGxfVt2RGPl7erELd2rRtXIWjXCFhzPK2HCe1v4amcmGg1Mv6MrX04eSpCPq9qlNQlpRppQgJcrnz4zlJl3dUergYQ9Z7ln3hYycuSbl1DP8bwSjuQUV0U0fez/xrfGYr13ZnV6tkQ1QlXL95zlnnkpHMkpxt/Tmc+eGcrvRvVA70CxzK857pHZCJ1WQ9zIbnz53DACvV04nlfCPfNSWLozU97whCqso2iiuvnj6y4RjdXIXgE467WcvFDKEfnCIFRQZjTx+2/2MfPrfZQZzQzv4kdSXHTNsgWOTJqRZjKsc9Uf1S3d22AwWXhteTovL9tLiUFiG9G8aiY6k4jmKl6uTtxWHdXInCOiuR3NLWb8vC18s/ssWg28cmd3Pnt2KAHejhnL/Jo0I83Iz9OFj58azB/u7oFOq+H7vee5Z24KB88Xql2aaCGO5RaTkVuMk05G0dSmZlSNRDWimSiKwte7srhnXgrH8koI8HLhi8nDmHFnN3RajdrlNRtpRpqZVqvhpdu6suz5YQT7uHIyv5R751eNHZc3P9HUrDeuRndrg4+7k8rV2J6RvQJx0Ws5lV/KoewitcsRDq7UYOKVZXv5Q8J+KiotRHfzJ2lGNJFd/NQurdlJM6KSQZ2qhmiN7BmA0WThzysOMO2rNIoqKtUuTTgwiWiuz9NFz+3VwyYlqhFN6dD5qtm6V+w9j06r4feje/DJ00Pwb4ELVoI0I6pq5eHMh5MG8UZML/RaDYn7sxkbn0L6WYltROM7mlvMsbwSnHVah5g+uqlIVCOakqIofLHjDBPmb+FkfilB3q4sfX4YU2/virYFxTK/Js2IyjQaDc/d0pmvp0TSzteNzEtl3L9gKx9vOSVvhKJRWac6j+7mj4+bRDTXckfPAFz0Ws5cLOPgeYlqROMprqhk+ldpvPHdAYwmC3f0DCBpRjSDO7VWuzTVSTNiIwZ0aEVSXDSjegdiNFv426pDTPl8N4VlEtuIm6coSs2Q3tgWvhbNjXi46LmjZ3VUky5RjWgcB84VMnZuCqv3Z6PXang9picfThzUohepvJI0IzbEx92J958cyF/H9cZJp+GHg7nEzk0mLfOy2qUJO3c0t4TjEtHU2S9r1UhUI26Ooih8svU0983fypmLZbTzdePrKZE8f0uXFh3L/Jo0IzZGo9Hw9IhQEl4cTofW7py9XM6DC7fxweaT8qYoGixx/3kAbuneBm9XiWhu5I6eAbg6acm8VMaBcxLViIYpLK/kxc/38NeVBzGaLdzVO5DEuCgGdGildmk2R5oRGxXe3pfVcVHE9g3GZFF4K+kwkz9J5XKpUe3ShJ1RFIXV1rVoJKKpE3dnPSN7Vl1BWp1+XuVqhD3am1VAbHwyaw/m4KTT8JexvVn05ECZ9fgapBmxYd6uTsx7LII3J4ThrNfy05E8YuOTST19Se3ShB05klPMyQulOOu1jOzleKt9NhWJakRDKIrCh8kneXDhVs5eLiektRvfThnOM1GhaDQSy1yLNCM2TqPR8OSwjnz30nBC/T04X1jBw4u2M3/jcSwWeYMUN2adL+O27m3wkoimzm7vEYCbk46zl8vZL8PtRR0UlBl57tNU/pl4mEqzwpiwIFZPj6ZfiK/apdk8aUbsRJ+2PqyaHsX4/m0xWxT+szaDpz/excUSg9qlCRumKErNiBAZRVM/bs66mitJMqpG3MjuM5eImZPMj4fzcNZpeXN8H+Y/PkCG0deRNCN2xNNFz7sP9+df9/XFRa9l09ELxMQns+PkRbVLEzbqUHYRp/JLcdFrGdlLRtHU11iJasQNWCwKCzed4KH3t3O+sIJOfu4sf2k4T0Z2klimHqQZsTMajYZHhnTg+2kj6NLGg9wiA49+sJ25Px3DLLGN+JWaiKZHGzxd9CpXY39u6xGAu7OOcwXl7M0qULscYWMulhh45pNd/GvNEcwWhXv6tWV1XDRh7XzULs3uSDNip3oGebNqehT3D2iPRYH/rj/KxCU7uFAssY2ocvVEZ21VrsY+uTrpaq4oJUlUI66w89QlYuKT2ZhxARe9ltn39WXOI/2l6W+gejUjs2fPZvDgwXh5eREQEMCECRPIyMi47j4bN25Eo9H85nHkyJGbKlxUDT/870P9ePvBfrg56dhy/CJj5iSz5Xi+2qUJG3DwfBGnL5ZVRTQ9ZRRNQ1kXFZSoRkBVLDPv52M8smgbuUUGOrfxYMXUETw6pIPEMjehXs3Ipk2bmDp1Ktu3b2f9+vWYTCZGjRpFaWnpDffNyMggOzu75tGtW7cGFy2u9sDA9qycNoIegV7klxh4YvEO3ll/VGKbFs560+UdPQPwkG9rDXZbjzZ4OOs4X1hBmkQ1LdqFYgOTPtrJ2+uOYlHgvoh2rJoWRa9gb7VLs3v1eodau3btVT9/9NFHBAQEsHv3bm655Zbr7hsQEICvr2+9CxR10y3QixVTR/D3VQdZuiuL+J+OsfPUReY8EkGgt6va5YlmpihKzf0iMorm5rg66bizdyDf7z1P4v5smT2zhdp6PJ8Zy/ZyodiAq5OWN8eH8eCgELXLchg3dc9IYWHV2PvWrW+84mBERATBwcGMHDmSDRs2XHdbg8FAUVHRVQ9xY27OOv51fzhzHumPh7OO7SerhpptOnpB7dJEMztwrojMS2W4OmlrFn0TDWeNapLSs2V+nxbGbFH4v/VHeXxx1T153QM9WTUtShqRRtbgZkRRFGbOnElUVBRhYWHX3C44OJhFixaRkJDA8uXL6dGjByNHjmTz5s3X3Gf27Nn4+PjUPEJC5KTXx/j+7Vg1verS4cVSI5OW7OTfa49gMlvULk00E+sU5iN7BuLuLBHNzbqle9VopOzCCtKyZOHKliKvqIInPtzBnJ+OoSjw0KD2fD81im6BXmqX5nA0SgPvyJo6dSqJiYmkpKTQvn37eu07btw4NBoNK1eurPXfDQYDBsMvo0KKiooICQmhsLAQb2/J5uqqotLMPxMP8fn2TAAGdWxF/KMRtPV1U7ky0ZQURSH6Pxs4e7mc+Y8PIKavxDSN4ZVle/ku7RxPj+jEX8f1Ubsc0cQ2H73AK8v2crHUiLuzjrfuDePeiPp91omqz28fH58bfn436MrI9OnTWblyJRs2bKh3IwIwbNgwjh07ds1/d3Fxwdvb+6qHqD9XJx3/nNCXeY9F4OmiJ/XMZWLik/n5SK7apYkmtP9sIWcvl+PmpOP2HhLRNBaJaloGk9nC//5whEkf7eRiqZGeQV6smh4ljUgTq1czoigK06ZNY/ny5fz888+EhoY26EXT0tIIDpZva81lbHhbEuOi6NvOh4KySp75OJX/STpMpcQ2DqlmFE2vANycdSpX4ziiu/vj5aInt8jAnkyJahxRdmE5j32wg/c2nEBR4PGhHVgxdQRd2niqXZrDq1czMnXqVD7//HO+/PJLvLy8yMnJIScnh/Ly8pptZs2axcSJE2t+fvfdd1mxYgXHjh3j4MGDzJo1i4SEBKZNm9Z4RyFuqKOfB9++GMlTwzsBsGjzSR5cuI2zl8vULUw0qitH0YyVeKZRueh13NW7agK01ftlAjRHs+FIHjFzktl5+hKeLnrmPhrBW/f2xdVJGvrmUK9mZMGCBRQWFnLbbbcRHBxc81i2bFnNNtnZ2WRmZtb8bDQaefXVVwkPDyc6OpqUlBQSExO57777Gu8oRJ246HX87Z4+LHxiIN6uevZmFRAzJ5kfDuaoXZpoJPvOFnKuoBx3Zx23SUTT6KzDpCWqcRyVZguzkw7z9Me7uFxWSVg7b1ZPj2JcP5m1uDk1+AbW5lTXG2BE3WVdKmPaV2nsq57E6ekRnZg1phfOelkhwJ69lXiID5JPMa5fW+Y+GqF2OQ7HYDIz6J8/Ulxh4usXIhkSeuNpDYTtOldQzvQv97AnswCAp4Z3YlZMT1z0cjWksTTpDazC/oW0duebFyJ5Lrrqvp+PtpzmgYVbybwosY29umqiM4lomoSLXseo3kEAJO4/r3I14masP5RLzJxk9mQW4OWqZ+ETA/jbPX2kEVGJNCMtmLNeyxuxvflw4iB83Z3Yf7aQ2PhkWRDMTqVlFXC+sAIPZx239WijdjkOa6w1qjmQI0su2CGjycI/Vh3iuU9TKSyvpF97H5Liork7TBp4NUkzIrizdyBJcdEM7NiKYoOJl77Yw59XHKCi0qx2aaIerFdF7uwdKDfdNaERXf3xdtVzodjArtOX1C5H1EPWpTIeXLiVJVtOAfBsVCjfTBlOSGt3lSsT0owIANr6urH0+WG8eFsXAD7bfob75m/lVP6NF0EU6rNYlJorWhLRNC1nvZbRfaxRjVxFtBdrD2QTE5/MvrOF+Lg58cHEQfx5bG+5T85GyFkQNZx0Wv54d08+fnowrT2cOZRdxNj4ZL7fe07t0sQNpGVdJruwAk8XPbd0l4imqcVURzVrJKqxeRWVZv76/QGmfL6H4goTAzr4kjQjumaYtrAN0oyI37itRwBJcdEMCW1NqdHMjKV7mbV8v8Q2Nsw678WdvQIkomkGI7r44+PmRH6JgZ2nJKqxVafzS7l/wVY+2XYGgBdu7cyyFyJpJ0ti2BxpRkStgnxc+XLyUKbf0RWNBr7amcX4eVs4nleidmniVywWhTXpVXPFxIbL3AjNoSqqqfpmnZguo2ps0cp95xk7N4WD54to7eHMR08PZtaYXjjp5GPPFslZEdek12n53agefPbMUPw9XcjILWbc3BQSdp9VuzRxhT2Zl8kpqsDLRU90N3+1y2kxrI3f2gM5siK2DamoNDNreTpxX6VRYjAxpFNrkuKiZZ0mGyfNiLihqG7+JM2IYngXP8orzfzum328+s0+yowmtUsT/BLR3CWjaJrV8C5++Lo7kV9ilKjGRpy4UMKE97bw1c5MNBqYfkdXvnxuKEE+rmqXJm5AmhFRJwFernz27FBm3tUdrQa+3X2W8fO2cDS3WO3SWrSrRtGEyyia5uSk03J39aia1TI3j+q+SzvLuLkpHMkpxt/TmU+fGcLvRvVAL7GMXZCzJOpMp9UQN7IbX0weRoCXC8fySrhnXgrLdmViB6sKOKTUM5fJKzbg5aonSiKaZmdtACWqUU+50czvv9nHK8v2UWY0E9nZj6S4aKK7yagyeyLNiKi3yC5+JM2IJrqbPxWVFv6YkM4ry/ZSYpDYprlZpyQf1TtIprFWQWRnP1q5O3Gp1Mj2kxLVNLejucXcMy+Fb3afRaOBl+/sxueThxLgLbGMvZFmRDSIv6cLnzw9hD/c3QOdVsOKvee5Z24Kh84XqV1ai2G2KCQdqBpFM1YiGlXoddqaacRlVE3zURSFr1OzuGdeCsfySmjj5cIXk4fy8p3d0Wk1apcnGkCaEdFgWq2Gl27rytLnhxHs48rJ/FImzN/C59vPSGzTDHadvsSFYgPernpGdJWIRi3WGW/XHsihUqKaJldqMPG7r/fxh2/3U1FpIbqbP2tmRDO8i/w/YM+kGRE3bXCn1iTGRXNHzwCMJgt/WnGAaV+lUVxRqXZpDs06FfmoPkEypbWKhnVuTWsPZy6XVbL95EW1y3Foh7OLGDcvheVp59Bq4Peje/DJ00Pw93RRuzRxk+QdTDSK1h7OfDhxEK/H9ESv1ZC4P5uxc1NIP1uodmkOyWxRWHPAOtGZRDRqqopqZK2apqQoCl/uyGTCe1s4eaGUIG9Xlj4fydTbu6KVWMYhSDMiGo1Wq+H5W7rw9ZSq6ZbPXCzj/gVb+XjLKYltGtnOU5fILzHg4+bECLk8rbqx1qjmoEQ1ja24opK4pXt5/bt0DCYLt/doQ9KMquUqhOOQZkQ0ugEdWpEUF82o3oEYzRb+tuoQL36+h8JyiW0ai/VmydF9AiWisQFDQlvj7+lMQVklW09IVNNYDpwrZNzcFFbtO49eq2HWmJ4snlS1kKdwLPIuJpqEj7sT7z85kL+O642TTsPagznExiezN6tA7dLsnslsYe0BWYvGllwd1ciompulKAqfbjvNffO3cvpiGe183Vj2QiQv3NpFYhkHJc2IaDIajYanR4SS8OJwOrR25+zlch5YsJUPk09KbHMTqiIaI77uTgzv4qd2OaJabN+qxvCHg7kYTRLVNFRheSUvfbGHv3x/EKPZwp29AkmMi2Jgx1ZqlyaakDQjosmFt/dldVwUMX2DMFkU/pl4mOc+TaWgzKh2aXbJOvX43X2CZAVSG1IV1bhQWF7JlhP5apdjl/ZlFTB2bjJrDuTgpNPw57G9+WDiQHzdJZZxdPJOJpqFt6sT7z02gDcnhOGs1/Lj4Txi5iSz+4zMWlkfV0c0MorGlui0GmL6yqiahlAUhcUpp3hg4VayLpUT0tqNb6cM59moUDQaiWVaAmlGRLPRaDQ8Oawj3700nFB/D84XVvDQ+9tZsPEEFovENnWx/eQlLpUaaeXuRGRniWhsTUz1qJp1B3MkqqmjgjIjz326mzdXH6LSrDAmLIjV06PpF+KrdmmiGUkzIppdn7Y+rJoexT392mK2KPx77RGe+WQXF0sMapdm8xKtEU1YkKxGaoMGd2pNGy8XiipMbDkuUc2N7D5zmdj4FH48nIuzTss/xvdh/uMD8HFzUrs00czk3UyowtNFz5xH+jP7vr646LVszLhATHwyO2QGy2uqimiqmhHrzZLCtui0GmKqR9WslqjmmiwWhfc3neDh97dxrqCcTn7uLH9pOBMjO0ks00JJMyJUo9FoeHRIB76fNoIubTzILTLw6AfbmfvTMcwS2/zGtpMXuVxWSWsPZ4Z1lgmfbJV1uPW6QzkYTGaVq7E9l0qNPPvJLmavOYLJojCuX1tWTY8irJ2P2qUJFUkzIlTXM8ibldOiuG9AOywK/Hf9USYt2cmFYoltrmS9KVIiGts2qGMrArxcKK4wkXJMopor7Tx1iZg5yWzIuICLXsv/3NuX+Ef64+UqsUxLJ+9owiZ4uOh556H+/O8D4bg56Ug5nk9MfDJbJXcHoNJsYe3BqlE01qnHhW3SajU1N7LKqJoqFovCexuO8+gH28kpqqBzGw9WTB3BY0M7SCwjAGlGhI15cFAIK6eNoHugJxeKDTy+eAfvrD/a4mObrScuUlBWib+ns6zJYQfGVg+7Xn8ol4rKlh3V5JcYmPTRTv73hwzMFoX7ItqxaloUvYK91S5N2BBpRoTN6RboxfdTo3h4UAiKAvE/HePxD7eTW1ShdmmqsU4xLhGNfRjQoRVB3q4UG0wkt+CoZuuJfMbMSSb5WD6uTlr+80A4/32oHx4uerVLEzZG3tWETXJz1vHvB8J59+H+uDvr2H6yKmvefPSC2qU1O6PJwg8HcwEZRWMvro5qWt5aNWaLwrs/HuWJD3dwodhAtwBPVk6L4qFBIRLLiFrVqxmZPXs2gwcPxsvLi4CAACZMmEBGRsYN99u0aRMDBw7E1dWVzp07s3DhwgYXLFqWCRHtWD296pLuxVJj9eXeI5ha0DLtW07kU1heib+ni0Q0diQ2vGqI74+H81pUVJNXVMGTi3fw7o/HsCjw0KD2rJwWRfdAL7VLEzasXs3Ipk2bmDp1Ktu3b2f9+vWYTCZGjRpFaWnpNfc5deoUMTExREdHk5aWxuuvv05cXBwJCQk3XbxoGTq38eS7l4bz+NAOKAq8t+EEj36wnezCcrVLaxZJ1TdBjgkLQicrltqNiJBWBPu4UmIwtZgresnHquYL2nriIu7OOt55qB//eaAfbs46tUsTNk6j3MTyqRcuXCAgIIBNmzZxyy231LrNH//4R1auXMnhw4drnpsyZQr79u1j27ZtdXqdoqIifHx8KCwsxNtbbnpqyVbvP89rCemUGEy0cnfinYf6c3vPALXLajJGk4VB/1xPUYWJpc8PY5hMAW9X3lx9iMUppxjfvy1zHolQu5wmYzJbePfHY7y38TiKAj2DvJj32AC6BniqXZpQWV0/v2/qnpHCwkIAWre+9qXjbdu2MWrUqKueGz16NKmpqVRWVta6j8FgoKio6KqHEABjw9uyenoUYe28uVxWydMf72J20mEqHTS22XI8n6IKE228XBjcSSIae2NdzPBHBx5Vk1NYwWMf7GDehqpG5LGhHVgxdYQ0IqJeGtyMKIrCzJkziYqKIiws7Jrb5eTkEBgYeNVzgYGBmEwm8vNrv8t89uzZ+Pj41DxCQkIaWqZwQJ38PUh4cThPDe8EwPubT/LQ+9s4e7lM3cKagHVK8RiJaOxSRIgv7XzdKDWa2ZjheFHNhow8YuKT2Xn6Ep4ueuIfjeB/7u2Lq5PEMqJ+GtyMTJs2jf379/PVV1/dcNtf3z1tTYaudVf1rFmzKCwsrHlkZWU1tEzhoFz0Ov52Tx8WPjEAL1c9aZkFxMansK56YjBHYDCZWXeo6nisU4wL+6LRaIjpW3Ujq3WRQ0dQabYwe81hnv5oF5dKjfRp683q6sUvhWiIBjUj06dPZ+XKlWzYsIH27dtfd9ugoCBycq7+gMjLy0Ov1+PnV3v+7eLigre391UPIWpzd1gwSXFVy40Xllfy/Ge7+fuqgw6xfHvKsXyKK0wEeLkwqGMrtcsRDWRtJH86nEu50f6jmnMF5TyyaDvvbzoJwKTIjiS8OJxO/h4qVybsWb2aEUVRmDZtGsuXL+fnn38mNDT0hvtERkayfv36q55bt24dgwYNwslJ1iMQNy+ktTvfvBDJ5Kiqv8ePtpzmgYVbybxo37GNdSrxmL7BaCWisVv92vvQzteNMqOZjRl5apdzU9YfyiVmTjK7z1zGy1XPgscH8PfxYRLLiJtWr2Zk6tSpfP7553z55Zd4eXmRk5NDTk4O5eW/DLGcNWsWEydOrPl5ypQpnDlzhpkzZ3L48GGWLFnC4sWLefXVVxvvKESL56zX8qexvflw4iB83JzYf7aQ2Phk1tjppfGKSjPrD1VNdGadWlzYJ41GU3MOV9vp36PRZOHN1Yd47tNUCssr6dfeh8Tp0YyRdZJEI6lXM7JgwQIKCwu57bbbCA4OrnksW7asZpvs7GwyMzNrfg4NDSUpKYmNGzfSv39/3nzzTeLj47n//vsb7yiEqHZn70CSZkQzsGMrig0mXvxiD3/5/oDdjWRIPpZPscFEkLcrAzpIRGPvrLOx/nw4z+6imqxLZTz4/jYWp5wC4JkRoXwzZTgd/NxVrkw4knotEFCXKUk+/vjj3zx36623smfPnvq8lBAN1s7XjaXPD+O/646ycNMJPt12ht1nLjPvsQGE2kmunVT9DXpM3yCJaBxAeHsf2rdy4+zl8qoRKHZyRWHtgWx+/+1+iitM+Lg58faD/bird+CNdxSinmRtGuGQnHRaXhvTk4+eHkxrD2cOni9ibHwyK/fZ/johEtE4Ho1GUzPniPVeIFtmMJn56/cHmPL5HoorTAzo4EtiXJQ0IqLJSDMiHNrtPQJIiotmSKfWlBrNxH2Vxqzl6TYd22w+eoESg4lgH1ciQiSicRRjqxc5/OlILmVGk8rVXNvp/FLuX7CVT7adAeCFWzuz7IVI2reSWEY0HWlGhMML8nHly+eGMv2Ormg08NXOTCa8t4XjeSVql1Yr63wUMorGsYS186ZDa3cqKi38fMQ2R9Ws3n+esXNTOHCuiFbuTnz01GBmjemFk04+KkTTkr8w0SLodVp+N6oHnz4zBH9PZ47kFHPPvBSW7zmrdmlXqag082N1RBMrEY1DseWopqLSzOvfpTPtyzRKDCYGd2pF0oxoh173SdgWaUZEixLdrQ1JcdEM7+JHmdHMzK/38ftv9tnMZfONGRcoNZpp5+tGRIiv2uWIRhZrHVVzJI9Sg238zZ24UMKE97bw5Y5MNBqYdntXvnpuGME+bmqXJloQaUZEixPg7cpnzw7llTu7o9XAN7vPMn7eFo7mFqtd2hURTdA1l0sQ9qtPW286+bljMFn4yQaimu/SzjJubgpHcorx83Dm02eG8OroHugllhHNTP7iRIuk02qYcWc3vpg8jAAvF47llXDPvBS+3pVVpyHsTaHcaOanw9aIRtb4cERXRzXqjewqN5r5w7f7eGXZPsqMZiI7+7FmRjTR3dqoVpNo2aQZES1aZBc/kmZEE93Nn4pKC39I2M/Mr/epcgl9Y0YeZdURTb/2Ps3++qJ5WOcY2ZBRNWqquR3LLWb8eyl8nXoWjQZmjOzG55OHEuDt2uy1CGElzYho8fw9Xfjk6SH8fnQPdFoN36WdY9zcFA5nFzVrHdaIJjY8WCIaB9Y72JtQfw+MJkvNlbDm8k1qFuPmpXA0t4Q2Xi588exQXrmrOzoZtSVUJs2IEIBWq2Hq7V1Z+vwwgrxdOZlfyvj3tvDFjjPNEttURTRV9xDE2snsnKJhNBpNzTlurlE1pQYTM7/ey++/3U9FpYXobv5VN3J39W+W1xfiRqQZEeIKgzu1rhrS2KMNRpOFN747wPSv0iiuqGzS192QkUd5pZn2rdwIl4jG4VnvG9l49EKT/20dySmqHsZ+Dq0Gfj+6B588PYQ2Xi5N+rpC1Ic0I0L8SmsPZxZPGszrMT3RazWs3p9dPRFUYZO9pvUbskQ0LUPPIC86t7FGNU0zqkZRFL7amcn4eVs4caGUIG9Xlj4fydTbu8pkesLmSDMiRC20Wg3P39KFZS9E0s7XjTMXy7hv/lY+2Xq60WObMqOJn45Ur0XTV0bRtAQajYax1VHN6iaIaoorKolbupdZy9MxmCzc1qMNSTOiGRLautFfS4jGIM2IENcxsGOrmgXCjGYLf115kBc/30NheeNdWv/5SB4VlRY6tHYnrJ13o/1eYdusw7c3H71AUSNGNQfOFTJubgqr9p1Hp9Uwa0xPlkyqWjBSCFslzYgQN+Dr7syiJwfyl7G9cdJpWHswh9j4ZPZmFTTK75eIpmXqHuhJ1wBPjGZLzRIAN0NRFD7bdpr75m/l9MUy2vq48vULkbxwaxeJZYTNk2ZEiDrQaDQ8ExXKt1OGE9LajbOXy3lw4VY+TD55U7FNqcFUs2iajKJpWRpzVE1RRSVTv9zDn78/iNFs4c5egSTNiGZgR1n1WdgHaUaEqId+Ib6snh7NmLAgKs0K/0w8zHOf7qagzNig3/fTkTwMJgsd/dzp01YimpbGOqom+Vh+g6O/fVkFxMYnk5Seg5NOw59ie/HBxIH4ukssI+yHNCNC1JOPmxPzHx/Am+P74KzT8uPhXGLmJLP7zOV6/64ka0TTVyKalqh7oBfdGhjVKIrCkpRTPLBwK1mXymnfyo1vpgxncnRn+VsSdkeaESEaQKPR8GRkJ5a/NJxOfu6cL6zgofe3sXDTCSyWusU2JQYTGzKqI5pwiWhaqpq1atLrHtUUlBl5/rPd/GP1ISrNCnf3CSIxLpr+stKzsFPSjAhxE8La+bBqehTj+rXFbFH415ojPPPJLi6WGG6470+HczGYLIT6e9A7WCKalsp630jysQsUlt04qtmTeZnY+BTWH8rFWaflH+P7sOCJAfi4OTV1qUI0GWlGhLhJXq5OxD/Sn9n39cVFr2VjxgVi4pPZeerSdfdLlIhGAN0CvegR6EWlWWHdoZxrbmexKCzafIKHFm7jXEE5Hf3cWf7ScCZGdpK/H2H3pBkRohFoNBoeHdKBFVNH0LmNB7lFBh5ZtI15Px+rNbYprqhk49ELgEQ04sZRzaVSI5M/TeV/ko5gsiiMDQ9m9fQowtrJ0gHCMUgzIkQj6hXszappUdwX0Q6LAm+vO8qkj3Zyofjq2Oanw3kYTRY6t/GgZ5CXStUKWxFTHdWkHMv/zcisXacvERufzM9H8nDWa/mfe/sy99EIvFwllhGOQ5oRIRqZh4ue/z7Uj/88EI6rk5bkY/nExCez9Xh+zTbWKcDHSkQjgK4BnvQM8sJkUVh3sGpUjcWi8N6G4zyyaDvZhRV09vfg+6kjeGxoB/mbEQ5HmhEhmoBGo+GhQSGsmhZF90BPLhQbeHzxDv5v/VEKyoxsroloZC0aUcV6I+vq9GzySwxM+mgn//tDBmaLwr0R7Vg1PYpecqOzcFAapbFX/WoCRUVF+Pj4UFhYiLe3/M8o7Eu50cxfVx7g69SzVz3fpY0HP868Vb7lCgBOXChh5H83AeCs12I0WXB10vKPe8J4cFB7+TsRdqmun99yZUSIJubmrOM/D/Tj/x7uh7uzruZ5Hzcn+YARNTr5edT8t9FkoVuAJyunRfHQ4BD5OxEOT5oRIZrJvRHt+fK5YTU/78ks4O0fMjCZLSpWJWxBXnEFTy7ecdVz308bQfdAublZtAzSjAjRjE7klVz187wNx3nsgx1kF5arVJFQW8qxfGLmJLP1xMWa53RaDRWV0qSKlkOaESGakXUeiZfv7MbcRyPwdNGz8/QlYuYks6F69V7RMpjMFv67LoMnl+wgv8RIzyAvfpx5K33aemO2KPxw8NoToAnhaKQZEaKZFJZVknysehRN32DG9WtbPXGVN5fLKnn6413MTjpMpcQ2Di+nsILHPtzB3J+PoyjUTJjXNcDzlwnQ9td9rRoh7F29m5HNmzczbtw42rZti0ajYcWKFdfdfuPGjWg0mt88jhw50tCahbBL6w7lUGlW6BHoRbfqewE6+XuQ8OJwJkV2BOD9zSd5+P2q6b6FY9qYkVezXICHs474RyOYfV9fXJ2qbm62DvHdeiK/TmscCeEI6t2MlJaW0q9fP+bNm1ev/TIyMsjOzq55dOvWrb4vLYRds0Y0v57+3UWv4+/jw1jw+AC8XPXsySwgZk4y6+u5pLywbZVmC/9ac4SnPtrFpVIjfdp6szoumnv6XT3XTEc/D/q288GiwFqJakQLoa/vDmPGjGHMmDH1fqGAgAB8fX3rvZ8QjqCgzEjKsaoZWK1Tf//amL7BhLXzYdqXe9h3tpDnPk3lmRGhvDamJ856SVTt2fmCcqZ/lcbuM5cBmBjZkddjetVcDfm1mL7BpJ8rJHF/No8P7dicpQqhimZ7h4uIiCA4OJiRI0eyYcOG625rMBgoKiq66iGEPVt3MBeTRaFnkBddAzyvuV1Ia3e+mTKcZ6NCAViy5RQPLtxK1qWy5ipVNLIfD+USE5/M7jOX8XLRM//xAfxjfNg1GxH4JarZfvIi+RLViBagyZuR4OBgFi1aREJCAsuXL6dHjx6MHDmSzZs3X3Of2bNn4+PjU/MICQlp6jKFaFI1Ec01ropcyVmv5c9je/PBxEH4uDmx72whMfHJrD0gNzTaE6PJwj9XH2Lyp6kUlFUS3t6HxLjoa14Zu1IHP3fC21dHNQckqhGO76amg9doNHz33XdMmDChXvuNGzcOjUbDypUra/13g8GAwfDLt4GioiJCQkJkOnhhly6XGhn81o+YLAo//e5WurS59pWRXztXUM70L/ewJ7MAgEmRHZl1ncv7wjZkXSpj2ldp7MsqAGhQ3Pb+phPMXnOEyM5+fPX8sBvvIIQNsunp4IcNG8axY8eu+e8uLi54e3tf9RDCXq07lIPJotAr2LtejQhAO183lr0QyQu3dgbgk21nuH/BVk7nlzZFqaIRrD2QQ2x8MvuyCvB21bPoyYH8ZVzvet/3Y72CsuPURfKKK5qiVCFshirNSFpaGsHBN75UKYQjWF09X8TY8Ib9zTvptMwa04uPnhpMK3cnDp4vYuzcFFbtO9+YZYqbZDCZ+dvKg0z5fDdFFSYiOviSNCOaUX2CGvT7Qlq70y/EF4sCP0hUIxxcvZuRkpIS9u7dy969ewE4deoUe/fuJTMzE4BZs2YxceLEmu3fffddVqxYwbFjxzh48CCzZs0iISGBadOmNc4RCGHDLpUaa6b5rsu9Atdze88AkmZEM6RTa0oMJqZ/lcas5elUVJobo1RxE85cLOWBBdv4eOtpAF64pTNfvxBJ+1buN/V7x1b/zayWCdCEg6t3M5KamkpERAQREREAzJw5k4iICP7yl78AkJ2dXdOYABiNRl599VXCw8OJjo4mJSWFxMRE7rvvvkY6BCFs1w8HczBbFPq09SbU3+PGO9xAsI8bXz43lGm3d0Wjga92ZjLhvS2cuFBy451Fk1i9/zyx8SmknyuklbsTS54axKyYXjjpbv7C85i+VVdVdp6+RF6RRDXCcd3UDazNpa43wAhha574cAcpx/P5w909eOm2ro36u5OPXeCVZXvJLzHi7qzjrXvDuDeifaO+hri2ikozb64+xBc7qr58De7UivhHIwj2cWvU17l3/hbSMgv4+z19mDS8U6P+biGamk3fwCpES3CxxMDWE1UTndVlSG99RXdrQ1JcNJGd/Sgzmnll2T5+/80+yo0S2zS1kxdKuHf+Vr7YkYlGA1Nv78JXzw1r9EYEfvnbkbVqhCOTZkSIJrL2YA4WBcLaedPR7+YjmtoEeLvy+eShvHxnNzQa+Gb3We6Zl8LR3OImeT0BK9LOMXZuCoezi/DzcOaTp4fw+9E90TdCLFObMdXNyK4zl8iVqEY4KGlGhGgiSTUTnbW9wZY3R6fV8PKd3fli8lDaeLlwLK+Ee+al8HVqFnaQwtqNcqOZP367n5eX7aXMaGZY59YkzYjmlu5tmvR12/m6MaCDL4oCa9Ll6ohwTNKMCNEE8ksMbKseRdMUEU1thnfxZ82MaKK7+VNRaeEP3+7nd1/vo9RgapbXd2TH84qZ8N4WlqVmodHAjJHd+GLyMAK9XZvl9WPDqxraRGlGhIOSZkSIJrD2QFVEE97ehw5+Nze8sz78PV2qY4MeaDWwPO0c4+ZVRQqiYb7dfZZxc7eQkVtMGy8Xvnh2KK/c1R2dVtNsNcRUj6rZdfoyOYUS1QjHI82IEE3AerNhc10VuZJWq2Hq7V1Z+nwkQd6unLxQyoT3tvDljkyJbeqhzGhi5td7efWbfZRXmonq6k9SXDTDu/o3ey3BPm4M6tgK+CX+E8KRSDMiRCPLK65gx6nGmejsZgwJrbqn4bYebTCYLLz+XTpxS/dSXFGpWk324khOEePmprB8zzm0Gnh1VHc+fWYIbbxcVKsptnoGX4lqhCOSZkSIRvZDdUTTL8SXkNbNF9HUprWHM0smDWbWmJ7otBpW7TvPuLkpHDhXqGpdtkpRFJbuzGT8vC2cuFBKoLcLXz03jGl3dEPbjLFMbcaEBaPRwO4zlzlfUK5qLUI0NmlGhGhkNWvRqHhV5EparYYXbu3C1y9E0s7XjdMXy7hv/lY+3XZaYpsrlBhMzFi6l9eWp2MwWbi1e9U8LkM7+6ldGgBBPq4M7tgakKhGOB5pRoRoRHlFFew8fQn4ZSpvWzGwYysS46K4s1cgRrOFv3x/kJe+2ENhucQ2B88XMm5uCiv3nUen1fDamJ589NRg/DzVi2VqY72RVaIa4WikGRGiEa09mIOiQP8Q35teJK0p+Lo788HEgfx5bG+cdBrWHMhh7Nyq5e5bIkVR+Gz7Ge6dv5VT+aW09XHl6xeGMeXWLqrHMrUZ07cqqknLLOCcRDXCgUgzIkQjqolowm0joqmNRqPh2ahQvp0ynJDWbmRdKueBhVtZnHKqRcU2RRWVTPsyjT+vOIDRZOHOXgEkxkUzsDoKsUWB3q4M7lRVn0yAJhyJNCNCNJLcogp21UQ0ttuMWPUL8WX19GjGhAVRaVZ4c/Uhnvt0NwVlRrVLa3L7zxYwNj6FxPRs9FoNf4rtxQcTB9HKw1nt0m7I2uiulrVqhAORZkSIRrImPRtFgQEdfGnn2/gLpjUFHzcn5j8+gH+M74OzTsuPh3OJjU9h95nLapfWJBRF4aMtp7h/wVYyL5XRvpUb3744nMnRndFobC+Wqc3dYUFoNLA3q4CsS2VqlyNEo5BmRIhGYr2p0Dp1t73QaDRMjOzE8peG09HPnXMF5Tz8/jbe33QCi8VxYpvCskpe+Gw3f191iEqzwt19gkiMi6Z/iK/apdVLgJcrQ0Oro5oDcnVEOAZpRoRoBDmFFew6XXU1IcbGRtHUVVg7H1ZPj2JseDAmi8LsNUd49pNdXCq1/9gmLfMyMfHJrDuUi7NOy9/v6cOCJwbg4+akdmkNUrNWjUQ1wkFIMyJEI7DO+zCoYyuCfewjoqmNl6sTcx+N4H/u7YuzXsuGjAvEzElm56lLapfWIIqi8MHmkzy4cBvnCsrp6OdOwovDmTS8k93EMrW5u08QWg3sO1soUY1wCNKMCNEIfolobP/G1RvRaDQ8NrQD308dQec2HuQUVfDoB9t5b8Nxu4ptLpcamfxJKm8lHcZkUYgND2b19Cj6tvdRu7Sb1sbLhWHVk7HJnCPCEUgzIsRNOl9QXnPD55gw+29GrHoFe7NqWhT3RrTDbFH43x8ymPTRTvJLDGqXdkOppy8RE5/MT0fycNZreeveMOY9GoGXq33GMrWxrnskUY1wBNKMCHGT1hzIAWBwp1YE+biqXE3j8nDR885D/fjPA+G4OmlJPpbPmDnJbD2Rr3ZptbJYFOZvPM7Di7aTXVhBZ38PVrw0gseHdrTrWKY2d4dVRTXp5wrJvChRjbBv0owIcZMS958HINYO5hZpCI1Gw0ODQlg5LYpuAZ5cKDbwxIc7ePfHo5htKLbJLzHw1Me7+M/aDMwWhQn927JyehS923qrXVqT8Pd0IbKLRDXCMUgzIsRNOFdQzp7MAjQa+5jo7GZ0D/Ri5bQoHhrUHosC7/54jCcX7yCvqELt0th+8iIxc5LZfPQCrk5a/nN/OP/3cH88XfRql9akYvtWj6pJP69yJULcHGlGhLgJ1im5B3dqTaC3Y0U0tXFz1vGfB/rxzkP9cHfWsfXERWLik0k+dkGVeswWhfifjvHYB9vJKzbQNcCT76dG8dDgEIeLZWozuk8gOq2GA+eKOJ1fqnY5QjSYNCNC3AR7WIumKdw3oD0rp0XRM8iL/BIjE5fs5O0fMjCZLc1WQ15xBROX7OCd9UexKPDgwPasnDaCHkFezVaD2vw8XRguUY1wANKMCNFAWZfK2JtVFdHcHWafE53djK4BnqyYOoLHhnZAUWDehuM89sEOcgqbPrbZcjyfmDkpbDl+ETcnHe881I//fbAf7s6OHcvUJlZG1QgHIM2IEA1knYp7aGhrArwcP6KpjauTjv+5ty/xj0bg6aJnZ/WQ2g0ZeU3yemaLwjvrMnhi8Q7ySwz0DPJi1fQo7hvQvklezx6M7hOETqvhUHYRJy+UqF2OEA0izYgQDWT9Jmpva9E0hXv6tWXV9Cj6tPXmUqmRpz/axew1h6lsxNgmt6iCxz7YTvzPx1EUeHRICCumjqBrgGejvYY9auXhzIiu/sAvMwELYW+kGRGiAbIulbHvbCFaTdXU3AJC/T1IeHE4EyM7AvD+ppM8smg75wrKb/p3bzp6gTFzktlx6hIezjrmPNKf2feF4+qku+nf7Qhiq9dDSkzPUbkSIRpGmhEhGsD6DXRoqB9tvFxUrsZ2uDrp+Mf4MBY8PgAvVz27z1wmZk4y6w/lNuj3mcwW/r32CJOW7ORSqZHewd6sjotmfP92jVy5fRvVOwi9VsPh7CJOSFQj7JA0I0I0gCOtRdMUxvQNJnF6NP3a+1BYXslzn6by5upDGE11j23OF5TzyKLtLNh4AoAnh3Vk+UvDCfX3aKqy7dZVUY3cyCrskDQjQtRT5sUy9lsjmhY4iqauOvi5882U4TwzIhSAxSmnePD9bXVaZfanw7nExCeTeuYyXi565j8+gDcnhEkscx3WxliG+Ap7VO9mZPPmzYwbN462bdui0WhYsWLFDffZtGkTAwcOxNXVlc6dO7Nw4cKG1CqETbC+2Ud28cPfUyKa63HWa/nLuN58MHEQPm5O7MsqICY+mbUHav/ANJosvJV4iGc/SaWgrJLw9j4kxkXXLAonrm107yCcdBqO5BRzPK9Y7XKEqJd6NyOlpaX069ePefPm1Wn7U6dOERMTQ3R0NGlpabz++uvExcWRkJBQ72KFsAXWqbetU3GLG7urdyCJcVFEdPCluMLElM/38NfvD2AwmWu2ybpUxkPvb+OD5FMAPDMilG+mRNLBz12tsu2Kj7sTUdVRTeJ+uZFV2Jd6zxA0ZswYxowZU+ftFy5cSIcOHXj33XcB6NWrF6mpqbz99tvcf//99X15IVR1Or+UA+eK0Gk1jO4TqHY5dqV9K3e+fiGSt9dl8P6mk3yy7Qy7My8z79EBZOQW8/tv9lFUYcLbVc/bD/ZjlIxSqrfY8LZsyLhAYvp5ZtzZTe1yhKizJp+ucNu2bYwaNeqq50aPHs3ixYuprKzEycnpN/sYDAYMBkPNz0VFRU1dphB1Yo1ohnfxw08imnpz0mmZNaYXw0L9mPn1Xg6cK+K2tzfW/HtEB1/mPhpB+1ZyNaQh7uodiJNOw9HcEo7mFtM9sOVMjS/sW5PfwJqTk0Ng4NXfIAMDAzGZTOTn59e6z+zZs/Hx8al5hISENHWZQtRJzURncg/DTbm9ZwALnxj4m+c/e3aoNCI3wcfNiVu6tQFkenhhX5plNM2vV89UFKXW561mzZpFYWFhzSMrK6vJaxTiRk7ll3IouyqikQjh5iTuz2byJ6m/ef6BBVtlnoybZL3ZV2ZjFfakyZuRoKAgcnKuvpkqLy8PvV6Pn59frfu4uLjg7e191UMItSVdEdG09nBWuRr7VFFp5k8r0pn65R6KDSYGdWzFtll38OkzQ/DzcOZITjHj5qawIu2c2qXarTt7B+Ks03IsryqqEcIeNHkzEhkZyfr16696bt26dQwaNKjW+0WEsFWrqy97j5WJzhrk5IUS7p2/lc+3ZwLw0m1dWPr8MIJ93LilexvWzIhmWOfWlBnNvLxsL3/8dj/lRvMNfqv4NR83J27pXjWqZrVENcJO1LsZKSkpYe/evezduxeoGrq7d+9eMjOr3mBmzZrFxIkTa7afMmUKZ86cYebMmRw+fJglS5awePFiXn311cY5AiGawYkLJRzOLkKv1TCqt0Q09fX93nOMm5vC4ewi/Dyc+eSZIfzh7p7odb+8BQV4u/LF5GHMGNkNjQaWpWYx/r0Ujsm3+3qrmQBt//maWFwIW1bvZiQ1NZWIiAgiIiIAmDlzJhEREfzlL38BIDs7u6YxAQgNDSUpKYmNGzfSv39/3nzzTeLj42VYr7Ar1im2R3T1p5VENHVWbjTzWsJ+ZizdS6nRzLDOrUmaEc2t3dvUur1Oq+GVu7rzxbNDaePlwtHcEsbNS+GbVLlvrD7u7BWIs17LiQulZEgzJ+yARrGDtrmoqAgfHx8KCwvl/hGhirvf3cyRnGL+80A4Dw2S0V11cTyvmKlfpJGRW4xGA9Pv6MaMkd3QaWu/cf3XLhQbmPn1XpKPVY26u29AO94cH4aHS5PPSOAQnvs0lfWHcpl+R1d+N6qH2uWIFqqun9+yNo0QN3A8r5gjOcU46TSMloimTr7dfZZxc7eQkVuMv6cLXzw7lJl3da9zIwLQxsuFT54ewqujuqPVwPI957hnXgpHcmTeoboYWxPVZEtUI2yeNCNC3IB1au2orv74uMtN19dTZjTxu6/38eo3+yivNBPV1Z81M6IZXj1NeX1ptRqm3dGNr54bRqC3CyculDJ+3ha+2pkpH7A3MLI6qjmZX8rhbIlqhG2TZkSIG6hZiyZc1qK5noycYu6Zt4WEPWfRauB3d3Xnk2eG0Mbr5meqHdrZj6S4aG7r0QaDycKs5enELd1LcUVlI1TumDxd9NxWfW+O9W9YCFslzYgQ13Est5ijuSU46TTc1VvWoqmNoigs25XJPfNSOJ5XQqC3C18+N4zp9bg/pC78PF1YMmkwr43piU6rYdW+84ybm8KBc4WN9hqOxjqqJik9R64kCZsmzYgQ12Fdiya6Wxt83CSi+bUSg4lXlu3ljwnpGEwWbu3ehqS4aIZ1rn1Cw5ul1WqYcmsXvn5hGG19XDl9sYz75m/ls22n5cO2FiN7BeKi19bMHiyErZJmRIjrkLVoru3Q+SLumZvCir3n0Wk1/PHunnz01OBmWUBwYMeqIcJ39grAaLbw5+8PMvXLPRRJbHMVTxc9t/cIAGStGmHbpBkR4hqO5hZzLK8EZ52WOyWiqaEoCp9vP8OE+Vs4mV9KsI8ry54fxou3dUHbiLHMjfi6O/PBxEH8KbYXTjoNSek5xMYnsy+roNlqsAc1E6Cly6gaYbukGRHiGqxTad/S3V8immpFFZVM+yqNP604gNFkYWTPAJLiohnUqbUq9Wg0GiZHd+abKcNp38qNrEvlPLBwK0tSTskHb7U7egbg6qTlzMUyDp6XqEbYJmlGhKiFoigk7reOopGIBiD9bCFj41NI3J+NXqvhT7G9+HDSIJuYkbZ/iC+JcdHc3SeISrPCP1Yf4vnPdlNQZlS7NNV5uOi5o2dVVCNr1QhbJc2IELXIyC3mxIVSnPVa7uzVsiMaRVH4eMsp7l+wlcxLZbTzdeObKZFMju6MRtN8scyN+Lg5seCJAfz9nj4467SsP5RLbHwKezIvq12a6mL7Vg1LT0yXtWqEbZJmRIhaWG/2u7V7G7xcW25EU1hWyZTPd/O3VYcwmi2M7hNIUlw0ER1aqV1arTQaDZOGd2L5S8Pp6OfOuYJyHlq4jUWbT2CxtNwP4dt7tsHNSUfWpXLSZSi0sEHSjAjxK1URTVUzMrYFRzRpmZeJnZvMDwdzcdZp+du43ix8YqBdzEIb1s6H1dOjGBsejMmi8D9JR5j8aSqXSltmbOPu/EtUI6NqhC2SZkSIXzmcXczJ/KqIZmQLjGgUReHD5JM8uHAbZy+X06G1OwkvDuepEaE2FcvciJerE3MfjeCte8Nw1mv5+UgesfHJ7Dp9Se3SVCGjaoQtk2ZEiF9Jqp7o7LbubfBsYSvEXi41MvmTVP6ZeBiTRSE2PJjVcVH0be+jdmkNotFoeHxoR1a8NILO/h5kF1bwyKLtvLfheIuLbW7vEYCbk46zl8vZf1aiGmFbpBkR4gqKotTMutrSRtHsPnOJ2PhkfjqSh7Neyz8nhDHv0Qi8HeCemd5tvVk1PYp7I9phtij87w8ZTPpoJ/klBrVLazZuzjpG9qqOatIlqhG2RZoRIa5wKLuIU/mluLSgiMZiUViw8QQPvb+d84UVhPp78N1Lw3liWEe7imVuxMNFzzsP9eM/94fj6qQl+Vg+MXOS2XbiotqlNRvrPVCJ+yWqEbZFmhEhrmC9ue/2HgEtIqK5WGLg6Y938e+1RzBbFMb3b8uq6VH0aWufscyNaDQaHhocwsppUXQN8CSv2MDjH25nzo/HMLeA2Oa2HgG4O+s4V1DOXpmpVtgQaUaEqNbSIpodJy8SE5/MpqMXcHXS8u/7+/Luw/1bRBPWPdCLldNG8ODA9lgU+L8fj/Lk4h3kFVeoXVqTcnXS1cybI6NqhC2RZkSIagfPF3HmYhmuTtqaYZCOyGxRmPvTMR79YDu5RQa6Bnjy/dQoHh7cwaFimRtxd9bzvw/2452H+uHurGPriYvEzEkm5Vi+2qU1KWujnZSe3eJu4hW2S5oRIapZp8q+o2cAHg56deBCsYGJS3bw3/VHsSjwwMD2rJw2gh5BXmqXppr7BrRn5bQoegZ5kV9i5MklO/jvugxMZovapTWJW7u3wcNZx/nCCtIkqhE2QpoRIbBGNFVr0cT0dcyIZsvxfMbMSWbL8Yu4Oen474P9ePvBfrg7O2bjVR9dAzxZMXUEjw7pgKLA3J+P89iHO8gpdLzYxtVJV7MKtUQ1wlZIMyIEkH6ukKxL5Q4Z0ZgtCu+sP8oTi3eQX2KgR6AXq6aP4P6B7dUuzaa4OumYfV9f4h+NwMNZx85Tl4iJT2ZjRp7apTW62OqGe80BiWqEbZBmRAh+mXdhZM9Ah7pSkFtUweMfbif+p2MoCjw6JITvp42ga0DLjWVu5J5+bVkdF03vYG8ulRp56qNd/GvNESodKLa5pXpCv+zCCtKyZCFBoT5pRkSLd+VaNI40imbT0QvEzElm+8lLeDjrmPNIf2bfF46rk07t0mxeqL8Hy18azsTIjgAs3HSCRxZt53xBucqVNQ5XJx13VUc1qyWqETZAmhHR4u0/W8jZy+W4Oem4vYf9RzQms4X/rD3CpCU7uVhqpFdw1eyj4/u3U7s0u+LqpOMf48OY//gAvFz07D5zmZj4ZH48lKt2aY3CGtXIqBphC6QZES1eTUTTKwA3Z/u+apBdWM6jH2xn/sYTADw5rCPfvTSczm08Va7MfsX0DSYxLprw9j4UlFUy+dNU/rn6EEaTfcc20d398XLRk1tkYHemRDVCXdKMiBbtyohmrJ1HND8fySVmTjK7Tl/Gy0XPe48N4M0JYRLLNIIOfu58MyWSZ0aEAvBhyikefH8bWZfKVK6s4Vz0Ou7qI6NqhG2QZkS0aHuzCjhXUI67s47b7DSiqTRb+J+kwzzzcSqXyyrp286H1XFRDnX/iy1w0ev4y7jeLHpyIN6uevZlFRATn8zaAzlql9ZgY6+YAK0lTIcvbJc0I6JFs34jvLNXoF1eQTh7uYyH3t/Gos0nAXh6RCe+fTGSjn4eKlfmuEb1CSJpRjQRHXwprjAx5fPd/G3lQQwms9ql1VtU1zZ4uerJKzaQevqS2uWIFkyaEdFiWSwKSdX3i9jjRGc/HMwhZk4yaZkFeLvqef/Jgfx1XB9c9PbXVNmb9q3c+fqFSF64pTMAH289zQMLtnHmYqnKldWPs17LqN5BwC/3TgmhBmlGRIuVllXA+cIKPJx13Najjdrl1JnRZOHvqw7ywme7Kaow0T/El8S4aEb3CVK7tBbFSadlVkwvljw1iFbuTqSfKyQ2PoXV+8+rXVq9WKOaNQdyJKoRqmlQMzJ//nxCQ0NxdXVl4MCBJCcnX3PbjRs3otFofvM4cuRIg4sWojFYr4rc2dt+IprMi2U8sHArH205DcBz0aF8/UIkIa3d1S2sBbujZyBJM6IZ3KkVJQYT075M443v0qmotI/YZkRXf7xd9VwoNrBLohqhkno3I8uWLePll1/mjTfeIC0tjejoaMaMGUNmZuZ198vIyCA7O7vm0a1btwYXLcTNujKiibWTiCYpPZvY+GT2ny3E192JxZMG8UZsb5z1coFTbcE+bnz13DBeuq0LAF/syOTe+Vs5eaFE5cpuzFmvrbmqJqNqhFrq/S72zjvv8OyzzzJ58mR69erFu+++S0hICAsWLLjufgEBAQQFBdU8dDr7+CYqHFNa1mWyCyvwdNFzS3fbjmgqKs38ecUBXvpiD8UGE4M6tiIpLpqRvQLVLk1cQa/T8oe7e/LJM0Pw83DmcHYRY+emsCLtnNql3VBs+C9r1UhUI9RQr2bEaDSye/duRo0addXzo0aNYuvWrdfdNyIiguDgYEaOHMmGDRuuu63BYKCoqOiqhxCNyToF9l02HtGcyi/lvvlb+Wz7GQBeuq0LXz0/jLa+bipXJq7l1u5tSJoRzbDOrSkzmnl52V7++O1+yo22G9uM6OqPj5sT+SVGdpy6qHY5ogWqVzOSn5+P2WwmMPDqb2SBgYHk5NQ+1j44OJhFixaRkJDA8uXL6dGjByNHjmTz5s3XfJ3Zs2fj4+NT8wgJCalPmUJcl71ENN/vPcfY+GQOZRfR2sOZT54Zwh/u7omTTmIZWxfo7coXk4cRN7IbGg0sS81iwntbOJ5XrHZptXLSablbohqhoga9q2k0mqt+VhTlN89Z9ejRg+eee44BAwYQGRnJ/PnziY2N5e23377m7581axaFhYU1j6ysrIaUKUStdmdeJrfIgJeLnuju/mqX8xsVlWZmLd/PjKV7KTWaGRramjUzornVxuMkcTWdVsPMu7rzxbNDaePlQkZuMePmbuHb3WfVLq1W1qhm7YEcTA60QrGwD/VqRvz9/dHpdL+5CpKXl/ebqyXXM2zYMI4dO3bNf3dxccHb2/uqhxCNxfrN764+gTY3J8fxvBImvLeFr3ZmodFA3MhufDF5KIHermqXJhpoeFd/kuKiierqT3mlmVe/2cfMr/dSajCpXdpVIrv40crdiYulRnacklE1onnVqxlxdnZm4MCBrF+//qrn169fz/Dhw+v8e9LS0ggOtt3L48Jx2XJEk7D7LOPmpnAkpxh/Txc+f3YoM+/qjl5iGbvXxsuFT54ZwqujuqPVwPI957hnXgpHcmznfjgn3RWjamQCNNHM6v0uN3PmTD788EOWLFnC4cOHeeWVV8jMzGTKlClAVcQyceLEmu3fffddVqxYwbFjxzh48CCzZs0iISGBadOmNd5RCFFHqWcuk1dswMtVT1Q324hoyowmXv1mH7/7Zh/llWZGdPUjaUYUI7raRn2icei0Gqbd0Y2vnhtGoLcLJy6UMn7eFpbuzERRbGMEi0Q1Qi36+u7w8MMPc/HiRf7xj3+QnZ1NWFgYSUlJdOzYEYDs7Oyr5hwxGo28+uqrnDt3Djc3N/r06UNiYiIxMTGNdxRC1FFi9eyYo3oH2UREczS3mKlf7OFYXglaDbx8Z3em3t4Vnbb2e7CE/Rva2Y+kuGhmfr2PTUcv8NrydLaeuMj/3NcXT5d6vyU3qsjOVVHNpVIj209espmGXTg+jWIrLfl1FBUV4ePjQ2Fhodw/IhrMbFEYNvsnLhQb+OipwdzeU71VehVF4evULP668iAVlRYCvV2Y80gEwzr7qVaTaF4Wi8L7m0/y9roMzBaFUH8P5j0WQZ+2PqrWNWt5Ol/tzOTRISHMvi9c1VqE/avr57eE0aLF2HX6EheKDXi76lWNQEoMJl5Ztpc/JqRTUWnhlu5tSIqLlkakhdFqNbx4Wxe+fmEYbX1cOZVfyr3Vc8qo+R1x7BVRTaVENaKZSDMiWgzrKJrRfYJUm0L90Pki7pmbwoq959FpNfzh7h58/NRg/DxdVKlHqG9gx9YkxkVzZ68AjCYLf15xgGlfplFUUalKPUNDW+Pn4czlskq2nZAJ0ETzkGZEtAhmi8KaA9WjaMKbfxSNoih8seMME+Zv4WR+KcE+rix7fhgv3dYVrdwf0uK18nDmg4mD+FNsL/RaDYnp2YyNT2H/2YJmr0Wv03J3mEyAJpqXNCOiRdhx6iL5JUZ83JyaPaIprqhk2ldpvPHdAYwmCyN7BpAUF82gTq2btQ5h2zQaDZOjO/PNlEja+bqReamM+xds5aMtp5o9tqkZVXNQohrRPKQZES2C9Rve3X2CmnU69QPnChk7N4XE/dnotRr+FNuLDycNopWHc7PVIOxLRIeqhRBH9wmk0qzw91WHeOGz3RSWNV9sMzTUD39PZwrLK9lyPL/ZXle0XNKMCIdnMltYe6Bq1uCYZopoFEXhk62nuW/+Vs5cLKOdrxvfTIlkcnTnay6dIISVj7sTC58YyN/v6YOzTsu6Q7nExCeTlnm5WV5fp9XURDVJMgGaaAbSjAiHt/PUJS6WGvF1d2J4l6YfsVJYXsmLn+/hrysPYjRbGNU7kKS4aCI6tGry1xaOQ6PRMGl4JxJeHE5HP3fOFZTz4MJtfLD5JBZL08c2sX3bAvDDwVyMJolqRNOSZkQ4vNXpzRfR7M0qIDY+mbUHc3DSafjruN68/+RAfNydmvR1hePq296HVdOjiA0PxmRReCvpMJM/TeVyqbFJX3dIaGv8PV2qopoTEtWIpiXNiHBoV0Y0TTmKRlEUPkw+yYMLt3L2cjkdWruT8OJwnh4RKrGMuGnerk7MezSCf04Iw1mv5ecjecTEJ5N6uukWtNNpNcT0lVE1onlIMyIc2vaTl7hUaqSVuxORTTSpWEGZkec+TeWfiYepNCvE9g1mdVwU4e19m+T1RMuk0Wh4YlhHVrw0gs7+HmQXVvDwou3M33i8yWIb62KSPxzMkahGNClpRoRDS0yvWovm7rDgJln9dveZS8TMSebHw3k467W8OSGMeY9F4O0qsYxoGr3berNyehQT+rfFbFH4z9oMnvp4F/klhkZ/rUGdWhPg5UJxhYmU4xca/fcLYSXNiHBYlVdENGMbOaKxWBQWbjrBQ+9v53xhBaH+Hnz30nCeHNZRYhnR5Dxd9Pzfw/359/19cXXSsvnoBWLmJLP9ZOPOmFoV1VT9v7NaohrRhKQZEQ5r24mLXC6rxM/DmaGhjTfB2MUSA898sot/rTmC2aIwvn9bVk2PUn2BM9GyaDQaHh7cge+nRtE1wJO8YgOPfbCd+J+OYW7E2MZ6r9X6g7kYTOZG+71CXEmaEeGwaiY6CwtqtIhmx8mLxMQnszHjAi56Lf++vy/vPtxf9aXfRcvVI8iLldNG8MDA9lgUeGf9USYu2UFecUWj/P6BHVoR6O1CscFE8lEZVSOahjQjwiFVmi38cKh6FE3fm49oLBaFeT8f49EPtpNbZKBLGw9WTovi4cEdJJYRqnN31vP2g/3474P9cHPSseX4RWLmpDTK7KlarYYxYVX/D8kEaKKpSDMiHNLWExcpKKvE39OZITcZ0VwoNjDpo528ve4oFgXuH9CeVdOj6BHk1UjVCtE47h9Y/bcZ6EV+iYEnFu/gnXUZmG5yfRnrPVfrD+VSUSlRjWh80owIh5S43zqK5uYimq3H84mJTyb5WD5uTrqqb58P9cPdWWIZYZu6Bnjy/bQRPDokBEWB+J+P89iHO8gtanhsM6BDK4K8XauimmMS1YjGJ82IcDhGk4UfDuYCv0xpXV9mi8L/rT/K44t3cKHYQI/AX3J5IWydq5OO2feFM+eR/ng469h56hJj5iSzMSOvQb9Pe8WoGmujL0RjkmZEOJwtJ/IpLK/E39OlQRFNXlEFj3+4nTk/HUNR4JHBIayYOoJugRLLCPsyvn87Vk2PonewN5dKjTz10S7+vfZIg2KbWIlqRBOSZkQ4HOsompi+Qei09bu5dPPRC4yZk8z2k5fwcNYx55H+/Ov+cNycdU1RqhBNrnMbT5ZXz4EDsGDjCR5ZtJ3zBeX1+j0RIb609XGl1Ghm01GZAE00LmlGhEOpimjqP4rGZLbwvz8cYdJHO7lYaqRXsDerpkcxvn+7pipViGbj6qTjzQlhvPfYALxc9KSeuUxMfDI/Hc6t8++4OqqRUTWicUkzIhxKyvELFFeYCPByYVCnukU02YXlPPrBdt7bcAJFgSeGdeC7l4bTuY1nE1crRPOKDa9aN6lvOx8Kyip59pNU3ko8VOd1Z6xRzY+HJaoRjUuaEeFQVtdENMF1img2HMkjZk4yu05fxstFz7zHIvjnhL64OkksIxxTRz8Pvn0xkqdHdALgg+RTPPT+NrIuld1w3/4hvrTzdaPMaG7wzbBC1EaaEeEwDCYz66tH0cTcIKKpNFuYnXSYpz/exeWySvq282F1XBRjwxs2+kYIe+Ki1/HXcX14/8mBeLvq2ZtVQGx8ck3EeS0ajYaYvkEAJKZff1sh6kOaEeEwUo7lU2yojmg6trrmdmcvl/HQ+9t4f/NJAJ4a3olvX4yko59Hc5UqhE0Y3SeIpBnR9A/xpajCxAuf7eZvKw9edw2a2OqG/afDuZQbJaoRjUOaEeEwEq+IaLTXiGjWHcwhNj6FtMwCvF31LHxiIH+7pw8ueollRMvUvpU730yJ5PlbOgPw8dbTPLBgG2culta6fb/2PhLViEYnzYhwCBWVZtYfqoporFNXX8losvCPVYd4/rPdFJZX0i/El8S4aO4OC2ruUoWwOU46La/H9GLJU4PwdXci/VwhY+NTah01o9Foav4fWy1r1YhGIs2IcAjJ1RFNkLcrAzpcHdFkXSrjwYVbWbLlFADPRYfyzQuRhLR2V6NUIWzWHT0DSYqLZlDHVhQbTEz9cg9/WpH+m5Ez1lE1Px/Oo8xoUqNU4WCkGREOwTpF9a8jmjXp2cTEJ7PvbCG+7k58OHEQb8T2xlkvf/pC1KatrxtLnx/GS7d1AeDz7ZncO38rJy+U1GzTt50PIa3dKK80s+GITIAmbp68Iwu7d2VEY/3GVlFp5i/fH+DFL/ZQXGFiYMdWJMVFc2fvQDVLFcIu6HVa/nB3Tz55Zgh+Hs4czi5i3NwUvt97DqiKaqzrPiWmy1o14uZJMyLs3qajFyg1mmnr40pEiC+n8ku5f8FWPt12BoAXb+vC0ueH0dbXTeVKhbAvt3ZvQ9KMaIaGtqbUaGbG0r28lrCfcqO55r6Rn4/kUWqQqEbcnAY1I/Pnzyc0NBRXV1cGDhxIcnLydbfftGkTAwcOxNXVlc6dO7Nw4cIGFStEba4cRbM6PZtxc1M4eL6I1h7OfPz0YP54d0+cdNJ3C9EQgd6ufDF5KHEju6HRwNJdWUx4bwuuTlo6tHanotLCz0dkVI24OfV+h162bBkvv/wyb7zxBmlpaURHRzNmzBgyMzNr3f7UqVPExMQQHR1NWloar7/+OnFxcSQkJNx08UJUVJr5sXp9jS0nLhL3VRolBhNDQluTFBfNbT0CVK5QCPun12mZeVd3Pn92KP6eLmTkFjNu7paae6+SZFSNuEkaRVGU+uwwdOhQBgwYwIIFC2qe69WrFxMmTGD27Nm/2f6Pf/wjK1eu5PDhwzXPTZkyhX379rFt27Y6vWZRURE+Pj4UFhbi7e1dn3KFg1t7IIcpn++u+Vmjgem3dyVuZDf0cjVEiEaXV1zBK8v2suX4xZrnXPRa9vz5Ljxc9CpWJmxRXT+/6/VubTQa2b17N6NGjbrq+VGjRrF169Za99m2bdtvth89ejSpqalUVlbWuo/BYKCoqOiqhxC1ubIR8fd04bNnhjJzVA9pRIRoIgFernz6zFB+d1d3rAPXDCYLP0lUI25Cvd6x8/PzMZvNBAZePSIhMDCQnJza1ynIycmpdXuTyUR+fn6t+8yePRsfH5+aR0hISH3KFC3E8bxfhhp6OOtImhFFVDd/FSsSomXQaTVMH9mNL58bRqC3CwBHsuVLo2i4Bn191GiunmpbUZTfPHej7Wt73mrWrFkUFhbWPLKyshpSpnBw7Vu5EdHBF4D9fxtNgJerugUJ0cIM6+xHUlw0b47vw7NRoWqXI+xYvQI+f39/dDrdb66C5OXl/ebqh1VQUFCt2+v1evz8/Grdx8XFBRcXl/qUJlogVycd3700Qu0yhGjR/DxdeDKyk9plCDtXrysjzs7ODBw4kPXr11/1/Pr16xk+fHit+0RGRv5m+3Xr1jFo0CCcnJzqWa4QQgghHE29Y5qZM2fy4YcfsmTJEg4fPswrr7xCZmYmU6ZMAaoilokTJ9ZsP2XKFM6cOcPMmTM5fPgwS5YsYfHixbz66quNdxRCCCGEsFv1Hof18MMPc/HiRf7xj3+QnZ1NWFgYSUlJdOzYEYDs7Oyr5hwJDQ0lKSmJV155hffee4+2bdsSHx/P/fff33hHIYQQQgi7Ve95RtQg84wIIYQQ9qdJ5hkRQgghhGhs0owIIYQQQlXSjAghhBBCVdKMCCGEEEJV0owIIYQQQlXSjAghhBBCVdKMCCGEEEJV0owIIYQQQlXSjAghhBBCVfWeDl4N1klii4qKVK5ECCGEEHVl/dy+0WTvdtGMFBcXAxASEqJyJUIIIYSor+LiYnx8fK7573axNo3FYuH8+fN4eXmh0Wga7fcWFRUREhJCVlaWw6554+jHKMdn/xz9GB39+MDxj1GOr+EURaG4uJi2bdui1V77zhC7uDKi1Wpp3759k/1+b29vh/wDu5KjH6Mcn/1z9GN09OMDxz9GOb6Gud4VESu5gVUIIYQQqpJmRAghhBCqatHNiIuLC3/9619xcXFRu5Qm4+jHKMdn/xz9GB39+MDxj1GOr+nZxQ2sQgghhHBcLfrKiBBCCCHUJ82IEEIIIVQlzYgQQgghVCXNiBBCCCFU5fDNyPz58wkNDcXV1ZWBAweSnJx83e03bdrEwIEDcXV1pXPnzixcuLCZKm24+hzjxo0b0Wg0v3kcOXKkGSuuu82bNzNu3Djatm2LRqNhxYoVN9zHns5hfY/P3s7f7NmzGTx4MF5eXgQEBDBhwgQyMjJuuJ+9nMOGHJ+9ncMFCxYQHh5eMyFWZGQka9asue4+9nL+oP7HZ2/n79dmz56NRqPh5Zdfvu52zX0OHboZWbZsGS+//DJvvPEGaWlpREdHM2bMGDIzM2vd/tSpU8TExBAdHU1aWhqvv/46cXFxJCQkNHPldVffY7TKyMggOzu75tGtW7dmqrh+SktL6devH/PmzavT9vZ2Dut7fFb2cv42bdrE1KlT2b59O+vXr8dkMjFq1ChKS0uvuY89ncOGHJ+VvZzD9u3b869//YvU1FRSU1O54447GD9+PAcPHqx1e3s6f1D/47Oyl/N3pV27drFo0SLCw8Ovu50q51BxYEOGDFGmTJly1XM9e/ZUXnvttVq3/8Mf/qD07NnzqudeeOEFZdiwYU1W482q7zFu2LBBAZTLly83Q3WNC1C+++67625jj+fQqi7HZ8/nT1EUJS8vTwGUTZs2XXMbez6HdTk+ez+HiqIorVq1Uj788MNa/82ez5/V9Y7PXs9fcXGx0q1bN2X9+vXKrbfeqsyYMeOa26pxDh32yojRaGT37t2MGjXqqudHjRrF1q1ba91n27Ztv9l+9OjRpKamUllZ2WS1NlRDjtEqIiKC4OBgRo4cyYYNG5qyzGZlb+ewoez1/BUWFgLQunXra25jz+ewLsdnZY/n0Gw2s3TpUkpLS4mMjKx1G3s+f3U5Pit7O39Tp04lNjaWO++884bbqnEOHbYZyc/Px2w2ExgYeNXzgYGB5OTk1LpPTk5OrdubTCby8/ObrNaGasgxBgcHs2jRIhISEli+fDk9evRg5MiRbN68uTlKbnL2dg7ry57Pn6IozJw5k6ioKMLCwq65nb2ew7oenz2ew/T0dDw9PXFxcWHKlCl899139O7du9Zt7fH81ef47PH8LV26lD179jB79uw6ba/GObSLVXtvhkajuepnRVF+89yNtq/teVtSn2Ps0aMHPXr0qPk5MjKSrKws3n77bW655ZYmrbO52OM5rCt7Pn/Tpk1j//79pKSk3HBbezyHdT0+ezyHPXr0YO/evRQUFJCQkMCkSZPYtGnTNT+w7e381ef47O38ZWVlMWPGDNatW4erq2ud92vuc+iwV0b8/f3R6XS/uUKQl5f3m47PKigoqNbt9Xo9fn5+TVZrQzXkGGszbNgwjh071tjlqcLezmFjsIfzN336dFauXMmGDRto3779dbe1x3NYn+Orja2fQ2dnZ7p27cqgQYOYPXs2/fr1Y86cObVua4/nrz7HVxtbPn+7d+8mLy+PgQMHotfr0ev1bNq0ifj4ePR6PWaz+Tf7qHEOHbYZcXZ2ZuDAgaxfv/6q59evX8/w4cNr3ScyMvI3269bt45Bgwbh5OTUZLU2VEOOsTZpaWkEBwc3dnmqsLdz2Bhs+fwpisK0adNYvnw5P//8M6GhoTfcx57OYUOOrza2fA5roygKBoOh1n+zp/N3Ldc7vtrY8vkbOXIk6enp7N27t+YxaNAgHn/8cfbu3YtOp/vNPqqcwya7NdYGLF26VHFyclIWL16sHDp0SHn55ZcVDw8P5fTp04qiKMprr72mPPnkkzXbnzx5UnF3d1deeeUV5dChQ8rixYsVJycn5dtvv1XrEG6ovsf4f//3f8p3332nHD16VDlw4IDy2muvKYCSkJCg1iFcV3FxsZKWlqakpaUpgPLOO+8oaWlpypkzZxRFsf9zWN/js7fz9+KLLyo+Pj7Kxo0blezs7JpHWVlZzTb2fA4bcnz2dg5nzZqlbN68WTl16pSyf/9+5fXXX1e0Wq2ybt06RVHs+/wpSv2Pz97OX21+PZrGFs6hQzcjiqIo7733ntKxY0fF2dlZGTBgwFVD7iZNmqTceuutV22/ceNGJSIiQnF2dlY6deqkLFiwoJkrrr/6HOO///1vpUuXLoqrq6vSqlUrJSoqSklMTFSh6rqxDqP79WPSpEmKotj/Oazv8dnb+avt2ADlo48+qtnGns9hQ47P3s7hM888U/P+0qZNG2XkyJE1H9SKYt/nT1Hqf3z2dv5q8+tmxBbOoUZRqu9KEUIIIYRQgcPeMyKEEEII+yDNiBBCCCFUJc2IEEIIIVQlzYgQQgghVCXNiBBCCCFUJc2IEEIIIVQlzYgQQgghVCXNiBBCCCFUJc2IEEIIIVQlzYgQQgghVCXNiBBCCCFUJc2IEEIIIVT1/zqxEa6jdUysAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x=[1,2,3,0,4,1]\n", + "y=[0,4,0,3,3,0]\n", + "plt.plot(x,y);" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "y=[0,4,0,3,3,0]\n", + "plt.plot(y);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cheatsheet for much more matplotlib: https://twitter.com/dr_shlee/status/1282772480046891010" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Boolean (`bool`) type\n", + "\n", + "Python's `bool` type can take one of two values: `True` or `False`. It is used to test a condition, such as in an *if statement*." + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 144, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = 1\n", + "y = x > 0\n", + "y" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "bool" + ] + }, + "execution_count": 145, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 148, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-1" + ] + }, + "execution_count": 148, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = -1\n", + "\n", + "if x > 0:\n", + " print(\"x is positive\")\n", + " x = 10\n", + "\n", + "x" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 149, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x>0" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "bool" + ] + }, + "execution_count": 150, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(x>0)" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x is positive\n", + "x is still positive\n", + "out of the blocks\n", + "20\n" + ] + } + ], + "source": [ + "x = 1\n", + "\n", + "if x > 0:\n", + " y = 20\n", + " print(\"x is positive\")\n", + " print(\"x is still positive\")\n", + "else:\n", + " y = 40\n", + " print(\"x is negative\")\n", + " print(\"x is still negative\")\n", + " \n", + "print(\"out of the blocks\")\n", + "print(y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Equality testing" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "# Equality and comparisons\n", + "\n", + "Comparison operators: `==`, `>`, `>=`, `<`, `<=`, `!=`\n", + "\n", + "These operators take two arguments (left and right hand side) and return a boolean." + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 154, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "3 > 4" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 155, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "3 == 4" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 156, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2+2 == 4" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 157, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2+(2 == 4)" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 158, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2+(False)" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 159, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2+False" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Coercion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## explicit coersion" + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "metadata": {}, + "outputs": [], + "source": [ + "x = \"10\"" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'10'" + ] + }, + "execution_count": 161, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "str" + ] + }, + "execution_count": 162, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "can only concatenate str (not \"int\") to str", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[163], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mx\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m32\u001b[39;49m\n", + "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str" + ] + } + ], + "source": [ + "x+32" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "metadata": {}, + "outputs": [], + "source": [ + "x = int(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 165, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "int" + ] + }, + "execution_count": 166, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "42" + ] + }, + "execution_count": 167, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x+32" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 168, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bool(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 169, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bool(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 170, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bool(\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 171, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bool(\" \")" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 172, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bool(None)" + ] + }, + { + "cell_type": "code", + "execution_count": 173, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 173, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bool(\"False\")" + ] + }, + { + "cell_type": "code", + "execution_count": 174, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 174, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bool(False)" + ] + }, + { + "cell_type": "code", + "execution_count": 175, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'False'" + ] + }, + "execution_count": 175, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "str(False)" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 176, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bool(str(False))" + ] + }, + { + "cell_type": "code", + "execution_count": 178, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 178, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "int(False)" + ] + }, + { + "cell_type": "code", + "execution_count": 177, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "invalid literal for int() with base 10: 'False'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[177], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mFalse\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'False'" + ] + } + ], + "source": [ + "int('False')" + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 179, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "int(bool('False'))" + ] + }, + { + "cell_type": "code", + "execution_count": 180, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 180, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "int(False)" + ] + }, + { + "cell_type": "code", + "execution_count": 181, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 181, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "int(True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## implicit coersion" + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 is an integer, not a boolean. Why is this not an error?\n" + ] + } + ], + "source": [ + "if 10:\n", + " print(\"10 is an integer, not a boolean. Why is this not an error?\")" + ] + }, + { + "cell_type": "code", + "execution_count": 183, + "metadata": {}, + "outputs": [], + "source": [ + "if 0:\n", + " print(\"why doesn't this print?\")" + ] + }, + { + "cell_type": "code", + "execution_count": 184, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hello\n" + ] + } + ], + "source": [ + "x = \"False\"\n", + "if x:\n", + " print(\"hello\")" + ] + }, + { + "cell_type": "code", + "execution_count": 185, + "metadata": {}, + "outputs": [], + "source": [ + "x = \"\"\n", + "if x:\n", + " print(\"hello\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Python's `assert`" + ] + }, + { + "cell_type": "code", + "execution_count": 186, + "metadata": {}, + "outputs": [], + "source": [ + "assert True" + ] + }, + { + "cell_type": "code", + "execution_count": 187, + "metadata": {}, + "outputs": [ + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[187], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + } + ], + "source": [ + "assert False" + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 188, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bool(1)==True" + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "metadata": {}, + "outputs": [], + "source": [ + "assert bool(1)==True" + ] + }, + { + "cell_type": "code", + "execution_count": 190, + "metadata": {}, + "outputs": [ + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[190], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mbool\u001b[39m(\u001b[38;5;241m0\u001b[39m)\u001b[38;5;241m==\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + } + ], + "source": [ + "assert bool(0)==True" + ] + }, + { + "cell_type": "code", + "execution_count": 191, + "metadata": {}, + "outputs": [ + { + "ename": "AssertionError", + "evalue": "When I wrote this function, I assumed this would be otherwise.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[191], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mbool\u001b[39m(\u001b[38;5;241m0\u001b[39m)\u001b[38;5;241m==\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWhen I wrote this function, I assumed this would be otherwise.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n", + "\u001b[0;31mAssertionError\u001b[0m: When I wrote this function, I assumed this would be otherwise." + ] + } + ], + "source": [ + "assert bool(0)==True, \"When I wrote this function, I assumed this would be otherwise.\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Blocks and control flow" + ] + }, + { + "cell_type": "code", + "execution_count": 192, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "statement 1\n", + "statement 2\n", + "statement 3\n" + ] + } + ], + "source": [ + "if True:\n", + " print(\"statement 1\")\n", + " print(\"statement 2\")\n", + " print(\"statement 3\")" + ] + }, + { + "cell_type": "code", + "execution_count": 194, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "here\n", + "a is one\n" + ] + } + ], + "source": [ + "a = 1\n", + "b = -2\n", + "\n", + "if a==1:\n", + " if b>0:\n", + " print(\"a is one and b is positive\")\n", + " else:\n", + " print(\"here\")\n", + " print(\"a is one\")\n", + "else:\n", + " print(\"a is not one\")" + ] + }, + { + "cell_type": "code", + "execution_count": 195, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a is one\n", + "b is zero\n" + ] + } + ], + "source": [ + "a = 1\n", + "b = -0.0\n", + "\n", + "if a==1:\n", + " if b>0:\n", + " print(\"a is one and b is positive\")\n", + " elif b<0:\n", + " print(\"a is one and b is negative\")\n", + " else:\n", + " print(\"a is one\")\n", + " print(\"b is zero\")\n", + "else:\n", + " print(\"a is not one\")" + ] + }, + { + "cell_type": "code", + "execution_count": 196, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.0" + ] + }, + "execution_count": 196, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}