00 Installation Guide and Python Crash Course/00a Python Self Study.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Machine Learning (ML) Module - Python crash course"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Attribution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* A lot of the material in this course was inspired by the free book [A Whirlwind Tour of Python](https://www.oreilly.com/library/view/a-whirlwind-tour/9781492037859/) by Jake VanderPlas\n",
    "* And some, as usual, from [Wikipedia](https://en.wikipedia.org/wiki/Python_(programming_language)) and [Stackoverflow](https://stackoverflow.com/questions/tagged/python)"
   ]
  },
  {
   "attachments": {
    "book.jpg": {
     "image/jpeg": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![book.jpg](attachment:book.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* An interpreted high-level programming language for general-purpose programming\n",
    "* Conceived in the late 1980s by Guido van Rossum\n",
    "* Simple, beautiful with a wide range of domain-specific libraries\n",
    "* As of February 2019, ranked 3th on the [TIOBE index](https://www.tiobe.com/tiobe-index/)\n",
    "* Python has a design philosophy that emphasizes code readability\n",
    "* Uses significant whitespace, the most obvious difference to other languages. Also probably the least important.\n",
    "* Python is typed *dynamically* (variables may change type) and *strongly* (no unobvious implicit casts)\n",
    "* Python has automatic memory management\n",
    "* Supports multiple programming paradigms, including object-oriented, functional and procedural\n",
    "* Has a large and comprehensive standard library\n",
    "* Users of Python are often referred to as Pythonists, Pythonistas, and Pythoneers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## and..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Python is arguably the most popular programming language for Data Science, with R and Julia being strong contenders"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The ZEN of Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python Syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Simple, iterative Fibonacci sequence\n",
    "\n",
    "# endpoint\n",
    "endpoint = 10\n",
    "\n",
    "# starting numbers\n",
    "a = 1; b = 1\n",
    "\n",
    "for i in range(endpoint-1):\n",
    "    print(a, end=\" \")\n",
    "    a,b = b,a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Comments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* comments are marked by #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Simple, iterative Fibonacci sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* there are no multi-line comments like /* ... */ such as in C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Multi-line Comments\n",
    "* But wait, I have seen multi-line comments using triple quotes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Is this is a \n",
    "multiline\n",
    "comment? \n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Triple quotes are actually **multi-line strings**. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* If they are not assigned to a variable they will be immediately garbage collected as soon as the code executes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* They are not ignored by the interpreter in the same way as # comment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* You often use this multi-line strings as **docstrings**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Statement termination"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* end-of-line terminates a statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# endpoint\n",
    "endpoint = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* statements can also be separated by a semicolon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# starting numbers\n",
    "a = 1; b = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* but this is not often used"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Code blocks and indentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Code blocks are indented by whitespace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for i in range(endpoint-1):\n",
    "    print(a, end=\" \")\n",
    "    a,b = b,a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* tabs and spaces are not the same, don't mix them\n",
    "* best to set your editor to indent with 4 spaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Simple, iterative Fibonacci sequence\n",
    "\n",
    "# endpoint\n",
    "endpoint = 10\n",
    "\n",
    "# starting numbers\n",
    "a,b = 1,1\n",
    "\n",
    "for i in range(endpoint-1):\n",
    "    print(a, end=\" \")\n",
    "    a,b = b,a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Getting Help"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* To get help on an object, you can use the internal help"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* When using iPython, you can also append a ? to the object you want help about"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* This will open a separate window with the help information"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python Semantics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Variables and Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Variables are references, not containers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = [1,2,3,4]\n",
    "b = a\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "b.append(5)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* The assignment operator does just that, assign a refererence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* So:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "b = 'something else'\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* And there is no type-safety (and no declaration needed)\n",
    "* But above is only true for mutable values\n",
    "* Simple types such as numbers are immutable\n",
    "* So the following works as expected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = x\n",
    "y += 1\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Everything in Python is an object\n",
    "* So everything has a type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = \"Hello\"\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "type(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* But the variable names are still references, the type information is contained in the object\n",
    "* even simple types have attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 42.0\n",
    "x.is_integer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Simple types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "| Scalar Type | Example        | Description                                                     |\n",
    "|-------------|----------------|-----------------------------------------------------------------|\n",
    "| ``int``     | ``x = 1``      | integers (i.e., whole numbers)                                  |\n",
    "| ``float``   | ``x = 1.0``    | floating-point numbers (i.e., real numbers)                     |\n",
    "| ``complex`` | ``x = 1 + 2j`` | Complex numbers (i.e., numbers with real and imaginary part)    |\n",
    "| ``bool``    | ``x = True``   | Boolean: True/False values                                      |\n",
    "| ``str``     | ``x = 'abc'``  | String: characters or text, either with single or double quotes |\n",
    "| ``NoneType``| ``x = None``   | Special object indicating nulls                                 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Built-in Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "There are four built-in compound data structures that act as containers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list = [0,1,2,3,4] # mutable, ordered collection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_tuple = (0,1,2,3,4) # immutable, ordered collection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_dictionary = {'a':0, 'b':1, 'c':2} # unordered key/value mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_set = {0,1,2,3,3,4,4,4} # Unordered collection of unique values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Lists are the workhorse datatype of Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* They are called lists, not arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "len(a_list) # they have a length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list.append('a') # and many many userful attributes and functions\n",
    "a_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### List indexing and slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list[0] # zero-based indexing for accessing elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list[-1] # access from the end of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list[2:4] # slice a list, 1st index is included, 2nd excluded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list[:2] # omitting the initial 0 or the end index (or both) is possible"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list[::2] # a third optional index indicated stepsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list[::-1] # reverse a list with a negative stepsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list[2:4] = [9,8] # indexing and slicing can be used on the left-hand-side too\n",
    "a_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# tuples behave like lists except that they are immutable\n",
    "a_tuple[0] = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# convert between the two with list() and tuple()\n",
    "another_list = list(a_tuple)\n",
    "another_list[0] = 6\n",
    "tuple(another_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_dict = {'a': 1, 2: 27, 'large_num':2**64}\n",
    "a_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_dict['large_num']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_dict.keys(), a_dict.values(), a_dict.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Please note that due to efficiency reasons, dictionaries are unordered "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_set = {1,2,3,3,4,4,4,4}\n",
    "a_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Sets have no duplicates and are unordered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "another_set = {2,3,5,6}\n",
    "a_set & another_set # or: a_set.intersection(another_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* set operations: union `|`, difference `-`, symmmetric difference `^` and more"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### if elif else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = 10\n",
    "\n",
    "if a == 10:\n",
    "    print(\"ten\")\n",
    "elif x > 0:\n",
    "    print(\"positive\")\n",
    "elif x < 0:\n",
    "    print(\"negative\")\n",
    "else:\n",
    "    print(\"must be something else then...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### for loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# for value in iterable\n",
    "for elem in ['foo', 'bar', 'baz']:\n",
    "    print(elem, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* There is no need for a counter, we iterate over a so-called sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### while loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "condition = True\n",
    "while condition:\n",
    "    print(\"it's true only once\")\n",
    "    condition = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### break and continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* break leaves the innermost loop\n",
    "* continue moves to the next iteration of the current loop\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Ternary expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# expr if cond else expr\n",
    "a = 1\n",
    "b = 2\n",
    "\"True\" if a>b else \"False\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def simple_fib(length=10):\n",
    "    result = []\n",
    "    \n",
    "    # starting numbers\n",
    "    a = 1; b = 1\n",
    "\n",
    "    while len(result) < length:\n",
    "        result.append(a)\n",
    "        a,b = b,a+b\n",
    "    return result\n",
    "\n",
    "simple_fib(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* functions can have defaults for arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def simple_fib(length=10):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* every function returns a value, either the one given in the return statement or *None*\n",
    "* Arguments and return values can be any Python object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def real_and_imag(a_complex_num):\n",
    "    return a_complex_num.real, a_complex_num.imag\n",
    "\n",
    "r, i = real_and_imag(3 + 4j)\n",
    "r, i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Function calls can have positional arguments and/or keyword arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def real_and_imag(a_complex_num, nothing):\n",
    "    return a_complex_num.real, a_complex_num.imag\n",
    "\n",
    "real_and_imag(3, None) # order matters\n",
    "real_and_imag(nothing=None, a_complex_num=3) # order does not matter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* When mixing, positional arguments must come before keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(1, 2, 3, sep='--')\n",
    "#print(1, sep='--', 2 , 3) # throws an error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* An arbitrary number of arguments is supported with `*args` and `**kwargs`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def catch_all(*args, **kwargs):\n",
    "    print(\"positional args =\", args)\n",
    "    print(\"keyword wargs = \", kwargs)\n",
    "catch_all(1, 2, 3, a=4, b=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* The names args and kwargs are just a convention, important are the `*` and `**`\n",
    "* A `*` before a parameter means \"unpack this as a sequence\", while a double `**` before a parameter means \"unpack this as a dictionary\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "inputs = (1, 2, 3)\n",
    "keywords = {'pi': 3.14}\n",
    "\n",
    "catch_all(*inputs, **keywords)\n",
    "catch_all(1, 2, 3, pi=3.14) # equal to the previous line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Functions are objects too (everything in Python is an object)\n",
    "* They can be passed around, assigned and have members"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def what_type(f):\n",
    "    print(type(f))\n",
    "what_type(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Lambda functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Anonymous, short-lived functions\n",
    "* Often used with data manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "add = lambda x, y: x + y\n",
    "add(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* In the following example, a lambda function is used to filter a list and only return the even values\n",
    "* filter(func, iterable) takes a function and applies it to each element of an iterable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "even = filter(lambda x: x % 2 == 0,\n",
    "              [1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
    "list(even)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Or sort a list with an alternate key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "sorted([1, 2, 3, 4, 5, 6, 7, 8, 9], key=lambda x: abs(5-x)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Namespaces and Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Functions can access the global scope, and create their own local scope\n",
    "* Functions have their local namespace, which is created and initialized with the parameters when the function is called\n",
    "* Variables assigned within the function are added to this namespace, and destroyed when the function ends\n",
    "* Functions can access variables that were defined in the outer scope by reference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def f():\n",
    "    a.append(4)    \n",
    "\n",
    "a = [1,2,3]\n",
    "f()\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* But using an assignment on that reference does not change it globally"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def f():\n",
    "    a = [4,5,6]\n",
    "    print(\"inside f: \", a)\n",
    "\n",
    "a = [1,2,3]\n",
    "f()\n",
    "print(\"outside f after calling f(): \", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* There are the two keywords `global` and `nonlocal` that change these rules, but we will not look at them in detail"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Iterators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We have seen a for loop  previously:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# for value in iterable\n",
    "for elem in ['foo', 'bar', 'baz']:\n",
    "    print(elem, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* The expression passed for looping over needs to implement the *iterator interface*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "iter(['foo', 'bar', 'baz'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "iter(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "iter(range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "To get the next element of an iterable, the *next()* statement is used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "an_iterable = iter(['foo', 'bar'])\n",
    "next(an_iterable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "next(an_iterable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "next(an_iterable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* When an iterable is depleted, a StopIteration is raised\n",
    "* The for in loop implicitely calls iter() and next() and catches the final StopIteration\n",
    "* Iterators are a central concept in Python\n",
    "* But why are they useful?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "1. Many things can be treated as lists and iterated over (they just need to implement the iterator interface)\n",
    "2. The whole list is never explicitely created, which allows for memory-efficient programming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "N = 10 ** 12 # this would need terabytes of memory if completely instanciated as a list...\n",
    "for i in range(N):\n",
    "    if i >= 10: break # ... which would be a waste sincce we only need the 1st 10 elements\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* If the whole list needs to be generated, wrap the iterable with *list()*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "range(10) # a range iterator, does not print the values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "list(range(10)) # a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Some useful iterators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* range() produces a sequence of integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for i in range(10, 0, -1):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* enumerate(an_iterable)  creates an iterator of 2-tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for i, val in enumerate(['Federer', 'Nadal', 'Djokovic']):\n",
    "    print(i+1, val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Please note the *unpacking* that is happening here. enumerate() generates 2-tuples (1, 'Federer), (2, 'Nadal'), ... which are *unpacked* into the two separate variables i and val."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* zip() can be used to iterate over multiple lists simultaneously and returns an iterator of the sequence (all, first, elements), (all, second, elements), ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "first_names = ['Roger', 'Rafael', 'Novak']\n",
    "last_names =['Federer', 'Nadal', 'Djokovic']\n",
    "for first, last in zip(first_names, last_names): \n",
    "    print(first, last)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* the number of lists can be greater than two"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* If lengths are not equal, the longer ones are truncated"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### List comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Python is famous for its list comprehension construct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "[i**2 for i in range(10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Takes an iterable, does something to every element and returns a list of the results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* The basic syntax is `[expression for variable in iterable]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "There is an extended syntax including a filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "[i for i in range(10) if i%2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `[expression for variable in iterable if condition]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* List comprehensions can of course also be written as a multiline for loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* List comprehensions can also be nested"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "[(i, j) for i in range(2) for j in range(3)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* This is equivalend to a nested for loop with `i` varying in the outer loop and `j` in the inner"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Set comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* With the same syntax but curly braces (not parenthesis!), a set is created and returned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "{-n for n in [1,1,2,3,4,4,4,5]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Note that duplicates are eliminated"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Dict comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* With almost similar syntax (only an additional colon), a dictionary is returned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "{n:n**2 for n in range(6)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Generators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* In the above examples, the list, set ot dict is fully created. These structures are constrained by available memory.\n",
    "* When instanciating a list, for example with a list comprehension, we are building a collection of values.\n",
    "* When instanciating a generator, we are building a *recipe* to create a collection of values\n",
    "* Both expose the same iterator interface, but with a generator, the collection is not precomputed. Elements are generated on demand.\n",
    "* Lists can be used multiple times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = [1,2,3]\n",
    "print(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Generators are single-use (once-used values are gone)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "g = (n for n in range(1, 4))\n",
    "print(list(g))\n",
    "print(list(g))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Generators cannot be sliced (or concatenated or multiplied or ...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list = [1,2,3]\n",
    "a_gen = iter([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_gen[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Building generators with *generator expressions*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "gen = (n**2 for n in [1,2,3])\n",
    "gen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "next(gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "next(gen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Building generators with the *yield* statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* For more complex operations, it is better to use a for loop than to construct an overly complex generator expression (or list comprehension)\n",
    "* We use the *yield* statement to return a value and stop the execution until the next value is requested"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def gen():\n",
    "    for n in [1,2,3]:\n",
    "        yield n ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "g = gen()\n",
    "# 1st use of next():\n",
    "# run the code up to the yield statement, return 1st value and pause\n",
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# continue after the yield statement and execute code\n",
    "# until the next yield statement is encountered\n",
    "next(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Runtime errors throw exceptions of different types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(2/0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "l = [1,2,3]\n",
    "print(l[42])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "1 + 'a'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* try/except block (which catches all types of exceptions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    print(\"Let's try something.\")\n",
    "    #x = 1 / 0 # ZeroDivisionError\n",
    "except:\n",
    "    print(\"Something bad happened!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* It is better to catch only anticipated exceptions and let everything unforseen still raise an error, so we don't mask problems in our code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    print(\"Let's try something.\")\n",
    "    #x = 1 / 0 # ZeroDivisionError\n",
    "except ZeroDivisionError:\n",
    "    print(\"Something bad happened!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Access error message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    x = 1 / 0\n",
    "except ZeroDivisionError as err:\n",
    "    print(\"Error class is:  \", type(err))\n",
    "    print(\"Error message is:\", err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Catch multiple exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    pass # do something that may fail\n",
    "except SomeException:\n",
    "    pass # do something for this kind of exception\n",
    "except AnotherException:\n",
    "    pass # do something else for another kind of exception"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "except (SomeException, AnotherException) as e: # parenthesis are mandatory, 'as e' is optional\n",
    "    pass # do the same thing for all exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Raise or re-raise an exception"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "raise RuntimeError(\"my error message\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Complete block "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    print(\"try something here (always executed)\")\n",
    "except:\n",
    "    print(\"this happens only if it fails\")\n",
    "else:\n",
    "    print(\"this happens only if it succeeds\")\n",
    "finally:\n",
    "    print(\"this happens no matter what (used for cleanup)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Suppress exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from contextlib import suppress\n",
    "\n",
    "with suppress(DeprecationWarning, FutureWarning):\n",
    "     raise(FutureWarning)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Additional functionality can be used by loading modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import math # Explicit import of whole module\n",
    "math.cos(math.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np # Explicit import by alias\n",
    "np.random.randint(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from os import getuid, getgid # Explicit import of module parts\n",
    "getuid(), getgid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from pathlib import *  # Implicit import of module, use with care\n",
    "data = Path(\"data\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Sometimes, you see a statement like this at the end of a Python script"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    # script was executed standalone\n",
    "    call_main_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* This is used to make a standalone executable script which is also importable as a module\n",
    "* The code is executed only when being called standalone, and not when imported as a module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Pitfalls in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Although Python tries to follow the [Principle of least astonishment](https://en.wikipedia.org/wiki/Principle_of_least_astonishment), there are some pitfalls one must be aware of\n",
    "* Let's discuss them, in (my subjective) order of importance\n",
    "* Don't mix spaces and tabs\n",
    "* Know what version of Python you use, Python 2 and 3 are different in some important points\n",
    "* Mutable default argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def foo(a=[]):\n",
    "    a.append(5)\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "foo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* What?!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Functions in Python are first-class objects\n",
    "* They are evaluated at definition time\n",
    "* Default parameters are kind of *member data* and so their state may change from one call to the other"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "What to do instead?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Never use mutable default arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def foo(a=None):\n",
    "    if a is None:\n",
    "        a = []\n",
    "    a.append(5)\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "foo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Assignment is by reference, not by copy. Only immutable objects are actually copied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = [1,2,3,4]\n",
    "b = a\n",
    "b.append(5)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Proper check for None:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# correct (compares object's identity)\n",
    "if a is not None:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# wrong (same as a == True, compares object's equality)\n",
    "if a:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# from https://stackoverflow.com/a/14247383/2315949\n",
    "class Negator(object):\n",
    "    def __eq__(self,other):\n",
    "        return not other\n",
    "thing = Negator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "thing == None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "thing is None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Be careful when using \"==\" to check against True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "if (var == True):  # this will execute if var is True or 1, 1.0, 1L\n",
    "    \n",
    "if (var != True):  # this will execute if var is neither True nor 1\n",
    "    \n",
    "if (var == False): # this will execute if var is False or 0 (or 0.0, 0L, 0j)\n",
    "    \n",
    "if (var == None):  # only execute if var is None\n",
    "    \n",
    "if var:            # execute if var is a non-empty string/list/dictionary/tuple, non-0, etc\n",
    "    \n",
    "if not var:        # execute if var is \"\", {}, [], (), 0, None, etc.\n",
    "    \n",
    "if var is True:    # only execute if var is boolean True, not 1\n",
    "    \n",
    "if var is False:   # only execute if var is boolean False, not 0\n",
    "    \n",
    "if var is None:    # same as var == None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Dicts are unordered, even if they often come along in the order they were filled.\n",
    "* Use *OrderedDict* from the *collections* module if you actually need an ordered dict\n",
    "* Sets are initialised with `set(iterable)`, whereas `{}` initialises a dict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "set([1,2,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* `list.sort()` sorts inplace, `sorted()` returns a list\n",
    "* ++n and --n not work as people with C or Java background would expect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "n = 1\n",
    "++n # positive of a positive number, which is simply n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "--n # negative of a negative number, which is simply n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Multiprocessing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* The GIL (Global Interpreter Lock) is responsible for the fact that only one thread in a Python program can be running at any one time\n",
    "* But when running Python code, you don't get parallel execution most of the time. In other words, threads in Python are not like threads in Java or C++.\n",
    "* There are many instances in which things do run in parallel, like when using libraries that are essentially C extensions (numpy for example)\n",
    "* Use the *multiprocessing* module if you want to parallelize your own code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Pythonic code (just a few examples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Don't\n",
    "l = ['a','b','c']\n",
    "for i in range(len(l)):\n",
    "    print(l[i], end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Do this instead:\n",
    "for elem in l:\n",
    "    print(elem, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Or if you do need the counter:\n",
    "for i, elem in enumerate(l):\n",
    "    print(\"{}:{} \".format(i, elem), end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "*It's easier to ask for forgiveness than permission* (EAFP) instead of *Look before you leap* (LBYL) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# from https://stackoverflow.com/a/11360880/2315949\n",
    "\n",
    "# Don't (LBYL):\n",
    "if 'key' in my_dict:\n",
    "    x = my_dict['key']\n",
    "else:\n",
    "    # handle missing key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Do this instead (EAFP):\n",
    "try:\n",
    "    x = my_dict['key']\n",
    "except KeyError:\n",
    "    # handle missing key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Duck typing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Don't check if it is a duck, it's enough if it walks like a duck and quacks like a duck"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Don't\n",
    "def foo(name):\n",
    "    if isinstance(name, str):\n",
    "        print(name.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Do this instead. It is enough if the object has a string representation (many objects do)\n",
    "def foo(name) :\n",
    "    print(str(name).lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Don't\n",
    "def bar(listing):\n",
    "    if isinstance(listing, list):\n",
    "        listing.extend((1, 2, 3))\n",
    "        return \", \".join(listing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Do this instead. It is enough if the object implements the sequence protocol (many objects do)\n",
    "def bar(listing):\n",
    "    l = list(listing)\n",
    "    l.extend((1, 2, 3))\n",
    "    return \", \".join(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Don't write long and unreadable one-liners just because you can"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "l = [m for a, b in zip(['a', 'b', 'c'], [1,2,3]) if b.method(a) != b for m in b if not m.method(a, b) and reduce(lambda x, y: a + y.method(), (m, a, b))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Python with its handy list comprehensions is somewhat more prone to this than other languages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "And again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "And also"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "[PEP 8 -- Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/)\n",
    "\n",
    "(PEP stands for Python Enhancement Proposals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Some things left out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* [Object-oriented programming](https://www.programiz.com/python-programming/object-oriented-programming)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* [@Properties](https://www.programiz.com/python-programming/property)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* [Decorators](https://www.programiz.com/python-programming/decorator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* [Closures](https://www.programiz.com/python-programming/closure)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* [Shallow and deep copying](https://www.programiz.com/python-programming/shallow-deep-copy)"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "text_representation": {
    "extension": ".py",
    "format_name": "percent",
    "format_version": "1.2",
    "jupytext_version": "0.8.6"
   }
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}