00 - Tutorial 1b - Python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>html, body{overflow-y: visible !important} .CodeMirror{min-width:105% !important;} .rise-enabled .CodeMirror, .rise-enabled .output_subarea{font-size:140%; line-height:1.2; overflow: visible;} .output_subarea pre{width:110%}</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import HTML\n",
    "HTML('''<style>html, body{overflow-y: visible !important} .CodeMirror{min-width:105% !important;} .rise-enabled .CodeMirror, .rise-enabled .output_subarea{font-size:140%; line-height:1.2; overflow: visible;} .output_subarea pre{width:110%}</style>''') # For slides"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python for data analysis\n",
    "For those who are new to using Python for scientific work, we first provide a short introduction to Python and the most useful packages for data analysis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python\n",
    "Disclaimer: We can only cover some of the basics here. If you are completely new to Python, we recommend to take an introductory online course, such as the [Definite Guide to Python](https://www.programiz.com/python-programming), or the [Whirlwind Tour of Python](https://github.com/jakevdp/WhirlwindTourOfPython). If you like a step-by-step approach, try the [DataCamp Intro to Python for Data Science](https://www.datacamp.com/courses/intro-to-python-for-data-science).\n",
    "\n",
    "To practice your skills, try the [Hackerrank challenges](https://www.hackerrank.com/domains/python)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Hello world\n",
    "* Printing is done with the print() function. \n",
    "* Everything after # is considered a comment. \n",
    "* You don't need to end commands with ';'.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world\n",
      "0.625\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.625"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is a comment\n",
    "print(\"Hello world\")\n",
    "print(5 / 8)\n",
    "5/8 # This only prints in IPython notebooks and shells."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Note: In these notebooks we'll use Python interactively to avoid having to type print() every time._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Basic data types\n",
    "Python has all the [basic data types and operations](https://docs.python.org/3/library/stdtypes.htm): int, float, str, bool, None.  \n",
    "Variables are __dynamically typed__: you need to give them a value upon creation, and they will have the data type of that value. If you redeclare the same variable, if will have the data type of the new value.  \n",
    "You can use type() to get a variable's type. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 5\n",
    "type(s)\n",
    "s > 3 # Booleans: True or False\n",
    "s = \"The answer is \"\n",
    "type(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python is also __strongly typed__: it won't implicitly change a data type, but throw a TypeError instead. You will have to convert data types explictly, e.g. using str() or int().  \n",
    "Exception: Arithmetic operations will convert to the _most general_ type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'The answer is 42'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.0 + 2     # float + int -> float\n",
    "s + str(42) # string + string\n",
    "# s + 42    # Bad: string + int"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Complex types\n",
    "The main complex data types are lists, tuples, sets, and dictionaries (dicts)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5, 6)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "{'foo': 'c', 2: 'a', 3: 'b', 'bar': 'd'}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [1,2,3,4,5,6]       # list\n",
    "t = (1,2,3,4,5,6)       # tuple: like a list, but immutable\n",
    "s = set((1,2,3,4,5,6))  # set: unordered, you need to use add() to add new elements \n",
    "d = {2: \"a\",            # dict: has key - value pairs\n",
    "     3: \"b\",\n",
    "     \"foo\": \"c\",\n",
    "     \"bar\": \"d\"}\n",
    "\n",
    "l  # Note how each of these is printed\n",
    "t\n",
    "s \n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "You can use indices to return a value (except for sets, they are unordered)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5, 6)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "{'foo': 'c', 2: 'a', 3: 'b', 'bar': 'd'}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'c'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l\n",
    "l[2]\n",
    "t\n",
    "t[2]\n",
    "d\n",
    "d[2]\n",
    "d[\"foo\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "You can assign new values to elements, except for tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 7, 4, 5, 6]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-42-4c3f030f5ef8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0ml\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m7\u001b[0m \u001b[0;31m# Lists are mutable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0ml\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m7\u001b[0m \u001b[0;31m# Tuples are not\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "l\n",
    "l[2] = 7 # Lists are mutable\n",
    "l\n",
    "t[2] = 7 # Tuples are not"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python allows convenient tuple packing / unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bob'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'CS'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = (\"Bob\", 19, \"CS\")      # tuple packing\n",
    "(name, age, studies) = b   # tuple unpacking\n",
    "name\n",
    "age\n",
    "studies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Strings\n",
    "Strings are [quite powerful](https://www.tutorialspoint.com/python/python_strings.htm).  \n",
    "They can be used as lists, e.g. retrieve a character by index.  \n",
    "They can be formatted with the format operator (%), e.g. %s for strings, %d for decimal integers, %f for floats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The answer is 42'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'T'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'answer'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'3.14'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"The %s is %d\" % ('answer', 42)\n",
    "s\n",
    "s[0]\n",
    "s[4:10]\n",
    "'%.2f' % (3.14159265) # defines number of decimal places in a float"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "They also have a format() function for [more complex formatting](https://pyformat.info/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'[1, 2, 3, 4, 5, 6]'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'[1, 2, 3, 4, 5, 6]'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'Hodor Hodor!'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [1,2,3,4,5,6]\n",
    "\"{}\".format(l) \n",
    "\"%s\" % l       # This is identical\n",
    "\"{first} {last}\".format(**{'first': 'Hodor', \n",
    "                           'last': 'Hodor!'})  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### For loops, If statements\n",
    "For-loops and if-then-else statements are written like this.  \n",
    "Indentation defines the scope, not brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "foo : c\n",
      "bar : d\n",
      "Short list\n"
     ]
    }
   ],
   "source": [
    "l = [1,2,3]\n",
    "d = {\"foo\": \"c\", \"bar\": \"d\"}\n",
    "\n",
    "for i in l:\n",
    "    print(i)\n",
    "    \n",
    "for k, v in d.items(): # Note how key-value pairs are extracted\n",
    "    print(\"%s : %s\" % (k,v))\n",
    "    \n",
    "if len(l) > 3:\n",
    "    print('Long list')\n",
    "else:\n",
    "    print('Short list')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Functions\n",
    "Functions are defined and called like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def myfunc(a, b):\n",
    "    return a + b\n",
    "\n",
    "myfunc(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Function arguments (parameters) can be:\n",
    "* variable-length (indicated with \\*)\n",
    "* a dictionary of keyword arguments (indicated with \\*\\*). \n",
    "* given a default value, in which case they are not required (but have to come last)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "func argv: (2, 3)\n",
      "func kwarg: {'a': 4, 'b': 5}\n",
      "9\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "def func(*argv, **kwarg):\n",
    "    print(\"func argv: %s\" % str(argv))\n",
    "    print(\"func kwarg: %s\" % str(kwarg))\n",
    "    \n",
    "func(2, 3, a=4, b=5)\n",
    "\n",
    "def func(a=2):\n",
    "    print(a * a)\n",
    "\n",
    "func(3)\n",
    "func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Functions can have any number of outputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 9)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "def func(*argv):\n",
    "    return sum(argv[0:2]), sum(argv[2:4])\n",
    "\n",
    "sum1, sum2 = func(2, 3, 4, 5)\n",
    "sum1, sum2\n",
    "\n",
    "def squares(limit):\n",
    "    r = 0\n",
    "    ret = []\n",
    "    \n",
    "    while r < limit:\n",
    "        ret.append(r**2)\n",
    "        r += 1\n",
    "    \n",
    "    return ret\n",
    "\n",
    "for i in squares(4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Functions can be passed as arguments to other functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello John'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def greet(name):\n",
    "    return \"Hello \" + name \n",
    "\n",
    "def call_func(func):\n",
    "    other_name = \"John\"\n",
    "    return func(other_name)  \n",
    "\n",
    "call_func(greet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Functions can return other functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello there!'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compose_greet_func():\n",
    "    def get_message():\n",
    "        return \"Hello there!\"\n",
    "\n",
    "    return get_message\n",
    "\n",
    "greet = compose_greet_func()\n",
    "greet()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Classes\n",
    "Classes are defined like this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The new answer is '"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'The new answer is 42'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class TestClass(object): # TestClass inherits from object.\n",
    "    myvar = \"\"\n",
    "     \n",
    "    def __init__(self, myString): # optional constructor, returns nothing\n",
    "        self.myvar = myString # 'self' is used to store instance properties\n",
    "    \n",
    "    def say(self, what): # you need to add self as the first argument \n",
    "        return self.myvar + str(what)\n",
    "\n",
    "a = TestClass(\"The new answer is \")\n",
    "a.myvar # You can retrieve all properties of self\n",
    "a.say(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Static functions need the @staticmethod decorator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The new answer is 42'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'The answer is 42'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class TestClass(object):\n",
    "    myvar = \"\"\n",
    "    \n",
    "    def __init__(self, myString): \n",
    "        self.myvar = myString\n",
    "    \n",
    "    def say(self, what): # you need to add self as the first argument \n",
    "        return self.myvar + str(what)\n",
    "    \n",
    "    @staticmethod\n",
    "    def sayStatic(what): # or declare the function static \n",
    "        return \"The answer is \" + str(what)\n",
    "\n",
    "a = TestClass(\"The new answer is \")\n",
    "a.say(42)\n",
    "a.sayStatic(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Functional Python\n",
    "You can write complex procedures in a few elegant lines of code using [built-in functions](https://docs.python.org/2/library/functions.html#map) and libraries such as functools, itertools, operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x11cb60e10>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[0, 0, 3, 4]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def square(num):\n",
    "    return num ** 2\n",
    "\n",
    "# map(function, iterable) applies a given function to every element of a list\n",
    "list(map(square, [1,2,3,4]))\n",
    "\n",
    "# a lambda function is an anonymous function created on the fly\n",
    "list(map(lambda x: x**2, [1,2,3,4])) \n",
    "list(map(lambda x: x if x>2 else 0, [1,2,3,4])) \n",
    "\n",
    "# reduce(function, iterable ) applies a function with two arguments cumulatively to every element of a list\n",
    "from functools import reduce\n",
    "reduce(lambda x,y: x+y, [1,2,3,4]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[(1, 5), (2, 6), (3, 7), (4, 8)]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# filter(function, iterable)) extracts every element for which the function returns true\n",
    "list(filter(lambda x: x>2, [1,2,3,4]))\n",
    "\n",
    "# zip([iterable,...]) returns tuples of corresponding elements of multiple lists\n",
    "list(zip([1,2,3,4],[5,6,7,8,9]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "__list comprehensions__ can create lists as follows:  \n",
    "\n",
    "    [statement for var in iterable if condition]  \n",
    "    \n",
    "__generators__ do the same, but are lazy: they don't create the list until it is needed:  \n",
    "\n",
    "    (statement for var in list if condition)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 5 \n",
      "\n",
      "4 5 6 7 8 9 "
     ]
    }
   ],
   "source": [
    "a = [2, 3, 4, 5]\n",
    "\n",
    "lc = [ x for x in a if x >= 4 ] # List comprehension. Square brackets\n",
    "lg = ( x for x in a if x >= 4 ) # Generator. Round brackets\n",
    "\n",
    "a.extend([6,7,8,9])\n",
    "\n",
    "for i in lc:\n",
    "    print(\"%i \" % i, end=\"\") # end tells the print function not to end with a newline\n",
    "print(\"\\n\")\n",
    "for i in lg:\n",
    "    print(\"%i \" % i, end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "__dict comprehensions__ are possible in Python 3:  \n",
    "\n",
    "    {key:value for (key,value) in dict.items() if condition}  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0, 2: 4, 4: 16, 6: 36, 8: 64}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Quick dictionary creation\n",
    "\n",
    "numbers = range(10)\n",
    "{n:n**2 for n in numbers if n%2 == 0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'t1': -34.44444444444444,\n",
       " 't2': -17.77777777777778,\n",
       " 't3': 0.0,\n",
       " 't4': 37.77777777777778}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Powerful alternative to replace lambda functions\n",
    "# Convert Fahrenheit to Celsius\n",
    "fahrenheit = {'t1': -30,'t2': 0,'t3': 32,'t4': 100}\n",
    "{k:(float(5)/9)*(v-32) for (k,v) in fahrenheit.items()}"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}