2.1 Recap and a few advanced bits.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exception reporting mode: Plain\n",
      "Doctest mode is: ON\n"
     ]
    }
   ],
   "source": [
    "# stuff that are needed to get the output pretty\n",
    "# but not to be included in the slideshow\n",
    "%doctest_mode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Quick overview of python \n",
    "\n",
    "## and some advanced bits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Types in python\n",
    "\n",
    "- types represents the kind of value we are dealing with and determines how the value can be used (i.e. what operations can be applied to the value)\n",
    "- types are similar to part of speech in natural language (e.g. what operations can you apply to a verb?)\n",
    "\n",
    "`type` built-in function gives the type of \"something\"\n",
    "\n",
    "`isinstance` built-in function which tests where \"something\" is of a given type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Built-in types in Python\n",
    "\n",
    "- Numeric Types: int, float, complex\n",
    "- Sequence Types: list, tuple, range\n",
    "- Text Sequence Type: strings\n",
    "- Binary Sequence Types: bytes, bytearray, memoryview\n",
    "- Set Types: set, frozenset\n",
    "- Mapping Types: dictionaries\n",
    "- Other Build-in Types: functions, classes, etc. \n",
    "\n",
    "Very detailed information about built-in types from the official documentation <a href=\"https://docs.python.org/3.6/library/stdtypes.html\" target=\"_blank\">https://docs.python.org/3.6/library/stdtypes.html</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<class 'float'>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1.1\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(x, int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(x, float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# For loops\n",
    "\n",
    "- repeats a block for each element in a sequence\n",
    "\n",
    "```python\n",
    "for variable in sequence:\n",
    "    <block>\n",
    "```\n",
    "\n",
    "- strings are sequences of characters so we can iterate through a string\n",
    "\n",
    "```python\n",
    "word=\"string\"\n",
    "for letter in word:\n",
    "    print(letter)\n",
    "```\n",
    "\n",
    "See how this program runs at <a href=\"https://goo.gl/ojM5ka\" target=\"_blank\">https://goo.gl/ojM5ka</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# while structure\n",
    "\n",
    "- repeats a block as long as a condition is true\n",
    "\n",
    "```python\n",
    "while <condition>:\n",
    "    <block>\n",
    "```\n",
    "\n",
    "- at times a *sentry variable* is used in the condition\n",
    "- the sentry variable needs to be initialised before it is used\n",
    "\n",
    "```python\n",
    "answer = \"\"\n",
    "while answer != \"y\":\n",
    "    answer = input(\"Exit (y/n):\")\n",
    "```\n",
    "\n",
    "Test the code at <a href=\"https://goo.gl/THn9T1\" target=\"_blank\">https://goo.gl/THn9T1</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# for vs while\n",
    "\n",
    "- Use ``for`` when you know how many times you need to execute something\n",
    "- Use ``while`` when you need to execute something a number of times but you do not know apriori\n",
    "\n",
    "- Example: for how long to take a shower?\n",
    "    - for 10 min\n",
    "    - Until clean/while not clean\n",
    "    \n",
    "- It is possible to control the behavious of ``for`` and ``while`` using ``break`` and ``continue``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Lists and tuples\n",
    "\n",
    "- lists are sequences which can be created and modified by the program\n",
    "- tuples are sequences which cannot be modified once created\n",
    "- they are a sequence of anything\n",
    "\n",
    "Strings are also sequences, so many operations for lists and tuples are valid also for strings (but not all of them)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Sequences are immutable and mutable\n",
    "\n",
    "- Immutable: a sequence cannot be changed. E.g. strings and tuples\n",
    "- Immutability shouldn’t be confused with assigning a new value to a variable\n",
    "\n",
    "```python\n",
    "string = \"test\"\n",
    "string[1] = \"a\" # doesn’t work\n",
    "string = \"a new test\" # works fine, new value\n",
    "```\n",
    "\n",
    "- Mutable the values of a sequence can be changed. E.g. lists\n",
    "\n",
    "```python\n",
    "list = [\"a\", 1, \"c\"]\n",
    "list[1] = \"b\" # is fine\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Creating a list\n",
    "\n",
    "The markers of a list are ``[]``\n",
    "\n",
    "```python\n",
    "\n",
    "# create an empty list\n",
    "empty_list = []\n",
    "\n",
    "# create a list of strings\n",
    "summer_months = [\"June\", \"July\", \"August\"]\n",
    "\n",
    "# create a mixed list\n",
    "mixed_list = [\"a string\", 1, 1.2]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# List comprehensions\n",
    "\n",
    "\n",
    "- provide a way to create lists \n",
    "- consists of **an expression** followed by a **for** and then zero or more **for** or **if** clause\n",
    "- ``[func(x) for x in seq ... for y in seq_y ... if cond ...]``\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "# create a list of squares\n",
    "list_squares = [x*x for x in range(5)] \n",
    "print(list_squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "# this is equivalent to\n",
    "list_squares = []\n",
    "for x in range(5):\n",
    "    list_squares.append(x*x)\n",
    "print(list_squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 16]\n"
     ]
    }
   ],
   "source": [
    "# create a list of squares for even numbers\n",
    "list_squares_for_even = [x*x for x in range(5) if x%2 == 0] \n",
    "print(list_squares_for_even)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 16]\n"
     ]
    }
   ],
   "source": [
    "# this is equivalent to\n",
    "list_squares_for_even = []\n",
    "for x in range(5):\n",
    "    if x%2 == 0: list_squares_for_even.append(x*x)\n",
    "print(list_squares_for_even)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0, 0, 1, 2, 0, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "# it is possible to have two variables\n",
    "list_products = [x*y for x in range(3) for y in range(3)]\n",
    "print(list_products)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0, 0, 1, 2, 0, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "# this is equivalent\n",
    "list_products = []\n",
    "for x in range(3):\n",
    "    for y in range(3):\n",
    "        list_products.append(x*y)\n",
    "print(list_products)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Readability counts\n",
    "\n",
    "- python allows breaking expressions in parentheses, square brackets or curly braces can be split over more than one physical line without using backslashes\n",
    "\n",
    "### Before\n",
    "\n",
    "```python\n",
    "list_squares_for_even = [x*x for x in range(5) if x%2 == 0] \n",
    "```\n",
    "\n",
    "### After\n",
    "```python\n",
    "list_squares_for_even = [\n",
    "        x*x \n",
    "        for x in range(5) \n",
    "        if x%2 == 0\n",
    "] \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Careful about the order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start: 2017-08-30 21:21:39.002737\n",
      "End: 2017-08-30 21:21:40.824908\n",
      "c=9\tl=[2, 4, 6, 8, 10, 12, 14, 16, 18, 4, 8, 12, 16, 20, 24, 28, 32, 36, 6, 12, 18, 24, 30, 36, 42]\n",
      "Start: 2017-08-30 21:21:40.826383\n",
      "End: 2017-08-30 21:21:57.113667\n",
      "c=81\tl=[2, 4, 6, 8, 10, 12, 14, 16, 18, 4, 8, 12, 16, 20, 24, 28, 32, 36, 6, 12, 18, 24, 30, 36, 42]\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "import time\n",
    "\n",
    "def counter(i):\n",
    "    global c\n",
    "    c += 1\n",
    "    time.sleep(0.2)\n",
    "    return i%2 == 0\n",
    "\n",
    "c, max = 0, 10\n",
    "print(\"Start: \" + str(datetime.now()))\n",
    "l = [i*j for i in range(1, max) if counter(i) for j in range(1, max)]\n",
    "print(\"End: \" + str(datetime.now()))\n",
    "print(\"c=\", c, \"\\tl=\", l[:25], sep=\"\")\n",
    "\n",
    "c, max = 0, 10\n",
    "print(\"Start: \" + str(datetime.now()))\n",
    "l = [i*j for i in range(1, max) for j in range(1, max) if counter(i)]\n",
    "print(\"End: \" + str(datetime.now()))\n",
    "print(\"c=\", c, \"\\tl=\", l[:25], sep=\"\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Dictionaries\n",
    "\n",
    "- Are data structures which store information in pairs\n",
    "\n",
    "- Work very much like dictionaries: there is a word (referred to as key) and a definition (referred as value)\n",
    "\n",
    "- A (key, value) pair is called entry\n",
    "\n",
    "- Dictionaries are created using ``{}``\n",
    "\n",
    "```python\n",
    "list_of_exceptions = {\"mouse\":\"mice\", \"goose\":\"geese\"} \n",
    "personal_details = {\"name\":\"john\", \"age\":21}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Dictionary comprehension\n",
    "\n",
    "- very similar with list comprehension\n",
    "- ``{k:v for k in .. if ...}``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'> {'0^0': 1, '2^2': 4, '4^4': 256, '6^6': 46656, '8^8': 16777216}\n"
     ]
    }
   ],
   "source": [
    "d = {str(k) + \"^\" + str(k):k**k for k in range(10) if k % 2 == 0}\n",
    "print(type(d), d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Functions\n",
    "\n",
    "**Function** = a device that groups a set of statements so they can be run more than once\n",
    "\n",
    "In python a function is defined using the ``def`` keyword\n",
    "\n",
    "```python\n",
    "def <name_of_function>(<list_of_parameters>):\n",
    "    <block_of_function>\n",
    "```\n",
    "\n",
    "A function is called by using its name and providing the necessary parameters\n",
    "\n",
    "A function can return a value by using ``return <value>`` statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Polymorphism\n",
    "\n",
    "The meaning of an expression can depend on the kind of arguments it takes (e.g. x * y)\n",
    "\n",
    "```python\n",
    "def times(x, y):\n",
    "    return x * y\n",
    "```\n",
    "\n",
    "What valid arguments we can pass to the function and what results we can get?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def intersection(seq1, seq2):\n",
    "    res = []\n",
    "    for x in seq1:\n",
    "        if x in seq2:\n",
    "            res.append(x)\n",
    "            \n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'c']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intersection(\"abcd\", \"ac\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intersection([1, 2, 3, 4], [1, 3, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intersection([1, 2, 3, 5], (1, 3, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '3', '5']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intersection(\"1235\", (\"1\", \"3\", \"5\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '3', '5']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intersection((\"1\", \"3\", \"5\"), \"1235\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Aliasing and side effects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "first = [1,2,3]\n",
    "second = first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 100, 3]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first[1] = 100\n",
    "first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 100, 3]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 100, 3]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "third = first[:]\n",
    "third"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 100, 3]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 200, 3]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first[1] = 200\n",
    "first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 100, 3]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "third"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Function arguments\n",
    "\n",
    "- Immutable arguments are effectively passed “by value”\n",
    "- Mutable arguments are effectively passed “by pointer”\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before calling the function: 1 [1, 2]\n"
     ]
    }
   ],
   "source": [
    "def change(a, b):\n",
    "    a = 2\n",
    "    b[0] = \"x\"\n",
    "\n",
    "x = 1\n",
    "L = [1,2]\n",
    "print(\"Before calling the function:\", x, L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After calling the function: 1 ['x', 2]\n"
     ]
    }
   ],
   "source": [
    "change(x, L)\n",
    "print(\"After calling the function:\", x, L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Mapping\n",
    "\n",
    "- it is possible to apply a function to each element of the list using ``map``\n",
    "- the function can be a build-in function or a user defined function that takes one parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[231, 33, -2]\n"
     ]
    }
   ],
   "source": [
    "words = [\"231\", \"33\", \"-2\"]\n",
    "numbers = map(int, words)\n",
    "print(list(numbers))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "It is possible to apply ``map`` to several lists. In this case the function needs to have the same number of parameters as the number of lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[101, 202, 303]\n"
     ]
    }
   ],
   "source": [
    "def addition(x, y): return x+y\n",
    "\n",
    "a = [1, 2, 3]\n",
    "b = [100, 200, 300]\n",
    "\n",
    "print(list(map(addition, a, b)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Filtering\n",
    "\n",
    "- apply a test to each element of the list and if the result of the test is True the element is included in the new list\n",
    "- if the function is None returns only the elements that are **True**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "def odd(n): return n % 2 == 1\n",
    "\n",
    "# filter (keeps) only the odd numbers\n",
    "print(list(filter(odd, range(10))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Lambda functions\n",
    "\n",
    "- allow to define an anonymous function\n",
    "- they are \"one line\" functions \n",
    "- lambda functions contain only one expression ``lambda <arg-1, …, arg-n>: expression``\n",
    "- useful for ``map``, ``filter``, list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['', 'b', 'cc', 'ddd', 'eeee', 'fffff', 'gggggg', 'hhhhhhh', 'iiiiiiii', 'jjjjjjjjj']\n"
     ]
    }
   ],
   "source": [
    "print(list(map(lambda x, y: x*y, \"abcdefghijk\", range(10))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "print(list(filter(lambda x: x%2 == 1, range(10))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We typically should use simple for loops when getting started with Python, and map. Use comprehension where they are easy to apply. However, there is a substantial performance advantage to use list comprehension. The map calls are roughly twice as fast as equivalent for loops. List comprehensions are usually slightly faster than map calls. This speed difference is largely due to the fact that map and list comprehensions run at C language speed inside the interpreter. It is much faster that stepping through Python for loop code within the Python Virtual Machine (PVM).\n",
    "\n",
    "However, for loops make logic more explicit, we may want to use them on the grounds of simplicity. On the other hand, map and list comprehensions are worth knowing and using for simpler kinds of iterations if the speed of application is an important factor.\n",
    "\n",
    "From <a href=\"http://www.bogotobogo.com/python/python_list_comprehension.php\" target=\"_blank\">http://www.bogotobogo.com/python/python_list_comprehension.php</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Who did the homework? 😌"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Further reading\n",
    "\n",
    "- List comprehension <a href=\"http://treyhunner.com/2015/12/python-list-comprehensions-now-in-color/\" target=\"_blank\">http://treyhunner.com/2015/12/python-list-comprehensions-now-in-color/</a> (don't miss the links to videos at the end of the post)\n",
    "- Functional programming in python: <a href=\"https://docs.python.org/3/howto/functional.html\" target=\"_blank\">https://docs.python.org/3/howto/functional.html</a>"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-sa/4.0/\"><img alt=\"Creative Commons Licence\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-sa/4.0/88x31.png\" /></a><br /><span xmlns:dct=\"http://purl.org/dc/terms/\" property=\"dct:title\">Python programming for linguists</span> by <a xmlns:cc=\"http://creativecommons.org/ns#\" href=\"http://dinel.org.uk\" property=\"cc:attributionName\" rel=\"cc:attributionURL\">Constantin Orasan</a> is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-sa/4.0/\">Creative Commons Attribution-ShareAlike 4.0 International License</a>.<br />Based on a work at <a xmlns:dct=\"http://purl.org/dc/terms/\" href=\"https://github.com/dinel/PythonForLinguists\" rel=\"dct:source\">https://github.com/dinel/PythonForLinguists</a>."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}