fp_toolbox.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Programmazione Funzionale in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Higher order functions\n",
    "\n",
    "Nella programmazione funzionale si utilizzano le funzioni che hanno per parametri altre funzioni.\n",
    "Un esempio può essere `sorted`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['pera', 'mela', 'caffé', 'banana']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits = ['pera', 'mela', 'banana', 'caffé']\n",
    "sorted(fruits, key=len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['mela', 'banana', 'pera', 'caffé']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def reverse(word):\n",
    "    return word[::-1]\n",
    "\n",
    "sorted(fruits, key=reverse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Retaggi e convenzioni\n",
    "\n",
    "Alcune funzioni che si utilizzano spesso nella programmazione funzionale sono:\n",
    " -  `map`\n",
    " -  `filter`\n",
    " -  `reduce`\n",
    " -  `apply` \n",
    "\n",
    "In Python *dev'esserci uno e un solo modo ovvio di fare una cosa* e questo ci porta ad alcune considerazioni"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "\n",
    "\n",
    "### apply\n",
    "\n",
    " Ma `apply` non esiste più in Python 3, era già deprecata nella versione 2.3.\n",
    " \n",
    "Al posto di \n",
    "\n",
    "    apply(fn, args, kwargs)\n",
    "    \n",
    "Si può semplicemente\n",
    "\n",
    "    fn(*args, **kwargs)\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### map\n",
    "\n",
    "È ancora builtin, ma inutile da quando esiste la list comprehension e l'espressione di generatori."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def fact(num):\n",
    "    res = 1\n",
    "    if num != 0:\n",
    "        for n in range(1, num+1):\n",
    "            res *= n\n",
    "    return res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Questa funzione è volutamente non in stile FP. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 6, 24, 120]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(fact, range(6)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 6, 24, 120]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[fact(n) for n in range(6)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 6, 120]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(fact, filter(lambda n: n % 2, range(6))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 6, 120]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[fact(n) for n in range(6) if n % 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Reduce\n",
    "\n",
    "In Python 3 non è più un builtin, ma si trova in `functools`.  L'uso più commune è quello della sommatoria, ma in questo caso è meglio usare il builtin `sum` (dal 2.3 - 2003), migliorando le leggibilità e la performance. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4950"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "from operator import add\n",
    "\n",
    "reduce(add, range(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100000 loops, best of 3: 4.81 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit reduce(add, range(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4950"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(range(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000000 loops, best of 3: 979 ns per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit sum(range(100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Di uso comune sono anche `max` e `min`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max([x**(-1 if x%2 == 0 else 1) for x in range(1, 10)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Altri builtins (che *riducono*) utili sono `all` e `any`, che possono essere visti come un `and` e un `or` *massivi*. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "any([i%2 == 0 for i in range(10)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all([i%2 == 0 for i in range(10)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all([i%2 == 0 for i in range(10) if i%4 == 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Una specie di pigrizia\n",
    "\n",
    "Alcuni linguaggi funzionali utilizzano la valutazione lazy o pigra, bisogna richiedere espicitamente l'elaborazione del risultato. In python si può ottenere qualcosa di simile con i generatori (e le coroutines ma attenti ai side-effects XD )."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x7fd6b40577d8>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "powers_of_two = (i**2 for i in range(10))\n",
    "powers_of_two_divided_by_three = (i/3 for i in powers_of_two)\n",
    "powers_of_two_divided_by_three"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0,\n",
       " 0.3333333333333333,\n",
       " 1.3333333333333333,\n",
       " 3.0,\n",
       " 5.333333333333333,\n",
       " 8.333333333333334,\n",
       " 12.0,\n",
       " 16.333333333333332,\n",
       " 21.333333333333332,\n",
       " 27.0]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(powers_of_two_divided_by_three)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Il modulo `operator`\n",
    "Spesso conviene utilizzare un operatore aritmetico come un funzione. Ad esempio, in python la sommatoria c'è, come abbiamo visto è `sum`, ma non la produttoria."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100000 loops, best of 3: 11.5 µs per loop\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "def fact(n):\n",
    "    return reduce(lambda a, b: a * b, range(1, n+1))\n",
    "\n",
    "%timeit fact(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100000 loops, best of 3: 7.5 µs per loop\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "from operator import mul\n",
    "\n",
    "def fact(n):\n",
    "    return reduce(mul, range(1, n+1))\n",
    "\n",
    "%timeit fact(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Operator permette di rimpiazzare anche tutte le funzioni che devono recuperare parametri da oggetti e sequenze, usando `itemgetter` e `attrgetter`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Sao Paolo', 'BR', 19.649, (-23.547778, -46.635833)),\n",
       " ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)),\n",
       " ('Tokio', 'JP', 36.933, (35.689722, 139.691667)),\n",
       " ('Mexico City', 'MX', 20.142, (19.433333, -99.133333)),\n",
       " ('New York-Newark', 'US', 20.104, (40.808611, -74.020386))]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metro_data = [\n",
    "    ('Tokio', 'JP', 36.933, (35.689722, 139.691667)),\n",
    "    ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)),\n",
    "    ('Mexico City', 'MX', 20.142, (19.433333, -99.133333)),\n",
    "    ('New York-Newark', 'US', 20.104, (40.808611, -74.020386)),\n",
    "    ('Sao Paolo', 'BR', 19.649, (-23.547778, -46.635833)),\n",
    "]\n",
    "\n",
    "from operator import itemgetter\n",
    "\n",
    "# itemgetter(1) == lambda(l): l[1]\n",
    "[city for city in sorted(metro_data, key=itemgetter(1))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('JP', 'Tokio'),\n",
       " ('IN', 'Delhi NCR'),\n",
       " ('MX', 'Mexico City'),\n",
       " ('US', 'New York-Newark'),\n",
       " ('BR', 'Sao Paolo')]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cc_name = itemgetter(1, 0)\n",
    "[cc_name(city )for city in metro_data]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In maniera simile funziona `attrgetter`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Metropolis(name='Tokio', cc='JP', pop=36.933, coord=LatLong(lat=35.689722, long=139.691667))"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import namedtuple\n",
    "LatLong = namedtuple('LatLong', 'lat long')  \n",
    "Metropolis = namedtuple('Metropolis', 'name cc pop coord')  \n",
    "\n",
    "metro_areas = [Metropolis(name, cc, pop, LatLong(lat, long))  \n",
    "    for name, cc, pop, (lat, long) in metro_data]\n",
    "metro_areas[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35.689722"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metro_areas[0].coord.lat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Sao Paolo', -23.547778),\n",
       " ('Mexico City', 19.433333),\n",
       " ('Delhi NCR', 28.613889),\n",
       " ('Tokio', 35.689722),\n",
       " ('New York-Newark', 40.808611)]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from operator import attrgetter\n",
    "name_lat = attrgetter('name', 'coord.lat')\n",
    "\n",
    "[name_lat(city) for city in sorted(metro_areas, key=attrgetter('coord.lat'))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abs',\n",
       " 'add',\n",
       " 'and_',\n",
       " 'attrgetter',\n",
       " 'concat',\n",
       " 'contains',\n",
       " 'countOf',\n",
       " 'delitem',\n",
       " 'eq',\n",
       " 'floordiv',\n",
       " 'ge',\n",
       " 'getitem',\n",
       " 'gt',\n",
       " 'iadd',\n",
       " 'iand',\n",
       " 'iconcat',\n",
       " 'ifloordiv',\n",
       " 'ilshift',\n",
       " 'imatmul',\n",
       " 'imod',\n",
       " 'imul',\n",
       " 'index',\n",
       " 'indexOf',\n",
       " 'inv',\n",
       " 'invert',\n",
       " 'ior',\n",
       " 'ipow',\n",
       " 'irshift',\n",
       " 'is_',\n",
       " 'is_not',\n",
       " 'isub',\n",
       " 'itemgetter',\n",
       " 'itruediv',\n",
       " 'ixor',\n",
       " 'le',\n",
       " 'length_hint',\n",
       " 'lshift',\n",
       " 'lt',\n",
       " 'matmul',\n",
       " 'methodcaller',\n",
       " 'mod',\n",
       " 'mul',\n",
       " 'ne',\n",
       " 'neg',\n",
       " 'not_',\n",
       " 'or_',\n",
       " 'pos',\n",
       " 'pow',\n",
       " 'rshift',\n",
       " 'setitem',\n",
       " 'sub',\n",
       " 'truediv',\n",
       " 'truth',\n",
       " 'xor']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import operator\n",
    "[name for name in dir(operator) if not name.startswith('_')]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Interessante è anche `methodcaller`, che permette di estrapolare un metodo e utilizzarlo nelle comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'BENVENUTI A PYTHON MILANO MEETUP'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from operator import methodcaller\n",
    "\n",
    "s = 'Benvenuti a Python Milano Meetup'\n",
    "upcase = methodcaller('upper')\n",
    "upcase(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Benvenuti-a-Python-Milano-Meetup'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hiphenate = methodcaller('replace', ' ', '-')\n",
    "hiphenate(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Il modulo functools\n",
    "\n",
    "Ecco un altro modulo molto utile che dobbiamo inserire nella nostra cassetta degli attrezzi per la Programmazione Funzionale.\n",
    "Saltiamo `reduce`, perché l'abbiamo già trattato in precedenza, ma parliamo di `partial`, che funzione in modo simile a `operator.methodcaller`, perché permette, data una funzione, di creare un'altra funzione con degli argomenti *congelati*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 3, 6, 9, 12, 15, 18]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from operator import mul\n",
    "from functools import partial\n",
    "\n",
    "triple = partial(mul, 3)\n",
    "[triple(x) for x in range(7)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Il modulo itertools\n",
    "\n",
    "Fornisce un insieme di high order function utili per combinare iteratori e "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def fibonacci():\n",
    "    a, b = 1, 1\n",
    "    while True:\n",
    "        yield a\n",
    "        a, b = b, a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 1), (1, 2), (2, 4), (3, 7), (5, 12), (8, 20), (13, 33)]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from itertools import tee, accumulate\n",
    "s, t = tee(fibonacci())\n",
    "pairs = zip(t, accumulate(s))\n",
    "[(fib, total) for _, (fib, total) in zip(range(7), pairs)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 0, 1, 2, 3, 4, 0, 1]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from itertools import chain\n",
    "thrice_range = chain(range(3), range(5), range(2))\n",
    "[num for _, num in zip(range(10), thrice_range)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 'A', 'B', 'C', 'D', 0, 1, 2]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def thrice_it(it1, it2, it3):\n",
    "    yield from it1\n",
    "    yield from it2\n",
    "    yield from it3\n",
    "    \n",
    "[i for i in thrice_it(range(3), 'ABCD', range(3))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['accumulate',\n",
       " 'chain',\n",
       " 'combinations',\n",
       " 'combinations_with_replacement',\n",
       " 'compress',\n",
       " 'count',\n",
       " 'cycle',\n",
       " 'dropwhile',\n",
       " 'filterfalse',\n",
       " 'groupby',\n",
       " 'islice',\n",
       " 'permutations',\n",
       " 'product',\n",
       " 'repeat',\n",
       " 'starmap',\n",
       " 'takewhile',\n",
       " 'tee',\n",
       " 'zip_longest']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import itertools\n",
    "[name for name in dir(itertools) if not name.startswith('_')]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Bibliografia\n",
    "\n",
    "Gli esempi sono stati presi soprattutto dai seguenti volumi:\n",
    "   - Luciano Ramalho - Fluent Python - O'Reilly\n",
    "   - David Mertz - Functional Programming in Python - O'Reilly\n",
    "   - David Beazley - Generator Tricks for Systems Programmers - Talk al PyCon UK 2008"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}