python_part1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/NIDS2020-instructor/python-part1/HEAD?filepath=python_part1.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction to Python"
   ]
  },
  {
   "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": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}