python_part2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction to Python - Part 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<figure class=\"half\" style=\"display:flex\">\n",
    "    <img style=\"width:40%\" src=\"monty_python.jpg\">\n",
    "    <img style=\"width:40%\" src=\"learning_python.jpeg\">\n",
    "</figure>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Python is called an interpreted language but is compiled to bytecode. The .py source code is first compiled to byte code as .pyc. This byte code can be interpreted (official CPython), or JIT compiled (PyPy)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Jupyter notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Useful to write both code and text in the same place"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Double click on a cell, choose in the top menu either \"code\" or \"Markdown\" for text.\n",
    "After writing something in the cell, just press `shift` + `Enter` to view the result (or click on the \"Run\" button)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### In addition of headings (#, ##, ###, ...) with markdown you can write bullet lists (\\*)\n",
    "* Use #, ##, ###, etc. on the first line for the size of your headings\n",
    "* Use single star (\\*) for each entry of your bullet list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Headings are obviously optional. In addition of bullet lists, you can create numbered lists using the format \"number\" \"fullpoint(.)\" \"space\":\n",
    "1. Markdown allows you to write simple text\n",
    "2. But also LaTeX formulas, by simply putting it between dollar signs: $\\sum_{n=1}^{\\infty} \\frac{1}{2^n} = 1$\n",
    "3. You can escape special markdown characters with a backslash (\\\\): \\*\n",
    "4. You can even quote commands by using apostrophes (\\`), as in: use `jupyter notebook` to launch Jupyter notebook from the terminal (after installing python and Jupyter)\n",
    "5. You can put words in *italics* by writing them in between stars (\\*) or in **bold** using two stars (\\*\\*)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now let's do some python code. Comments can be made with a hash sign (#).\n",
    "2 + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "While the result of executing a cell (`shift` + `Enter`) in *Markdown* is **formatting that cell**, for *code* (like `python` code) the result is **running that code and displaying the output (if any)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The jupyter notebook can be in either of two modes:\n",
    "* **edit mode** when you are editing a cell (i.e. typing Markdown or code): **the edited cell is green**\n",
    "* **command mode** when you can can execute commands from the keyboard (e.g. adding or deleting a cell): **the cell marker becomes blue**  \n",
    "\n",
    "To go from edit mode to command mode, press the `Esc` key. To go from command mode to edit mode, press the `Enter` key. This is useful to avoid using the mouse and thus saving time.\n",
    "\n",
    "Press the keyboard button on the menu at the top to see all keyboard shortcuts."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Exercise\n",
    "1. Create two new cells clicking on `+` in the top left corner, once for each cell\n",
    "2. Make the first cell a Markdown cell, by clicking on it and selecting `Markdown` in the menu (top center)\n",
    "3. Edit it by double-clicking it, then write a bullet list of items\n",
    "4. Make the second cell a code cell, by clicking on it and selecting `code` in the menu (top center)\n",
    "5. Edit it by double-clicking it, then write an arithmetic operation\n",
    "6. Make sure to execute both cells (if not already done) by selecting it and pressing the \"Run\" button (top left)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Exercise (part 1)\n",
    "Do the same as above but without using the mouse except for the initial step `0`.\n",
    "0. Click on the last cell you created and make sure the cell marker is blue (otherwise press the `Esc` key)\n",
    "1. Create two new cells by pressing twice on `b` on the keyboard\n",
    "2. Navigate to the first cell you created using the up / down arrows on your keyboard\n",
    "3. While in command mode (make sure the cell marker is blue otherwise press the `Esc` key), press the `m` key to make the cell a Markdown cell\n",
    "4. Switch to edit mode by pressing the `Enter` key, then write a numbered list of items\n",
    "5. Execute the cell by pressing `Shift` + `Enter`: since the cell is a markdown cell this will format the cell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Exercise (part 2)\n",
    "6. Executing the previous cell will bring you to the next cell. While in command mode (make sure the cell marker is blue otherwise press the `Esc` key), press the `y` key to make the cell a code cell\n",
    "7. Switch to edit mode by pressing the `Enter` key, then write an arithmetic operation\n",
    "8. Execute the cell by pressing `Shift` + `Enter`: since the cell is a code cell this run the code inside the cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python variables and datatypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Variables allow for generalization and reusability of programming instructions. A variable is a reference to an object. The object can be:\n",
    "* A sequence of characters, i.e. a \"string\":\n",
    "  * `my_var = \"Felix\"`\n",
    "  * `my_var = \"My cat is called Felix\"`\n",
    "  * `my_var = \"/home/felix/how_to_manipulate_humans.txt\"`\n",
    "* A number (integer, float)\n",
    "  * `my_var = 3.14`\n",
    "* A list of objects:\n",
    "  * `my_vars = [\"felix\", \"/home/felix/file.txt\", 3.14]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Variable names\n",
    "* can only contain letters, digits, and underscore `_` (no spaces!)\n",
    "* cannot start with a digit\n",
    "* are case sensitive (`fruit`, `FRUIT` and `Fruit` are three different variables)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let's look at some code. In python spaces can be used on each side of equal sign, and the content of the variable is simply obtained by indicating the variable name (no need for `$` like in bash)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a refers to an integer (int)\n",
    "a = 2\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Functions (to be discussed later) are like commands in bash, but take arguments inside parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14\n"
     ]
    }
   ],
   "source": [
    "# simple_pi refers to a float\n",
    "simple_pi = 3.14\n",
    "print(simple_pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Compare with the bash version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "pi=3.14\n",
    "echo ${pi}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "As in bash, strings (i.e. sequence of characters) are indicated inside quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kiwi\n"
     ]
    }
   ],
   "source": [
    "# favorite_fruit refers to a string (str)\n",
    "favorite_fruit = \"kiwi\"\n",
    "print(favorite_fruit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Python can define a boolean value. A boolean is a variable which can only have one of two values: `True` or `False`. For convenience `0` is considered `False` while anything different from `0` is considered `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# like_kiwi refers to a boolean\n",
    "like_kiwi = True\n",
    "print(like_kiwi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "You can check the type of a variable with `type`.  \n",
    "Note that in Python arguments to a function are separated by `,` and spaces can be used before (not recommended) or after (recommended) the comma. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'> <class 'float'> <class 'str'> <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(type(a), type(simple_pi), type(favorite_fruit), type(like_kiwi), sep=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print?\n",
    "# Output: print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False) [can also use \"Shift\"+\"Tab\" for help]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Simple datatypes are **immutable** (you cannot change them)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Setting a variable to a new immutable object (e.g. integer) will refer to a new object entirely\n",
    "a = 3\n",
    "a = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<img src=\"immutvar_newval_up.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is 3\n",
      "b is 3\n"
     ]
    }
   ],
   "source": [
    "# Consider a variable 'a' referring to an immutable object (e.g. an int).\n",
    "# Setting a variable 'b' to 'a' can also be thought as creating a new object, with the same value but independent\n",
    "a = 3\n",
    "b = a \n",
    "print('a is', a)\n",
    "print('b is', b)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<tr><td><img src='immutvar_by_val.png'></td><td><img src='immutvar_by_val_wall.png'></td></tr>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is 4\n",
      "b is 3\n"
     ]
    }
   ],
   "source": [
    "# Since they are completely independent, changing one will not affect the other\n",
    "a = 3\n",
    "b = a\n",
    "a = 4\n",
    "print('a is', a)\n",
    "print('b is', b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<img src=\"immutvar_by_val_newval.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "letter at index 0 is h\n",
      "letter at index 4 is u\n"
     ]
    }
   ],
   "source": [
    "# Strings, similarly to list (cf next section), are 0-indexed sequences\n",
    "atom_name = 'helium'\n",
    "print('letter at index 0 is', atom_name[0])\n",
    "print('letter at index 4 is', atom_name[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<img src=str_indexing_only.svg>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' 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)",
      "\u001b[0;32m<ipython-input-27-81394bd6cbfd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Do not forget that strings are immutable (you cannot change them)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0matom_name\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'i'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# Do not forget that strings are immutable (you cannot change them)\n",
    "atom_name[1] = 'i'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mr John Doe\n"
     ]
    }
   ],
   "source": [
    "# However you can do many things with strings, for example you can concatenate them\n",
    "first_name = 'John'\n",
    "last_name = 'Doe'\n",
    "full_name = 'Mr' + ' ' + first_name + ' ' + last_name\n",
    "print(full_name) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sub_string is: raw\n"
     ]
    }
   ],
   "source": [
    "# You can slice them, i.e. extract several sequential characters at a time\n",
    "# <sub_string> = <main_string>[start:stop] where stop is the index AFTER the last wanted character\n",
    "red_fruit = 'strawberry'\n",
    "sub_string = red_fruit[2:5]\n",
    "print('sub_string is:', sub_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sub_string is: berry\n"
     ]
    }
   ],
   "source": [
    "# You can ommit the starting index if you want to start from the beginning\n",
    "# Similarly, you can ommit the stop index if you want to stop at the end\n",
    "red_fruit = 'strawberry'\n",
    "sub_string = red_fruit[5:]\n",
    "print('sub_string is:', sub_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python data structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Data structures prove often essential to write any kind of code, to facilitate reasoning / processing (hence shopping list and calories table)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fav_fruits: ['kiwi', 'mango']\n"
     ]
    }
   ],
   "source": [
    "fav_fruits = ['kiwi', 'mango']\n",
    "print('fav_fruits:', fav_fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fav_fruits_cals: [42, 60]\n"
     ]
    }
   ],
   "source": [
    "fav_fruits_cals = [42, 60]\n",
    "print('fav_fruits_cals:', fav_fruits_cals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'mango'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fav_fruits[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "To use functions on objects such as lists, you can use either:\n",
    "* **general functions** with `<function_name>(<object_name>)` such as `len(fav_fruits)` (to compute length with `len`), OR \n",
    "* **specific object functions**, called **methods**, with  `<object_name>.<method_name>` such as `fav_fruits.extend(['apple', 'pear'])` (to append a list of new elements to the original list with `extend`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(fav_fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "To see the list of all methods applying to an object, use general function `dir`. You can also use \"TAB\" after typing a dot ('.') after your variable name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__delitem__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__iadd__',\n",
       " '__imul__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__reversed__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__setitem__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'append',\n",
       " 'clear',\n",
       " 'copy',\n",
       " 'count',\n",
       " 'extend',\n",
       " 'index',\n",
       " 'insert',\n",
       " 'pop',\n",
       " 'remove',\n",
       " 'reverse',\n",
       " 'sort']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(fav_fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "fav_fruits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fav_food: ['kiwi', 'mango', '4cheese_pizza', 'banana_split']\n"
     ]
    }
   ],
   "source": [
    "fav_food = fav_fruits\n",
    "fav_food.extend(['4cheese_pizza', 'banana_split'])\n",
    "print('fav_food:', fav_food)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fav_food_cals: [42, 60, 1200, 900]\n"
     ]
    }
   ],
   "source": [
    "fav_food_cals = fav_fruits_cals\n",
    "fav_food_cals.extend([1200, 900])\n",
    "print('fav_food_cals:', fav_food_cals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total_fruit_diet_cals: 2202\n"
     ]
    }
   ],
   "source": [
    "total_fruit_diet_cals = sum(fav_fruits_cals)\n",
    "print('total_fruit_diet_cals:', total_fruit_diet_cals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"mutvar_error_article.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## WARNING: Lists are mutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"mutvar_by_ref.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fav_fruits: ['kiwi', 'mango', '4cheese_pizza', 'banana_split']\n",
      "fav_fruits_cals: [42, 60, 1200, 900]\n"
     ]
    }
   ],
   "source": [
    "print('fav_fruits:', fav_fruits)\n",
    "print('fav_fruits_cals:', fav_fruits_cals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fav_fruits:  ['kiwi', 'mango']\n",
      "fav_fruits_cals  [42, 60]\n",
      "total_fruit_diet_cals: 102\n"
     ]
    }
   ],
   "source": [
    "fav_fruits = ['kiwi', 'mango']\n",
    "fav_fruits_cals = [42, 60]\n",
    "# Copy then extend fav_food and fav_food_cals\n",
    "fav_food = fav_fruits.copy() # copy\n",
    "fav_food.extend(['4cheese_pizza', 'banana_split'])\n",
    "fav_food_cals = fav_fruits_cals.copy() # copy\n",
    "fav_food_cals.extend([1200, 900])\n",
    "print('fav_fruits: ', fav_fruits)\n",
    "print('fav_fruits_cals ', fav_fruits_cals)\n",
    "total_fruit_diet_cals = sum(fav_fruits_cals)\n",
    "print('total_fruit_diet_cals:', total_fruit_diet_cals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"mutvar_error_articleerratum.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fav_fruits:  ['kiwi', 'mango']\n",
      "fav_food:  ['kiwi', 'mango', '4cheese_pizza', 'banana_split']\n"
     ]
    }
   ],
   "source": [
    "# Typically there are no problems such as above if you do not initialize a list with another\n",
    "fav_fruits = ['kiwi', 'mango']\n",
    "fav_food = fav_fruits + ['4cheese_pizza', 'banana_split']\n",
    "print('fav_fruits: ', fav_fruits)\n",
    "print('fav_food: ', fav_food)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['we', 'will', 'we', 'will']\n"
     ]
    }
   ],
   "source": [
    "# Python overloads traditional operators in context you may not have think of\n",
    "print(['we', 'will'] * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['we', 'will', 'we', 'will', 'rock', 'you']\n"
     ]
    }
   ],
   "source": [
    "print(['we', 'will'] * 2 + ['rock', 'you'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "food_cals = {\n",
    "          'kiwi': 42,\n",
    "          'mango': 60,\n",
    "          '4cheese_pizza': 1200,\n",
    "          'banana_split': 900\n",
    "          }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "food_cals['mango']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['kiwi', 'mango', '4cheese_pizza', 'banana_split'])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "food_cals.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([42, 60, 1200, 900])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "food_cals.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "1",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-30-69ae36855740>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfood_cals\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 1"
     ]
    }
   ],
   "source": [
    "food_cals[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## WARNING: Dictionaries are mutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Tuples: like lists but immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_experiment_params = (42, 'method3', 3.14, 'paramx', 'paramy')\n",
    "office_lat_long = (46.2221685, 6.1482567)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'count',\n",
       " 'index']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(office_lat_long)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Unpack tuple (number of variables on the left should be equal to len(tuple))\n",
    "office_lat, office_long = office_lat_long"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My office latitude is 46.2221685 and its longitude is 6.1482567\n"
     ]
    }
   ],
   "source": [
    "print('My office latitude is {} and its longitude is {}'.format(office_lat, office_long))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My office latitude is 46.2221685 and its longitude is 6.1482567\n"
     ]
    }
   ],
   "source": [
    "print('My office latitude is {lat} and its longitude is {long}'.format(lat=office_lat, long=office_long))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise\n",
    "1. Create a variable named `my_fruit` referring to the string 'pineapple'\n",
    "2. Using indices, slice (i.e. extract) 'pine' from your variable\n",
    "3. Use either `dir` or \"TAB\" (after writing '.' after your variable name) to display all methods applicable to your variable `my_fruit`\n",
    "4. Use the list above to find a method to test if what is in your variable `my_fruit` ends with `apple`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise\n",
    "1. Create a dictionary `wish_list` representing a list of items you'd like with item names as keys and item prices as values\n",
    "2. Using your dictionary `wish_list`, print the list of item names\n",
    "3. Using your dictionary `wish_list`, print the total cost of your wish list (hint: use the function `sum`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Control structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Most programs need to do repeated actions, and perform different actions according to different conditions. That is why control structures such as \"for loop\" and \"if else statements\" are essential."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### For loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A for loop will iterate for each item in a sequence. A typical example is iterating over a list of integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "seq = [0, 1, 2, 3]\n",
    "for i in seq:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In Python, a built-in function `range` is typically used to generate this sequence. Only indicating the integer `n` to stop at (exclusive) is enough, such as in `range(n)`. Both starting and stopping integers could be used, as in `range(k, n)`. And in the latter case, a `step` can even be set, as in `range(k, n, step)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "n = 3\n",
    "for i in range(n): # same as: for i in range(0, n)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "n = 3\n",
    "for i in range(1, n+1): # remember that stopping integer is exclusive\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "n = 3\n",
    "for i in range(0, n, 2): # the index increase by 2 at each iteration\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The \"for block\" is indicated by an \"indentation\" (typically 4 spaces)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "launch!\n",
      "1\n",
      "launch!\n",
      "2\n",
      "launch!\n"
     ]
    }
   ],
   "source": [
    "n = 3\n",
    "for i in range(n):\n",
    "    print(i)\n",
    "    print('launch!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "launch!\n"
     ]
    }
   ],
   "source": [
    "n = 3\n",
    "for i in range(n):\n",
    "    print(i)\n",
    "print('launch!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The sequence does not have to be a sequence of integers, it can be any \"iterable\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kiwi\n",
      "mango\n",
      "papaya\n"
     ]
    }
   ],
   "source": [
    "fav_fruits = ['kiwi', 'mango', 'papaya']\n",
    "for fruit in fav_fruits:\n",
    "    print(fruit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python allows for concise and elegant syntax and this shows when extracting both the iterating index and the corresponding item."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rank 1: kiwi\n",
      "Rank 2: mango\n",
      "Rank 3: papaya\n"
     ]
    }
   ],
   "source": [
    "# Other programming language\n",
    "n = len(fav_fruits)\n",
    "for i in range(n):\n",
    "    fruit = fav_fruits[i]\n",
    "    print('Rank {}: {}'.format(i+1, fruit))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rank 1: kiwi\n",
      "Rank 2: mango\n",
      "Rank 3: papaya\n"
     ]
    }
   ],
   "source": [
    "# Python uses the built-in function \"enumerate\" to extract both index and item at the same time\n",
    "for i, fruit in enumerate(fav_fruits):\n",
    "    print('Rank {}: {}'.format(i+1, fruit))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This shows as well when iterating over dictionary items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "food_cals = {\n",
    "          'kiwi': 42,\n",
    "          'mango': 60,\n",
    "          '4cheese_pizza': 1200,\n",
    "          'banana_split': 900\n",
    "          }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Food item kiwi has 42 calories\n",
      "Food item mango has 60 calories\n",
      "Food item 4cheese_pizza has 1200 calories\n",
      "Food item banana_split has 900 calories\n"
     ]
    }
   ],
   "source": [
    "# Other programming language\n",
    "all_food_names = food_cals.keys()\n",
    "for food_name in all_food_names:\n",
    "    n_cals = food_cals[food_name]\n",
    "    print('Food item {} has {} calories'.format(food_name, n_cals))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Food item kiwi has 42 calories\n",
      "Food item mango has 60 calories\n",
      "Food item 4cheese_pizza has 1200 calories\n",
      "Food item banana_split has 900 calories\n"
     ]
    }
   ],
   "source": [
    "# Python extract directly the (key, val) pairs with the \"items\" method function\n",
    "for food_name, n_cals in food_cals.items():\n",
    "    print('Food item {} has {} calories'.format(food_name, n_cals))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## If - else statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "An \"if - else\" statement allows to execute commands only if a logical expression is True. The logical expression is called \"Boolean expression\" and is always either True or False. If False the block of commands is not executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Exam for which grade < 5 is fail, grade = 5 requires to resit exam, and grade > 5 is a pass\n",
    "grade = 7\n",
    "if grade < 5:\n",
    "    print(\"Grade too low\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "An `else` statement is executed if the `if` statement is false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grade high enough\n"
     ]
    }
   ],
   "source": [
    "grade = 7\n",
    "if grade < 5:\n",
    "    print(\"Grade too low\")\n",
    "else:\n",
    "    print(\"Grade high enough\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "One or more `elif` statements can be added to add tests. Tests are always evaluated only once, in order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grade high enough\n"
     ]
    }
   ],
   "source": [
    "grade = 7\n",
    "if grade < 5:\n",
    "    print(\"Grade too low\")\n",
    "elif  grade == 5:\n",
    "    print(\"Please resit exam\")\n",
    "elif grade < 8:\n",
    "    print(\"Grade high enough\")\n",
    "elif grade <= 10:\n",
    "    print(\"Excellent grade\")\n",
    "else:\n",
    "    print(\"Your grade is greater than 10!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Boolean expressions can be combined with boolean operators: `and`, `or` or `not`. Below is an example with a dictionary having as values other dictionaries (values can be any objects)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "shopping_list = {\n",
    "              'kiwi': {'cals': 42, 'price': 2},\n",
    "              'mango': {'cals': 60, 'price': 5},\n",
    "              '4cheese-pizza': {'cals': 1200, 'price': 18},\n",
    "              'banana split': {'cals': 900, 'price': 9}\n",
    "              }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dinner tonight could be banana split\n"
     ]
    }
   ],
   "source": [
    "for food_name, food_info in shopping_list.items():\n",
    "    if (not food_info['cals'] < 500) and (food_info['price'] < 15):\n",
    "        print('Dinner tonight could be {}'.format(food_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise\n",
    "1. Create a variable 'my_dict' referring to a dictionary (any content is fine)\n",
    "2. Loop on all methods available for this dictionary, and only print the ones NOT starting with an underscore (`_`)\n",
    "  1. Create a variables `methods` listing all methods applying to your dictionary (hint: use the `dir` function)\n",
    "  2. Create a variable `proper_methods` set to an empty list (you will fill it next)\n",
    "  3. Create a for loop on all the items in the `methods` variable and append it to the list `proper_methods` if it does not start with an underscore"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction to Python - Part 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A function allows you to group *a logical unit set of commands*, which has a specific aim, into **a single entity**. This way you can reuse that function every time you want to achieve that aim. \n",
    "\n",
    "The aim can be very simple such has finding the maximum of a list (function `max`), its length (function `len`) or more complex (finding each unique element and count how many times it occurs )."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def comment_grade(grade):\n",
    "    if grade < 5:\n",
    "        return('Grade too low')\n",
    "    else:\n",
    "        return('Grade high enough')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "A function can have optional arguments, always indicated after the compulsory arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def comment_grade(grade, mode='normal'):\n",
    "    if grade < 5:\n",
    "        return('Grade too low')\n",
    "    elif grade > 5:\n",
    "        if mode == 'normal':\n",
    "            return('Grade high enough')\n",
    "        elif mode == 'positive_reinforcement':\n",
    "            return('Well done, keep going!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "To call the function, use its name, with arguments inside parentheses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Grade high enough'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comment_grade(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In many cases, the user is interested in a return value that he will use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "comment = comment_grade(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grade high enough\n"
     ]
    }
   ],
   "source": [
    "print(comment)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "A function can also have no arguments at all. And return nothing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def say_hello():\n",
    "    print('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "say_hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "greeting = say_hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### A special Python keyword: None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`None` is a case-sensitive keyword to state that a variable does not have any value (like \"null\" in other languages). `None` is not the same as `0`, `False`, or an empty string. `None` has a datatype of its own."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "a = None\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A function always return something. So if nothing is explicitely returned by the function, the return value is `None`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Function docstring"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "When you write a function, you need to document it. This will be used to automatically generate help and documentation, and also help anyone (including yourself at a later date) better understanding what it does."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def comment_grade(grade, mode = 'normal'):\n",
    "    ''' Provide a feedback according to the grade value\n",
    "    \n",
    "        Parameters\n",
    "        ----------\n",
    "        grade : int\n",
    "            The amount of distance traveled\n",
    "        mode : str\n",
    "            The feedback mode, either \"normal\" (default) or \"positive_reinforcement\"\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        comment : str\n",
    "            The grade feedback\n",
    "    '''\n",
    "    if grade < 5:\n",
    "        return('Grade too low')\n",
    "    elif grade > 5:\n",
    "        if mode == 'normal':\n",
    "            return('Grade high enough')\n",
    "        elif mode == 'positive_reinforcement':\n",
    "            return('Well done, keep going!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Best practice is now to use Python \"type hints\" for the function arguments and return values. You can remove this information from the documentation since it is redundant. Type hints provide useful information when using IDEs (linting) and allows to check code logic via third party libraries (e.g. `mypy`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def comment_grade(grade: int, mode: str = 'normal') -> str :\n",
    "    ''' Provide a feedbac k according to the grade value\n",
    "    \n",
    "        Parameters\n",
    "        ----------\n",
    "        grade\n",
    "            The amount of distance traveled\n",
    "        mode\n",
    "            The feedback mode, either \"normal\" (default) or \"positive_reinforcement\"\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        comment\n",
    "            The grade feedback\n",
    "    '''\n",
    "    if grade < 5:\n",
    "        return('Grade too low')\n",
    "    elif grade > 5:\n",
    "        if mode == 'normal':\n",
    "            return('Grade high enough')\n",
    "        elif mode == 'positive_reinforcement':\n",
    "            return('Well done, keep going!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "student_results = {\n",
    "               'John': 3,\n",
    "               'Mary': 9,\n",
    "               'Peter': 5\n",
    "               }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feedback for John: Grade too low\n",
      "Feedback for Mary: Well done, keep going!\n",
      "Feedback for Peter: None\n"
     ]
    }
   ],
   "source": [
    "for s_name, s_grade in student_results.items():\n",
    "    s_feedback = comment_grade(s_grade, mode='positive_reinforcement')\n",
    "    print('Feedback for {}: {}'.format(s_name, s_feedback))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Proper Python code development: use an IDE (e.g. Visual Studio Code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Jupyter notebooks do not allow to easily debug, reuse and version-control your code**. As such it is much better practice to develop functions inside an Integrate Development Environment (IDE) to write the main functions there. You can then import them inside your Jupyter Notebook (and reuse them in other notebooks, in other projects, and with other people with e.g. GitHub)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Functions can be (and often are) imported from modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from random import randrange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "randrange?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "max_grade = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "random_grade = randrange(0, max_grade+1)\n",
    "print(random_grade)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "random_grade = random.randrange(0, max_grade+1)\n",
    "print(random_grade)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Remember `PATH` in the Linux lecture ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "sys.path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/opt/conda/shared/envs/ds38/lib/python3.8/os.py'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.__file__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "A module is a python file (ending in `.py`), usually containing python functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To import functions, simply use `import` followed by the name of your python file without the `.py` extension, e.g. `import grading` if your python file is called `grading.py`.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise (using module in Jupyter notebook)\n",
    "1. Open a terminal in VS Code (`Terminal` --> `New Terminal`) and create the directory `autograder` in the `python_lecture` directory\n",
    "2. Create a new file in VS Code (`File` --> `New File`) and copy the definition of the function `comment_grade`\n",
    "3. Save it in the directory `autograder` with the name `grading.py` (`File` --> `Save As`, then search the `autograder` directory you created, clicking on `..` (parent directory) if required)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "4. Go back into the Jupyter notebook and try to import your `grading` module so that to call the function `comment_grade` within your notebook. Does it work ?\n",
    "5. Add the path to your `autograder` directory by appending it to the `sys.path` list.  \n",
    "Remember that:\n",
    "    * you can append an element `el` to a list `l` with `l.append(el)`\n",
    "    * a path is a string (i.e. a sequence of characters) and so should be put in between quotes\n",
    "6. Try again to import your `grading` module\n",
    "7. Print the help of your function (`help(fun)`, or `fun?`, or `Shift + Tab` after having written the function name)\n",
    "8. Call the function with a grade of your choice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise (using module in VS Code)\n",
    "1. Create a new file in VS Code (`File` --> `New File`) and copy:\n",
    "    * the definition of the dictionary `student_results`\n",
    "    * the code applying the function `comment_grade` on each item of the dictionary\n",
    "2. Save the in the directory `autograder` with the name `exam1.py` (`File` --> `Save As`, then search the `autograder` directory you created, clicking on `..` (parent directory) if required)\n",
    "3. Import the `grading` module in the `exam1.py` file you just saved (no need to update sys.path as the current function directory is always on the path contrarily to `bash`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "4. Make sure your code will use the function `comment_grade` of that module (choose between `import grading` or `from grading import comment_grade` and adapt the code)\n",
    "5. In the terminal type `python` and then the path to your `exam1.py` file for python to run your code (note: this is the same as clicking on the `run` icon (green triangle) on the top right)\n",
    "6. Can you see something strange in the outputs?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Example of debugging (`Run` --> `Start debugging`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Exercise (using module in VS Code)\n",
    "1. Correct the bug and check it works\n",
    "2. Save the file\n",
    "3. Import `exam1` inside the Jupyter notebook. What do you notice ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Your python file can be used in two ways:\n",
    "* Called on the command line with `python` (e.g. `python exam1.py`)\n",
    "* Imported in another file or in a Jupyter notebook to use all the functions defined inside\n",
    "\n",
    "Careful: when you import a file, all the code inside it will be executed !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python use the keywork `__name__` to understand how your file was used:\n",
    "* If it was called from the command line, then `__name__` will be automatically set to `__main__`\n",
    "* If it was imported, then `__name__` will be automatically set to your file name (e.g. `exam1`)  \n",
    "\n",
    "To have a part of your file automatically run on the command line, use:  \n",
    "```\n",
    "if __name__ == \"__main__\":\n",
    "    ...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise (using module in VS Code)\n",
    "1. Modify `exam1` so that it only executes the code when it is run from the command line\n",
    "2. Test by saving it and running it from the command line\n",
    "3. Test by importing in the Jupyter notebook and observing nothing happened\n",
    "    * Tip: use the following to re-import a module which has been modified:  \n",
    "```\n",
    "import importlib\n",
    "importlib.reload(my_module)```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exceptions and assert statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Errors are essential to be able to understand why something went wrong. You can throw yourself so called \"Exceptions\" in your code should something unexpected occurs, such as another module or a user not using your function as intended."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def comment_grade(grade: int, mode: str = 'normal') -> str :\n",
    "    ''' Provide a feedback according to the grade value\n",
    "    \n",
    "        Parameters\n",
    "        ----------\n",
    "        grade\n",
    "            The amount of distance traveled\n",
    "        mode\n",
    "            The feedback mode, either \"normal\" (default) or \"positive_reinforcement\"\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        comment\n",
    "            The grade feedback\n",
    "    '''\n",
    "    if grade >= 0 and grade < 5:\n",
    "        return('Grade too low')\n",
    "    elif grade >= 5 and grade <= 10:\n",
    "        if mode == 'normal':\n",
    "            return('Grade high enough')\n",
    "        elif mode == 'positive_reinforcement':\n",
    "            return('Well done, keep going!')\n",
    "        else:\n",
    "            raise ValueError('The mode should be \"normal\" or \"positive_reinforcement\"')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The mode should be \"normal\" or \"positive_reinforcement\"",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-27-61b62a4c2f2b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcomment_grade\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"tough\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-25-e9aa7469f387>\u001b[0m in \u001b[0;36mcomment_grade\u001b[0;34m(grade, mode)\u001b[0m\n\u001b[1;32m     22\u001b[0m             \u001b[0;32mreturn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Well done, keep going!'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 24\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'The mode should be \"normal\" or \"positive_reinforcement\"'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: The mode should be \"normal\" or \"positive_reinforcement\""
     ]
    }
   ],
   "source": [
    "comment_grade(7, mode=\"tough\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "For a list of Python Exceptions, please see [here](https://docs.python.org/3/library/exceptions.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Assert statements are particularly useful to test the internal logic of your code, to check that impossible events indeed never happen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def comment_grade(grade: int, mode: str = 'normal') -> str :\n",
    "    ''' Provide a feedback according to the grade value\n",
    "    \n",
    "        Parameters\n",
    "        ----------\n",
    "        grade\n",
    "            The amount of distance traveled\n",
    "        mode\n",
    "            The feedback mode, either \"normal\" (default) or \"positive_reinforcement\"\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        comment\n",
    "            The grade feedback\n",
    "    '''\n",
    "    if grade >= 0 and grade < 5:\n",
    "        return('Grade too low')\n",
    "    elif grade > 5 and grade <= 10:\n",
    "        if mode == 'normal':\n",
    "            return('Grade high enough')\n",
    "        elif mode == 'positive_reinforcement':\n",
    "            return('Well done, keep going!')\n",
    "        else:\n",
    "            raise ValueError('The mode should be \"normal\" or \"positive_reinforcement\"')\n",
    "    else:\n",
    "        assert (grade < 0 or grade > 10), 'INTERNAL BUG: grade is not less than 0 or greater than 10'\n",
    "        raise ValueError('EXTERNAL ERROR: The grade entered should be between 0 and 10')\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "INTERNAL BUG: grade is not less than 0 or greater than 10",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-40-41e0e863e2d4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcomment_grade\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-38-5cfe2777a96e>\u001b[0m in \u001b[0;36mcomment_grade\u001b[0;34m(grade, mode)\u001b[0m\n\u001b[1;32m     24\u001b[0m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'The mode should be \"normal\" or \"positive_reinforcement\"'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m         \u001b[0;32massert\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mgrade\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mgrade\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'INTERNAL BUG: grade is not less than 0 or greater than 10'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     27\u001b[0m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'EXTERNAL ERROR: The grade entered should be between 0 and 10'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAssertionError\u001b[0m: INTERNAL BUG: grade is not less than 0 or greater than 10"
     ]
    }
   ],
   "source": [
    "comment_grade(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "It is convenient to define test functions (starting with `test_`) to run a group of assert statements. The `pytest` package is helpful to automatically run this kind of test functions (cf later section)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def test_comments():\n",
    "    assert comment_grade(0, mode='normal') == 'Grade too low'\n",
    "    assert comment_grade(2, mode='normal') == 'Grade too low'\n",
    "    assert comment_grade(5, mode='normal') == 'Grade high enough'\n",
    "    assert comment_grade(5, mode='positive_reinforcement') == 'Well done, keep going!'\n",
    "    assert comment_grade(10, mode='normal') == 'Grade high enough'\n",
    "    assert comment_grade(10, mode='positive_reinforcement') == 'Well done, keep going!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "INTERNAL BUG: grade is not less than 0 or greater than 10",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-45-a3b233d16f3f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_comment_grade\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-41-050aabd910cd>\u001b[0m in \u001b[0;36mtest_comment_grade\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mcomment_grade\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'normal'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'Grade too low'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mcomment_grade\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'normal'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'Grade too low'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0;32massert\u001b[0m \u001b[0mcomment_grade\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'normal'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'Grade high enough'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mcomment_grade\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'positive_reinforcement'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'Well done, keep going!'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mcomment_grade\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'normal'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'Grade high enough'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-38-5cfe2777a96e>\u001b[0m in \u001b[0;36mcomment_grade\u001b[0;34m(grade, mode)\u001b[0m\n\u001b[1;32m     24\u001b[0m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'The mode should be \"normal\" or \"positive_reinforcement\"'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m         \u001b[0;32massert\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mgrade\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mgrade\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'INTERNAL BUG: grade is not less than 0 or greater than 10'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     27\u001b[0m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'EXTERNAL ERROR: The grade entered should be between 0 and 10'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAssertionError\u001b[0m: INTERNAL BUG: grade is not less than 0 or greater than 10"
     ]
    }
   ],
   "source": [
    "test_comment_grade()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`pytest` can be used not only to run tests from functions, but also to check results of Numpy docstring examples. In this case, use the `--doctest-modules` flag."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def comment_grade(grade: int, mode: str = 'normal') -> str :\n",
    "    ''' Provide a feedback according to the grade value\n",
    "    \n",
    "        Parameters\n",
    "        ----------\n",
    "        grade\n",
    "            The amount of distance traveled\n",
    "        mode\n",
    "            The feedback mode, either \"normal\" (default) or \"positive_reinforcement\"\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        comment\n",
    "            The grade feedback\n",
    "\n",
    "        Examples\n",
    "        --------\n",
    "        >>> comment_grade(6)\n",
    "    '''\n",
    "    if grade >= 0 and grade < 5:\n",
    "        return('Grade too low')\n",
    "    elif grade >= 5 and grade <= 10:\n",
    "        if mode == 'normal':\n",
    "            return('Grade high enough')\n",
    "        elif mode == 'positive_reinforcement':\n",
    "            return('Well done, keep going!')\n",
    "        else:\n",
    "            raise ValueError('The mode should be \"normal\" or \"positive_reinforcement\"')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:shared-ds38]",
   "language": "python",
   "name": "conda-env-shared-ds38-py"
  },
  "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}