1_Python_crash_course.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python crash course\n",
    "\n",
    "If you already did this before, feel free to skim through it for a refresher and do the exercises (including those at the end).\n",
    "\n",
    "*This notebook can also be used as a Python syntax reference throughout the course.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### The Zen of Python\n",
    "\n",
    "The 20 principles that influences the design of Python. \n",
    "\n",
    "Written in the 1999, they have been included as the 20th entry of the Python Enhancement Proposals (a.k.a. [PEP 20](https://www.python.org/dev/peps/pep-0020/))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "# eastern egg\n",
    "import this # import is used to pull code from somewhere else (e.g., the Python standard library)\n",
    "# this, by the way, is a comment: a piece of text which will not be executed as code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*In December 1989, Van Rossum had been looking for a \"'hobby' programming project that would keep [him] occupied during the week around Christmas\" as his office was closed when he decided to write an interpreter for a \"new scripting language [he] had been thinking about lately: a descendant of ABC that would appeal to Unix/C hackers\". He attributes choosing the name \"Python\" to \"being in a slightly irreverent mood (and a big fan of Monty Python's Flying Circus)\".* https://en.wikipedia.org/wiki/Guido_van_Rossum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Getting Started\n",
    "\n",
    "The simplest way is to type commands directly in the **Interactive** IPython shell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic interface of Colab notebooks:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![alt text](images/notebook-ui.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (Optional) loading data in Colab\n",
    "\n",
    "You can mount your own Google drive via Colab, to read/write your files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from google.colab import drive\n",
    "drive.mount('/content/gdrive')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check where you are at\n",
    "! ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# move in the folder hierarchy\n",
    "%cd 'gdrive'/'My Drive'/'project_folder'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cloning our repository\n",
    "! git clone https://github.com/Giovanni1085/UvA_CSDA_2021"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Variables\n",
    "\n",
    "Variables are reserved **memory locations** used by a computer program.\n",
    "\n",
    "Each variable is associated with an **identifier** (i.e. a name). Python restricts the naming possibilities of a variable:\n",
    "\n",
    "- identifier characters may be letters, digits or underscores...\n",
    "\n",
    "- ... but the first character cannot be a number\n",
    "\n",
    "- Python keywords cannot be used as identifiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "a = \"Hello\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
     ]
    }
   ],
   "source": [
    "# list of Python keywords\n",
    "import keyword\n",
    "print(keyword.kwlist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "cannot assign to None (2683696864.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Input \u001b[0;32mIn [7]\u001b[0;36m\u001b[0m\n\u001b[0;31m    None = 10\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m cannot assign to None\n"
     ]
    }
   ],
   "source": [
    "# Nope.\n",
    "None = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### Python does not require variables to be declared explicitly\n",
    "\n",
    "Variables are created when you first assign a value to them.\n",
    "\n",
    "The symbol `=` is used to assign values to variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# let's associate the value 55 to the variable named \"a_number\"\n",
    "a_number = 55"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the type of value of the variable can be inspected with the function type()\n",
    "type(a_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### Variable types can change during the execution of a command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's convert our numerical variable into a digit (i.e. into text)\n",
    "a_number = str(a_number)\n",
    "a_number\n",
    "type(a_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Built-in data types\n",
    "\n",
    "Python natively supports the following basic types:\n",
    "\n",
    "- **Boolean**: *bool*\n",
    "\n",
    "- **None**: *NoneType*\n",
    "\n",
    "- **Numerical**: *int*, *float*, *long*, *complex*\n",
    "\n",
    "- **Sequence**: *string*, *list*, *tuple*\n",
    "\n",
    "- **Set**: *set*, *frozenset*\n",
    "\n",
    "- **Dictionaries**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Mutable vs. Immutable objects\n",
    "\n",
    "Python data types can be organized by distinguishing those types whose objects can change after their creation (**Mutable**) and those that do not admit such possibility (**Immutable**)\n",
    "\n",
    "| Immutables|   Mutables|\n",
    "|:---------:|:---------:|\n",
    "|  Numerical|          -|\n",
    "|     String|          -|\n",
    "|      Tuple|       List|\n",
    "|  Frozenset|        Set|\n",
    "|          -| Dictionary|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### NoneType\n",
    "\n",
    "It has one sole value: `None`. It is used to represent the absence of a value.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### bool\n",
    "\n",
    "Boolean logical values, can be `True` or `False`.\n",
    "\n",
    "To be used to represent the truth or falsity of some condition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Boolean Operators\n",
    "\n",
    "- **and**: conjunction\n",
    "- **or**: inclusive disjunction\n",
    "- **not**: negation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False or True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Numerical Types\n",
    "\n",
    "- **int**: integers, e.g. `92`\n",
    "- **long**: long integers of non-limited length, e.g. `15L`\n",
    "- **float**: floating-point numbers, e.g. `8.75638`\n",
    "- **complex**: complex numbers, e.g. `1.23+4.56j`\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Using Python as a Calculator\n",
    "\n",
    "The simplest way to perform calculations with Python is by using the interactive shell as a fancy calculator. \n",
    "\n",
    "Some of the operations supported by all the numeric types are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# addition\n",
    "3 + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# difference\n",
    "9 - 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "450"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# product\n",
    "9 * 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.5"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# quotient\n",
    "9 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Floor division gives us the default behavior of division in Python 2\n",
    "9 // 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the remainder of the floored quotient\n",
    "9 % 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# x to the power of y\n",
    "3 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.765"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Round a number to a given precision in decimal digits (default 0 digits)\n",
    "round(1.765432, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz\n",
    "\n",
    "Calculate the number of seconds we're going to spend in this classroom together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### (Optional) \n",
    "\n",
    "While the previous operators produce new variables, the following perform the operation **in-place**. \n",
    "\n",
    "That is, the variable itself is changed in the result of the process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# our variable\n",
    "a_number = 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# IN PLACE addition\n",
    "a_number += 3\n",
    "a_number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# IN PLACE subtraction\n",
    "a_number -= 3\n",
    "a_number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# IN PLACE multiplication\n",
    "a_number *= 3\n",
    "a_number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# IN PLACE division\n",
    "a_number /= 3\n",
    "a_number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# IN PLACE modulus\n",
    "a_number %= 3\n",
    "a_number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Relational Operators\n",
    "\n",
    "Comparisons are supported by all objects. The main comparison operators are:\n",
    "\n",
    "|   Operator|                Semantics|\n",
    "|:---------:|:-----------------------:|\n",
    "|         ==|                    equal|\n",
    "|         !=|                not equal|\n",
    "|          <|                less-than|\n",
    "|         <=|    less-than or equal to|\n",
    "|          >|             greater-then|\n",
    "|         >=| greater-then or equal to|\n",
    "|         is| object identity|\n",
    "|         is not| negated object identity|\n",
    "\n",
    "Relational operators are used to **test conditions**, and the output is a boolean value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# is 7 bigger than 9?\n",
    "7 > 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sequences\n",
    "\n",
    "We will focus on three types of sequences: **strings**, **lists** and **tuples** (see the [documentation](https://docs.python.org/2/library/stdtypes.html#sequence-types-str-unicode-list-tuple-bytearray-buffer-xrange) for the full list). \n",
    "\n",
    "Most sequence types support the following operations (where `s` and `t` are sequences, `n`, `i` and `j` integers):\n",
    "\n",
    "|   Operation|                Result|\n",
    "|:----------:|:-----------------------:|\n",
    "|      x in s|  True if an item of s is equal to x|\n",
    "|  x not in s|  False if an item of s is equal to x|\n",
    "|       s + t| Concatenation of s and t|\n",
    "|       s * n|   add s to itself n times (negative n are treated as 0)|\n",
    "|        s[i]|\tith item of s, origin 0|\n",
    "|      s[i:j]|   slice of s from i to j|\n",
    "|    s[i:j:k]| slice of s from i to j with step k|\n",
    "|      len(s)| length of s|\t \n",
    "|      min(s)| smallest item of s|\n",
    "|      max(s)| largest item of s|\n",
    "|  s.index(x)| index of the first occurrence of x in s |\n",
    "|  s.count(x)| total number of occurrences of x in s|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Lists\n",
    "\n",
    "\n",
    "Lists are **ordered** **mutable** sequences of **heterogeneous** elements.\n",
    "\n",
    "In the Python language, lists are defined by square brackets `[]` and their elements are separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['text', 23, 92, 'another_text', [1, 2, 3]]\n"
     ]
    }
   ],
   "source": [
    "# lists can contain different types of objects (even another list like [1,2,3])\n",
    "demo_list = [\"text\", 23, 92, \"another_text\", [1,2,3]]\n",
    "print(demo_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# len() returns the length of the list\n",
    "len(demo_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# membership verification (return a boolean value)\n",
    "23 in demo_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['text',\n",
       " 23,\n",
       " 92,\n",
       " 'another_text',\n",
       " [1, 2, 3],\n",
       " 'text',\n",
       " 23,\n",
       " 92,\n",
       " 'another_text',\n",
       " [1, 2, 3]]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# concatenation\n",
    "new_demo_list = demo_list + demo_list\n",
    "new_demo_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['text',\n",
       " 23,\n",
       " 92,\n",
       " 'another_text',\n",
       " [1, 2, 3],\n",
       " 'text',\n",
       " 23,\n",
       " 92,\n",
       " 'another_text',\n",
       " [1, 2, 3],\n",
       " 'text',\n",
       " 23,\n",
       " 92,\n",
       " 'another_text',\n",
       " [1, 2, 3]]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# repetition\n",
    "new_demo_list = demo_list * 3\n",
    "new_demo_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Lists are ordered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'text'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lists are ordered, elements can be recalled by using their index (remember that the index of the first element is 0)\n",
    "demo_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the index \"-1\" is associated with the last element\n",
    "demo_list[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check the position of the element \"23\"\n",
    "demo_list.index(23)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slicing\n",
    "\n",
    "\n",
    "Slicing is a **computationally fast** way to extract a portion of a sequence in order to create a new sequence. \n",
    "\n",
    "Slicing Notation works in the following way:\n",
    "\n",
    "\n",
    "```python\n",
    "sequence[start:stop:step]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### Slicing rules\n",
    "\n",
    "- The slice of the sequence `s` from `start` to `stop` is defined as the sequence of items with index `k` such that `start` <= `k` < `stop`. \n",
    "\n",
    "\n",
    "- If `start` or `stop` is greater than len(`s`), use len(`s`). \n",
    "\n",
    "\n",
    "- If `start` is omitted or `None`, use 0. \n",
    "\n",
    "\n",
    "- If `stop` is omitted or `None`, use len(`s`). \n",
    "\n",
    "\n",
    "- If `start` or `stop` is negative, the index is relative to the end of sequence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "![alt text](images/list-slicing.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['text', 23, 92, 'another_text', [1, 2, 3]]\n"
     ]
    }
   ],
   "source": [
    "print(demo_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[23, 92]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slicing with positive indices \n",
    "demo_list[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[92, 'another_text']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slicing works with negative indices as well \n",
    "demo_list[-3:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[23, 92]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slicing works with a mixture of positive and negative indices\n",
    "demo_list[1:-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[92, 'another_text', [1, 2, 3]]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# if an index is omitted, Python reaches the first or the last element of the list\n",
    "demo_list[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['text', 23, 92]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the same as above, with the first index omitted\n",
    "demo_list[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[23, 'another_text']"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slicing with steps\n",
    "demo_list[1::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz\n",
    "\n",
    "The following code creates a list whose length is a-priori unknown. Extract:\n",
    "\n",
    "- the last element of the list by using a positive index\n",
    "\n",
    "\n",
    "- the first element of the list by using a negative index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[55 67 52 80 25 42 44 23 44 64]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "random_length_list = np.random.choice(99, 10)\n",
    "print(random_length_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Lists are mutable\n",
    "\n",
    "Lists methods allows you to manipulate the elements stored in the list quickly and effectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['text', 23, 92, 'another_text', [1, 2, 3], 'appended']\n"
     ]
    }
   ],
   "source": [
    "# the method .append() allows you to add an element at the end of the list\n",
    "# Equivalent to `demo_list[len(demo_list):] = [\"appended\"]`\n",
    "demo_list.append(\"appended\")\n",
    "print(demo_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['text', 23, 92, 'another_text', [1, 2, 3], 'appended', 'elements', 'of', 'another', 'list']\n"
     ]
    }
   ],
   "source": [
    "# the method .extend() allows you to add all the elements of a second list\n",
    "demo_list.extend([\"elements\",\"of\",\"another\",\"list\"])\n",
    "print(demo_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['text', 23, 92, 'another_text', [1, 2, 3], 'elements', 'of', 'another', 'list']\n"
     ]
    }
   ],
   "source": [
    "# the method .remove() allows you to remove a given elements from a list\n",
    "demo_list.remove(\"appended\")\n",
    "print(demo_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Bonus question: What happens if the list contained duplicates of the removed element?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['list', 'another', 'of', 'elements', [1, 2, 3], 'another_text', 92, 23, 'text']\n"
     ]
    }
   ],
   "source": [
    "# the method .reverse() reverses a list IN PLACE (i.e. the original list is modified)\n",
    "demo_list.reverse()\n",
    "print(demo_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['list', 'new_text', 7, 38, 'elements', [1, 2, 3], 'another_text', 92, 23, 'text']\n"
     ]
    }
   ],
   "source": [
    "# slicing can be used also to replace elements in a list\n",
    "demo_list[1:3] = [\"new_text\", 7, 38]\n",
    "print(demo_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['list', 'new_text', 7, 38, 'another_text', 92, 23, 'text']\n"
     ]
    }
   ],
   "source": [
    "# slicing can be used to delete elements\n",
    "demo_list[4:6] = []\n",
    "print(demo_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 8, 9, 33, 56, 220]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the method .sort() order a list (NOTE: the list elements must be of the same type)\n",
    "homogeneous_list = [1,56,33,8,220,9]\n",
    "homogeneous_list.sort()\n",
    "homogeneous_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ant', 'canary', 'elephant', 'hippo', 'kangaroo', 'narwhal', 'raccoon', 'yak']"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lists of strings can be sorted as well\n",
    "homogeneous_list = [\"canary\", \"hippo\", \"kangaroo\", \"narwhal\", \"elephant\", \"raccoon\", \"yak\", \"ant\"]\n",
    "homogeneous_list.sort()\n",
    "homogeneous_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz\n",
    "\n",
    "Explain the sorting of the following list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '220', '33', '56', '8', '9']"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "homogeneous_list =[\"1\", \"56\", \"33\", \"8\", \"220\", \"9\"]\n",
    "homogeneous_list.sort()\n",
    "homogeneous_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### Lists of numbers\n",
    "\n",
    "Lists of numbers can be manipulated by additional functions, among which **max()**, **min()** and **sum**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "2\n",
      "31\n"
     ]
    }
   ],
   "source": [
    "some_numbers = [4, 8, 2, 6, 2, 9]\n",
    "print(max(some_numbers))\n",
    "print(min(some_numbers))\n",
    "print(sum(some_numbers))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Quiz\n",
    "\n",
    "Compute the average of `some_numbers`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### (Optional) Tuples\n",
    "\n",
    "Tuples are the **immutable** counterpart of the lists. \n",
    "\n",
    "They are defined by round brackets `()` and they mainly differ from the list in that they do not accept those methods that tries to manipulate its elements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('text', 23, 92, 'another_text', [1, 2, 3])\n"
     ]
    }
   ],
   "source": [
    "# tuples can contain different types of objects (even another list like [1,2,3])\n",
    "demo_tuple = (\"text\", 23, 92, \"another_text\", [1,2,3])\n",
    "print(demo_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(23, 92)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# elements can be accessed on the basis of their index...\n",
    "demo_tuple[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'tuple' object does not support item assignment\n"
     ]
    }
   ],
   "source": [
    "# ...but they cannot be replaces\n",
    "try:\n",
    "    demo_tuple[1] = 2\n",
    "except TypeError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Strings\n",
    "\n",
    "Strings are **immutable**, sequences of characters (so, they are **homogeneus**)\n",
    "\n",
    "In the Python language, strings are defined by single `'` or double quotes `\"`,  and their elements are continguous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Does Cersei have any friends?\n"
     ]
    }
   ],
   "source": [
    "demo_string = \"Does Cersei have any friends?\"\n",
    "print(demo_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using single or double quotes is indifferent\n",
    "demo_string_single = 'Does Cersei have any friends?'\n",
    "demo_string == demo_string_single"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "\"1979\" type is: <class 'str'>\n",
      "1979 type is:<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# Remember: Digits =/= numbers! (frequent source of debugging frustration)\n",
    "print (type(\"1979\") == type(1979))\n",
    "print ('\"1979\" type is: ' + str(type(\"1979\")))\n",
    "print ('1979 type is:' + str(type(1979)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "By being immutable sequences, strings accept all the sequences methods, but they not support item assignment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# you can check the length (in charachters, whitespaces count!!!) of a string\n",
    "len(demo_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# strings can be looked for in other strings\n",
    "\"Cersei\" in demo_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# how many 'a's do we have in our string?\n",
    "demo_string.count(\"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Does Cersei have any friends?\\nNoway!'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# concatenation is possible\n",
    "demo_string += \"\\nNoway!\"\n",
    "demo_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The escape sequence `\\n` indicates the end of the line. \n",
    "\n",
    "Python escape sequences are introduced by the escape character `\\`, whose goal is to signal the interpreter that the following character has an \"unusual\" interpretation. Here is a partial list:\n",
    "\n",
    "| Escape Sequence|         Meaning|\n",
    "|:--------------:|:---------------:|\n",
    "|              \\\\\\\\|  backslash|\n",
    "|              \\\\'|  single quote|\n",
    "|              \\\\b|  backspace|\n",
    "|              \\\\n|  new line|\n",
    "|              \\\\t|  horizontal tab|\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Does Cersei have any friends?\n",
      "Noway!\n"
     ]
    }
   ],
   "source": [
    "# nicely print our string!\n",
    "print(demo_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Does Cersei have any friends?\n",
      "Noway!\b\n"
     ]
    }
   ],
   "source": [
    "# what does a backspace do?\n",
    "print(demo_string  +\"\\b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"can any of you pronounce 's-Hertogenbosch?\""
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the escape character may be useful when you need single quotes inside a single quote-marked string...\n",
    "'can any of you pronounce \\'s-Hertogenbosch?'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"can any of you pronounce 's-Hertogenbosch?\""
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# but I prefer this solution (when possible)\n",
    "\"can any of you pronounce 's-Hertogenbosch?\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Strings that span multiple lines can be written in a readable form by using the sequence `\"\"\"` as a delimiter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unsealed, on a porch a letter sat\n",
      "Then you said, \"I wanna leave it again\"\n",
      "Once I saw her on a beach of weathered sand\n",
      "And on the sand I wanna leave her again\n"
     ]
    }
   ],
   "source": [
    "print(\"\"\"Unsealed, on a porch a letter sat\n",
    "Then you said, \"I wanna leave it again\"\n",
    "Once I saw her on a beach of weathered sand\n",
    "And on the sand I wanna leave her again\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\"On a weekend I wanna wish it all away, yeah\\nAnd they called and I said that I\\'ll go\\nAnd I said that I\\'ll call out again\\nAnd the reason I ought ta leave her calm, I know\\nI said, \"I don\\'t know whether I\\'m the boxer or the bag'"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# where do all those '\\n's come from???\n",
    "\"\"\"\"On a weekend I wanna wish it all away, yeah\n",
    "And they called and I said that I'll go\n",
    "And I said that I'll call out again\n",
    "And the reason I ought ta leave her calm, I know\n",
    "I said, \"I don't know whether I'm the boxer or the bag\"\"\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Monty'"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# string slicing\n",
    "\"Monty Python\"[-12:-7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'str' object does not support item assignment\n"
     ]
    }
   ],
   "source": [
    "# ...but single characters cannot be replaced\n",
    "try:\n",
    "    demo_string[5:11] = \"Melisandre\"\n",
    "except TypeError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### (Optional) String Methods\n",
    "\n",
    "Strings have a buch of dedicated methods (see the [documentation](https://docs.python.org/2/library/stdtypes.html#string-methods) for a complete list), that allows them to be both inspected or manipulated (they are not modified, rather a **new object** is returned). The following are those I use the most:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# is the string composed SOLELY of 1. digits 2. alphabetic characters 3. both?\n",
    "print('100'.isdigit())\n",
    "print('cat'.isalpha())\n",
    "print('my cat is 100'.isalnum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Does Cersei have any friends?\n",
      "Noway!\n"
     ]
    }
   ],
   "source": [
    "print(demo_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# does the string starts or ends with a given sequence of characters?\n",
    "print(demo_string.startswith(\"d\"))  # it is case sensitive !!!\n",
    "print(demo_string.endswith(\"Noway!\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DOES CERSEI HAVE ANY FRIENDS?\n",
      "does cersei have any friends?\n"
     ]
    }
   ],
   "source": [
    "# change case to all the characters of a string\n",
    "print(demo_string_single.upper())\n",
    "print(demo_string_single.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Twice minus: - before and after \n",
      "Too much space?\n"
     ]
    }
   ],
   "source": [
    "# remove a given character (default is any whitespace) from the beginning and the end of a string\n",
    "print (\"Twice minus: - before and after -\".strip(\"-\"))\n",
    "print (\"  \\t  Too much space?\".strip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Does Melisandre have any friends?\n",
      "Noway!\n"
     ]
    }
   ],
   "source": [
    "# replace a given sequence of characters with another \n",
    "print(demo_string.replace(\"Cersei\", \"Melisandre\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "A string can be transformed into a list of string by splitting it on a given character"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Does', 'Cersei', 'have', 'any', 'friends?']"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a whitespace\n",
    "demo_string_single.split(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Does', 'Cersei', 'have', 'any', 'friends?', 'Noway!']"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the default character is any white line (that's convenient)\n",
    "demo_string.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Does', 'Cersei', 'have any friends?']"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the maximun number of slits can be specified\n",
    "demo_string_single.split(\" \", 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The inverse operation is possible, a list of strings can be joined by a single character"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'One Two Three'"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a whitespace\n",
    "\" \".join([\"One\",\"Two\",\"Three\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'One-Two-Three'"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# an hyphen\n",
    "\"-\".join([\"One\",\"Two\",\"Three\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Supercalifragilisticexpialidocious'"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# no characters at all\n",
    "\"\".join([\"Super\", \"cali\", \"fragilistic\", \"expiali\", \"docious\"] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sequence item 3: expected str instance, int found\n"
     ]
    }
   ],
   "source": [
    "# BEWARE: non string elements in the original list are not admitted\n",
    "try:\n",
    "    \" \".join([\"Today\", \"I\", \"am\", 45])\n",
    "except TypeError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz\n",
    "\n",
    "Italian nobles tends to have an awful lot of names. \n",
    "\n",
    "For instance, \"Vittorio Emanuele di Savoia\" has the 12 names listed in `full_name`. \n",
    "\n",
    "Can you find a pythonic way to eliminate the less used names from this string?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_name = \"Vittorio Emanuele Alberto Carlo Teodoro Umberto Bonifacio Amedeo Damiano Bernardino Gennaro Maria di Savoia\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### (Optional) Sets\n",
    "\n",
    "Sets are collections of **unordered** of **distinct** objects.\n",
    "\n",
    "They are commonly used to test membership, to remove duplicates or to compute mathematical operations such as intersection, union, difference, and symmetric difference. Being unordered collections, they do not support indexing, slicing and any other sequence-like behavior.\n",
    "\n",
    "In Python, sets can be create beither by using the syntax  `set([])` or by using curly braces `{}`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6}\n",
      "{1, 3, 6, 9}\n"
     ]
    }
   ],
   "source": [
    "# when you creates a set, repetitions are removed\n",
    "demo_set = set([1,2,1,2,1,2,3,5,6,4,2,3,5,2])\n",
    "another_demo_set = {1,6,6,3,9}\n",
    "print(demo_set)\n",
    "print(another_demo_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7}"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# elements may we added with the function add()\n",
    "demo_set.add(7)\n",
    "demo_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 4, 5, 6, 7}"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# elements may we removed with the function remove()\n",
    "demo_set.remove(2)\n",
    "demo_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# length of a set\n",
    "len(demo_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# membership test\n",
    "5 in demo_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 4, 5, 6, 7, 9}"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the union of the two sets\n",
    "demo_set.union(another_demo_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 6}"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# intersection of the two sets\n",
    "demo_set.intersection(another_demo_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5, 7}"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# elements that are in the demo_set but not in another_demo_set\n",
    "demo_set.difference(another_demo_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# every elements of another_demo_set are in demo_set?\n",
    "print(demo_set.issuperset(another_demo_set))\n",
    "print(another_demo_set.issubset(demo_set))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz\n",
    "\n",
    "The following list contains 100 random extractions (with replacement) of numbers between 1 and 15. \n",
    "\n",
    "Find the number that has never been extracted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_numbers = [1, 2, 1, 1, 9, 13, 15, 5, 9, 8, 12, 14, 3, 2, 8, 10, 3, 12, 15, 13, 5, 3, 7, 5, 2, 13, 12, 8, 10, 5, 15, 8, 2, 8, 5, 12, 9, 2, 3, 5, 1, 4, 5, 9, 13, 2, 12, 5, 10, 8, 1, 15, 15, 6, 12, 3, 1, 3, 7, 14, 15, 10, 15, 7, 10, 12, 1, 2, 13, 7, 9, 6, 6, 7, 4, 12, 10, 8, 8, 3, 8, 4, 6, 14, 10, 5, 2, 3, 15, 4, 9, 3, 7, 7, 2, 4, 4, 1, 7, 15]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Dictionaries\n",
    "\n",
    "Dictionaries are **associative arrays** mapping **immutable** types (string, numbers, tuples...) to arbitrary objects of any kind (variables, functions, modules...). Intuitively, they can be thought as collections of objects that we can recall by means of a unique key. \n",
    "\n",
    "To visualize a Python dictionary you can think of a telephone book, in which people names are the unique keys that you use to retrieve difference kinds of information (phone numbers, street address, mail address...). The same telephone number, street address or other information can be present in the entries of more people, but a label cannot be associated with more than one entry. \n",
    "\n",
    "In Python, dictionaries are defined by curly brackets `{}`, in which key-value pairs are separated by commas and joint by colons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'black': 'zwart', 'white': 'witte', 'red': 'rod', 'yellow': 'geel'}\n"
     ]
    }
   ],
   "source": [
    "# a English-Dutch dictionary of colors\n",
    "demo_dictionary = {\"black\" : \"zwart\",\n",
    "                  \"white\" : \"witte\",\n",
    "                  \"red\" : \"rod\",\n",
    "                  \"yellow\" : \"geel\"}\n",
    "print(demo_dictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'witte'"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# values can be recalled by their keys\n",
    "demo_dictionary[\"white\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'black': 'zwart', 'white': 'wit', 'red': 'rod', 'yellow': 'geel'}\n"
     ]
    }
   ],
   "source": [
    "# we can change a value assocaited with a key\n",
    "demo_dictionary[\"white\"] = \"wit\"\n",
    "print(demo_dictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'black': 'zwart', 'white': 'wit', 'red': 'rod', 'yellow': 'geel', 'blue': 'blauw'}\n"
     ]
    }
   ],
   "source": [
    "# if the key is missing a new key : value pair is added\n",
    "demo_dictionary[\"blue\"] = \"blauw\"\n",
    "print(demo_dictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'black': 'zwart', 'white': 'wit', 'red': 'rod', 'yellow': 'geel'}\n"
     ]
    }
   ],
   "source": [
    "# key:values can be deleted with the command \"del()\"\n",
    "del(demo_dictionary[\"blue\"])\n",
    "print(demo_dictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check if a dictionary has a given key\n",
    "\"blue\" in demo_dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# count the number of entries in a dictionary\n",
    "len(demo_dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Iterating over a Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['black', 'white', 'red', 'yellow']\n",
      "['black', 'white', 'red', 'yellow']\n"
     ]
    }
   ],
   "source": [
    "# iterate over dictionary keys:\n",
    "print(list(demo_dictionary))\n",
    "print(list(demo_dictionary.keys()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['zwart', 'wit', 'rod', 'geel']\n"
     ]
    }
   ],
   "source": [
    "# iterate over dictionary values:\n",
    "print(list(demo_dictionary.values()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('black', 'zwart'), ('white', 'wit'), ('red', 'rod'), ('yellow', 'geel')]\n"
     ]
    }
   ],
   "source": [
    "# iterate over dictionary key-value pairs:\n",
    "print(list(demo_dictionary.items()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz\n",
    "\n",
    "How many characters the longest Dutch color name in our dictionary has?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "###  (Optional) Type casting\n",
    "\n",
    "Sometimes, we may need to change the type of a variable. \n",
    "\n",
    "For instance, we may want to change a list into a set in order to delete all its repeated elements. A quick way to do so is to transform the list in a set.\n",
    "\n",
    "Other example may involve the `join()` operator and the `print()` functions, that do not accept numbers. Conversion functions can be used to quickly switch numbers to strings.\n",
    "\n",
    "Note that not all types of variables can be switched to other types. In what follows we report some common conversion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.123424235454'"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# from number to string\n",
    "str(3.123424235454)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.12'"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sometimes you want to round the number\n",
    "str(round(3.123424235454, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# from string to integer\n",
    "int(\"3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# from string to floating numer\n",
    "float(\"3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['list', 'new_text', 7, 38, 'another_text', 92, 23, 'text'],)"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# from list to tuple (list cannot be used as dictionary keys, tuples can)\n",
    "tuple([demo_list])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# from list to set\n",
    "set([1,2,3,1,2,3,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['t', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 's', 'e', 'n', 't', 'e', 'n', 'c', 'e']\n"
     ]
    }
   ],
   "source": [
    "# from string to list\n",
    "print(list(\"this is a sentence\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz\n",
    "\n",
    "How many different characters did Jonathan Coe use in the tiles of his books?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "coe_bibliography = [\"The Accidental Woman\", \"A Touch of Love\", \"The Dwarves of Death\", \"What a Carve Up! or The Winshaw Legacy Viking\", \"The House of Sleep\", \"The Rotters' Club\", \"The Closed Circle\", \"The Rain Before It Falls\", \"The Terrible Privacy of Maxwell Sim\", \"Expo 58\", \"Number 11\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python Syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Significant Whitespace\n",
    "\n",
    "Most program languages use characters (e.g. `{...}`) or keyworks (e.g. `begin ... end`) to delimitate blocks of codes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### When writing Python code, you rely on INDENTATION to structure your programs. \n",
    "\n",
    "All programming languages allow you to indent (and you should!), but in Python you **have to.**\n",
    "\n",
    "Otherwise, you'll receive and IndentationError and your code won't work"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### How Indentation Works\n",
    "\n",
    "- All statements with the same distance from the left border belong of the same block of code. \n",
    "\n",
    "\n",
    "- Sub-blocks are more indented, while the block ends at the line less indented.\n",
    "\n",
    "\n",
    "- You should use **4 spaces** per indentation level.\n",
    "\n",
    "\n",
    "- When a statement is too long it's good practice to avoid lines of code longer than 80 characters), it can be split with `\"\\\"`\n",
    "\n",
    "\n",
    "- **Never mix** spaces and tabs in a single source file\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> #### Recommended Reading\n",
    ">\n",
    "> [PEP 8 - Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### The code is way more readable:\n",
    "\n",
    "\n",
    "```python\n",
    "# raw_input() reads from standard input (e.g. keyboard)\n",
    "n_string = raw_input('enter a number, please')\n",
    "\n",
    "if not n_string.isdigit():\n",
    "    print(\"this isn't a number...\")\n",
    "else:\n",
    "    n = int(n_string)\n",
    "    if n == 0:\n",
    "        print(\"zero? why zero?\")\n",
    "    elif n % 2 == 0:\n",
    "        print(\"even\")\n",
    "    else:\n",
    "        print(\"odd\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Conditional Statements\n",
    "\n",
    "A lot of programming has to do with executing a block of code only if a certain condition is verified. \n",
    "\n",
    "In Python, the `if-then-else` construct has the form:\n",
    "\n",
    "```python\n",
    "if condition1:\n",
    "    statements\n",
    "elif condition2:\n",
    "    statements\n",
    "elif condition3:\n",
    "    statements\n",
    "else:\n",
    "    statements\n",
    "```\n",
    "\n",
    "Note that the `elif` and `else` clauses are optional. A conditional statement can contain a single `if` block, and nothing else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "even\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "n = random.randrange(0,99)  # random number between 0 and 99\n",
    "if n == 0:\n",
    "    print(\"zero? why zero?\")\n",
    "elif n % 2 == 0:\n",
    "    print(\"even\")\n",
    "else:\n",
    "    print(\"odd\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Flow control\n",
    "\n",
    "### For Loops\n",
    "\n",
    "Programming is of little use if we cannot repeat an instruction for an intended number of times. \n",
    "\n",
    "The `for` statement allows us to define **iterations** (i.e.taking items from an iterable) by following this template:\n",
    "\n",
    "```python\n",
    "for variable in sequence:\n",
    "\tstatement\n",
    "else:\n",
    "\tstatement\n",
    "```\n",
    "\n",
    "The code in the optional `else` clause is executed if and only if the loop terminates successfully (i.e. without a **`break`**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list\n",
      "new_text\n",
      "7\n",
      "38\n",
      "another_text\n",
      "92\n",
      "23\n",
      "text\n"
     ]
    }
   ],
   "source": [
    "# let's iterate over our demo_list\n",
    "for el in demo_list:\n",
    "    print(el)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### The enumerate function\n",
    "\n",
    "The `enumerate()` is problably the most used among the functions that supports the iteration of an iterable. This funtion return the current item plus **its index** in the iteration process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 --> list\n",
      "1 --> new_text\n",
      "2 --> 7\n",
      "3 --> 38\n",
      "4 --> another_text\n",
      "5 --> 92\n",
      "6 --> 23\n",
      "7 --> text\n"
     ]
    }
   ],
   "source": [
    "# use enumerate in the iteration over our demo_list\n",
    "for i, el in enumerate(demo_list):\n",
    "    print (i, \"-->\", el)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### The range construct\n",
    "\n",
    "The  `range()` construct can be used to control the iteration. It generate lists of numbers on the basis of the following three arguments:\n",
    "\n",
    "- `start` : the first integer of the list\n",
    "(default is 0)\n",
    "- `stop` : one larger the last integer of the list (list stop at n - 1)\n",
    "- `step`: the increment of the list (default is 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 10)\n",
      "range(0, 10)\n",
      "range(1, 10, 2)\n"
     ]
    }
   ],
   "source": [
    "# let's play with range\n",
    "print(range(0,10))\n",
    "print(range(10))\n",
    "print(range(1,10,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# let's use range in a for loop\n",
    "for el in range(1, 10, 2):\n",
    "    print(el)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### (Optional) While Loops\n",
    "\n",
    "The `while` statement allows us to control a loop on the basis of a condition. \n",
    "\n",
    "A `while` loop runs as long as a condition is verified. \n",
    "\n",
    "It has the following general form:\n",
    "\n",
    "```python\n",
    "while condition:\n",
    "\tstatement\n",
    "else:\n",
    "\tstatement\n",
    "```\n",
    "\n",
    "the code in the optional `else` clause is execute if and only if the loops terminates successfully (i.e., without a **`break`**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "76\n"
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "while n % 2 != 0:\n",
    "    n = random.randrange(0,99)\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### (Optional) Break and Continue\n",
    "\n",
    "`break` and `continue` are two statements that allow for a more flexible control of a loop. Intuitively:\n",
    "\n",
    "- `continue` is used to pass to the next iteration of the loop\n",
    "- `break` is used to interrupt the loop abruptly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# when we encounter 7 we skip to the next step\n",
    "for el in range(1, 10, 2):\n",
    "    if el == 7:\n",
    "        continue\n",
    "    print(el)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# when we encounter 7 we stop our loop \n",
    "for el in range(1, 10, 2):\n",
    "    if el == 7:\n",
    "        break\n",
    "    print(el)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`break` influence the execution of the loop in yet another way: when a loop terminates due to a `break` statement, the code embedded in the option `else` clause is skipped."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "(let's ignore the 7)\n",
      "9\n",
      ">>> the iteration ended with the number 9\n"
     ]
    }
   ],
   "source": [
    "# the continue statement does not influence the execution of the else block\n",
    "for el in range(1, 10, 2):\n",
    "    if el == 7:\n",
    "        print (\"(let's ignore the \" + str(el) + \")\")\n",
    "        continue\n",
    "    print(el)\n",
    "else:\n",
    "    print (\">>> the iteration ended with the number \" + str(el))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "(we encountered the number 7, let's break the loop)\n"
     ]
    }
   ],
   "source": [
    "# what if we replace continue with break\n",
    "for el in range(1, 10, 2):\n",
    "    if el == 7:\n",
    "        print (\"(we encountered the number \" + str(el) + \", let's break the loop)\")\n",
    "        break\n",
    "    print(el)\n",
    "else:\n",
    "    print (\">>> the iteration ended with the number \" + str(el))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### (Optional) The Pass Statement\n",
    "\n",
    "Given the importance of indentation for Python, sometimes we may need a placeholder that allows us to write down a condition for an `if-then-else` construct or for a `while` loop without writing any statement (maybe just a comment). This is the case in which the `pass` statement comes in handy. \n",
    "\n",
    "In what follows, **nothing happens**:\n",
    "\n",
    "```python\n",
    "if condition1:\n",
    "    pass\n",
    "else:\n",
    "    pass\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### (Optional) List Comprehensions\n",
    "\n",
    "A list comprehension is a syntactic construct that allows us to create lists by applying a function on another list, in just **one line** of code. \n",
    "\n",
    "Even if the reverse isn't always true, list comprehensions can always be (inefficiently) expressed as loops. We will exploit this family resemblance for introducing this construct."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In what follows, we start with a list of numbers and we want to square all of its elements and save our final values in a new list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# our source list\n",
    "source_list = [1,2,3,4,5,6,7,8,9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "# we can solve this problem with a for loop...\n",
    "final_list = []\n",
    "for el in source_list:\n",
    "    final_list.append(el ** 2)\n",
    "print(final_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "# ... or by using list comprehension\n",
    "final_list = [el ** 2 for el in source_list]\n",
    "print(final_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Conditional statements may be implemented**\n",
    "\n",
    "In what follows we want to ignore all the odd numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "# we can solve this problem with a for loop...\n",
    "final_list = []\n",
    "for el in source_list:\n",
    "    if el % 2 == 0:\n",
    "        final_list.append(el ** 2)\n",
    "print(final_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "# ... or by using list comprehension\n",
    "final_list = [el ** 2 for el in source_list if el % 2 == 0]\n",
    "print(final_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**If you want to implement an else clause the syntax changes slightly**\n",
    "\n",
    "In what follows we want to leave the odd numbers unchanged"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 3, 16, 5, 36, 7, 64, 9]\n"
     ]
    }
   ],
   "source": [
    "# we can solve this problem with a for loop...\n",
    "final_list = []\n",
    "for el in source_list:\n",
    "    if el % 2 == 0:\n",
    "        final_list.append(el ** 2)\n",
    "    else:\n",
    "        final_list.append(el)\n",
    "print(final_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 3, 16, 5, 36, 7, 64, 9]\n"
     ]
    }
   ],
   "source": [
    "# ... or by using list comprehension\n",
    "final_list = [el ** 2 if el % 2 == 0 else el for el in source_list]\n",
    "print(final_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz\n",
    "\n",
    "The list `random_numbers` contains 20 randomly generated integers. \n",
    "\n",
    "Create a new list containing only the positive numbers from the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "random_numbers = [81, -36, 15, -96, 14, 51, 70, 40, -15, -64, -25, 82, -88, 7, -13, -30, 12, 32, 96, -55]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Here's something you might find useful:**\n",
    "\n",
    "[Python Cheat Sheet](https://www.cheatography.com/davechild/cheat-sheets/python/)\n",
    "\n",
    "Collects much of the syntax we used today."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Exercise 1.\n",
    "\n",
    "The code in the next cell creates a variable called `zen_text`, and assigns it a nicely formatted version of the textual elements of the Zen of Python.\n",
    "\n",
    "**Count the number of non-empty lines** of this manifesto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import this\n",
    "zen_text = ''.join(this.d.get(el, el) for el in this.s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"The Zen of Python, by Tim Peters\\n\\nBeautiful is better than ugly.\\nExplicit is better than implicit.\\nSimple is better than complex.\\nComplex is better than complicated.\\nFlat is better than nested.\\nSparse is better than dense.\\nReadability counts.\\nSpecial cases aren't special enough to break the rules.\\nAlthough practicality beats purity.\\nErrors should never pass silently.\\nUnless explicitly silenced.\\nIn the face of ambiguity, refuse the temptation to guess.\\nThere should be one-- and preferably only one --obvious way to do it.\\nAlthough that way may not be obvious at first unless you're Dutch.\\nNow is better than never.\\nAlthough never is often better than *right* now.\\nIf the implementation is hard to explain, it's a bad idea.\\nIf the implementation is easy to explain, it may be a good idea.\\nNamespaces are one honking great idea -- let's do more of those!\""
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zen_text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "?zen_text.split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of non-empty lines: 20\n"
     ]
    }
   ],
   "source": [
    "# your code here\n",
    "\n",
    "n_non_empty = 0\n",
    "for line in zen_text.split('\\n'):\n",
    "    line_len = len(line)\n",
    "    if line_len > 0:\n",
    "        n_non_empty += 1\n",
    "print(\"Number of non-empty lines:\",n_non_empty)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Exercise 2.\n",
    "\n",
    "The dictionary in the following cell reports, for each Scrubs character, a nested dictionary containing the name of the actor, the age of the character and its credentials.\n",
    "\n",
    "Write code to answer the following questions:\n",
    "\n",
    "- what are the **names of the actors** of the cast?\n",
    "\n",
    "\n",
    "- what is the **average age** of the characters?\n",
    "\n",
    "\n",
    "- how **many M.D.s** are there in the main cast?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "scrubs_main = {'Bob Kelso': {'actor': 'Ken Jenkins', 'age': 70, 'credentials': 'M.D.'},\n",
    "               'Carla Espinosa-Turk': {'actor': 'Judy Reyes', 'age': 36, 'credentials': 'RN'},\n",
    "               'Christopher Turk': {'actor': 'Donald Faison', 'age': 31, 'credentials': 'M.D.'},\n",
    "               'Elliot Reid': {'actor': 'Sarah Chalke', 'age': 29, 'credentials': 'M.D.'},\n",
    "               'J.D.': {'actor': 'Zach Braff', 'age': 31, 'credentials': 'M.D.'},\n",
    "               'Janitor': {'actor': 'Neil Flynn', 'age': 40, 'credentials': None},\n",
    "               'Perry Cox': {'actor': 'John C. McGinley', 'age': 45, 'credentials': 'M.D.'}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}