pm21-dragon/lectures/lecture-02/1 - Scopes, Types, etc.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Important reminder\n",
    "\n",
    "No lecture on 1 Nov. 2024 due to holiday.\n",
    "\n",
    "Lecture will be at start of tutorial on 4 Nov. 2024 (at the normal tutorial time and loaction, namely 14:15 in the Computer Pool in Bio 2/3 building.)\n",
    "\n",
    "# File naming in assignments\n",
    "\n",
    "Please use original name and overwrite original file."
   ]
  },
  {
   "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": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0\n",
    "\n",
    "def foo(a):\n",
    "    return a\n",
    "\n",
    "z = foo(x)"
   ]
  },
  {
   "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": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(10.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 10\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(\"10\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type('10')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Hello, My name is Angela Merkel\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"übersetzen😀\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "Übersetzung = \"translation\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "übersetzen😀\n"
     ]
    }
   ],
   "source": [
    "print(my_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "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": 41,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (1042171736.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[41], 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": 42,
   "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": 43,
   "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": 44,
   "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": 45,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (57043761.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[45], 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": 46,
   "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": 47,
   "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": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1234"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1234"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myprint(x):\n",
    "    print(x)\n",
    "    return 32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myprint(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "myprint(\"hello\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "z=myprint(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "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": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=x+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "z=x=x+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 63,
     "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": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "x=None\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=None\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "x=print(10)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 72,
     "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": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3+4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int.__add__(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdef'"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"abc\" + \"def\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdef'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 * 3 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 4 * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 4 * 3 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = x * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y=4*3+2\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tmp = 4*3\n",
    "y = tmp+2\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "tmp = 'my super import data'\n",
    "\n",
    "y=4*(3+2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'my super import data'"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tmp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# list type\n",
    "\n",
    "## list construction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "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": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "x=list()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "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": 107,
   "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": 108,
   "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": 109,
   "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": 110,
   "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": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'red'"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[\"red\",\"green\",\"blue\"]\n",
    "x[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'green'"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[\"red\",\"green\",\"blue\"]\n",
    "x[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'blue'"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[\"red\",\"green\",\"blue\"]\n",
    "x[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'blue'"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[\"red\",\"green\",\"blue\"]\n",
    "x[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'violet'"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n",
    "x[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'blue'"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n",
    "x[-3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'yellow'"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y=2\n",
    "x[y]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "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[119], 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": 120,
   "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[120], 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": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n",
    "x.index(\"blue\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "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[122], 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": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[3]=3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['red', 'orange', 'yellow', 3, 'blue', 'indigo', 'violet']"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## list slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['red', 'orange', 'yellow']"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n",
    "x[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'green'"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['red', 'orange', 'yellow']"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['red', 'orange', 'yellow']"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n",
    "x[None:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['red', 'orange', 'yellow']"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['green', 'blue', 'indigo', 'violet']"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n",
    "x[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['green', 'blue', 'indigo', 'violet']"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\"]\n",
    "x[3:None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['green', 'blue', 'indigo']"
      ]
     },
     "execution_count": 133,
     "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": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "(1, 2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "x = (1,2,3,4)\n",
    "print(type(x))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "x = ()\n",
    "print(type(x))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "(1,)\n"
     ]
    }
   ],
   "source": [
    "x = (1,)\n",
    "print(type(x))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "x = (1)\n",
    "print(type(x))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "(1,)\n"
     ]
    }
   ],
   "source": [
    "x = 1,\n",
    "print(type(x))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "x = 1,2,3\n",
    "print(type(x))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "print(type(x))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "x = tuple()\n",
    "print(type(x))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "(1,)\n"
     ]
    }
   ],
   "source": [
    "x = tuple([1])\n",
    "print(type(x))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\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": 146,
   "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[146], 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": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'tuple'>\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": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'yellow'"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=(\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\")\n",
    "x[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'violet'"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=(\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\")\n",
    "x[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'blue'"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=(\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\")\n",
    "x[-3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('red', 'orange', 'yellow')"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=(\"red\",\"orange\",\"yellow\",\"green\",\"blue\",\"indigo\",\"violet\")\n",
    "x[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('red', 'orange', 'yellow')"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## lists are *mutable*, tuples are not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "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": 154,
   "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[154], 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": 155,
   "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": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "def modify_arg(a,b):\n",
    "\t    a = a + b\n",
    "\t    # Notice that there is no return here!\n",
    "\t    # So, this function has an important \"side effect\",\n",
    "\t    # but the output is None.\n",
    "\t    \n",
    "x = 10\n",
    "y = modify_arg(x, 4)\n",
    "x\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 161,
     "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": 163,
   "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": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['red', 'orange', 'yellow', 3, 'blue', 'indigo', 'violet']\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "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": 166,
   "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": 167,
   "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": 168,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "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,\"ro:\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "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": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "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": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1\n",
    "y = x > 0\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is positive\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 180,
     "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": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x>0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x>0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "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": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 > 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 == 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2+2 == 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2+(2 == 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2+(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 190,
     "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"10\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x+32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x+32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(\"False\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(str(False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int('False')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(bool('False'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## implicit coersion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "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": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 0:\n",
    "    print(\"why doesn't this print?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "x = \"False\"\n",
    "if x:\n",
    "    print(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"\"\n",
    "if x:\n",
    "    print(\"hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python's `assert`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "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[198], 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": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(1)==True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert bool(1)==True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "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[201], 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": 202,
   "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[202], 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": 203,
   "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": 206,
   "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": 208,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is one and b is negative\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = -1.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": null,
   "metadata": {},
   "outputs": [],
   "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
}