00 Tutorial 1a - Python.ipynb

{
 "cells": [
  {
   "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": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "hide_input": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from preamble import * # Global imports and settings\n",
    "HTML('''<style>.CodeMirror{min-width:100% !important;}</style>''') # For slides\n",
    "InteractiveShell.ast_node_interactivity = \"all\""
   ]
  },
  {
   "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 [DataCamp Intro to Python for Data Science](https://www.datacamp.com/courses/intro-to-python-for-data-science).  \n",
    "\n",
    "Another good resource is the [Whirlwind Tour of Python](https://github.com/jakevdp/WhirlwindTourOfPython)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Hello world\n",
    "* Printing is doen 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": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world\n",
      "0.625\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.625"
      ]
     },
     "execution_count": 2,
     "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": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 3,
     "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": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 's' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-ad0ba00fa399>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;36m1.0\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m2\u001b[0m     \u001b[0;31m# float + int -> float\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0ms\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m42\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# string + string\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;31m# s + 42    # Bad: string + int\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 's' is not defined"
     ]
    }
   ],
   "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": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5, 6)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "{'foo': 'c', 2: 'a', 3: 'b', 'bar': 'd'}"
      ]
     },
     "execution_count": 5,
     "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": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5, 6)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "{'foo': 'c', 2: 'a', 3: 'b', 'bar': 'd'}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'c'"
      ]
     },
     "execution_count": 6,
     "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": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'l' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-4c3f030f5ef8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ml\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\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[1;32m      4\u001b[0m \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[0;31mNameError\u001b[0m: name 'l' is not defined"
     ]
    }
   ],
   "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": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bob'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'CS'"
      ]
     },
     "execution_count": 8,
     "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": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The answer is 42'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'T'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'answer'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'3.14'"
      ]
     },
     "execution_count": 9,
     "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": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'[1, 2, 3, 4, 5, 6]'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'[1, 2, 3, 4, 5, 6]'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'Hodor Hodor!'"
      ]
     },
     "execution_count": 10,
     "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', '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": 11,
   "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": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 12,
     "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": 13,
   "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": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 9)"
      ]
     },
     "execution_count": 14,
     "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": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello John'"
      ]
     },
     "execution_count": 15,
     "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": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello there!'"
      ]
     },
     "execution_count": 16,
     "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": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The new answer is '"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'The new answer is 42'"
      ]
     },
     "execution_count": 17,
     "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": 18,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The new answer is 42'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'The answer is 42'"
      ]
     },
     "execution_count": 18,
     "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": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[0, 0, 3, 4]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 19,
     "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 a is 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": 20,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[(1, 5), (2, 6), (3, 7), (4, 8)]"
      ]
     },
     "execution_count": 20,
     "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": 21,
   "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=\"\")"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Edit Metadata",
  "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
}