un pitone a san luca - fondamentali.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import __builtin__ \n",
      "npall, all = all, __builtin__.all \n",
      "npany, any = any, __builtin__.any"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Un pitone a San Luca - Fondamentali #\n",
      "***\n",
      "\n",
      "<img src=\"files/example_spherical_harmonics.jpg\">\n",
      "***\n",
      "\n",
      "## Perch\u00e8 programmare ?##\n",
      "\n",
      "affrontiamo subito il cuore del problema. Programmare \u00e8 (o meglio, sembra):\n",
      "\n",
      "* lungo da imparare\n",
      "* difficile da imparare\n",
      "* poco efficiente (tanto tempo per pochi risultati)\n",
      "* poco produttivo (posso fare solo cose semplici)\n",
      "\n",
      "In sostanza, ogni volta che vi trovate di fronte all'idea di scrivere un \n",
      "programma, vi sentite come se doveste scalare l'everest...\n",
      "e senza sapere cosa guadagnare da questa faticaccia!\n",
      "\n",
      "Voglia convincervi che programmare non solo \u00e8 utile, ma \u00e8 anche molto pi\u00f9 facile di quanto non crediate!\n",
      "\n",
      "Non \u00e8 una salita verso l'everest, ma \u00e8 pi\u00f9 simile ad una comoda passeggiata verso San Luca.\n",
      "\n",
      "Rimane il problema fondamentale: perch\u00e8 fare comunque la fatica?\n",
      "\n",
      "* analisi dati\n",
      "* stime montecarlo\n",
      "* simulazione di modelli\n",
      "* calcolo simbolico\n",
      "* previsione di risultati sperimentali\n",
      "* esplorazione di modelli\n",
      "* visualizzazione dati\n",
      "* compiti di automazione\n",
      "* acquisizione ed elaborazione dati live\n",
      "\n",
      "### Perch\u00e8 in Python? ###\n",
      "Python \u00e8 un linguaggio molto espressivo, che permette di eseguire operazioni complicate con pochissime righe di codice molto comprensibili.\n",
      "\n",
      "Il classico programma che scrive hello world su terminale risulta essere semplicemente"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "print \"hello world\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "meno di cos\u00ec non si pu\u00f2!\n",
      "\n",
      "salvatelo in un file di testo chiamato *hello.py* ed eseguite da \n",
      "terminale (nella stessa cartella in cui lo avete salvato):\n",
      "\n",
      "**python hello.py**\n",
      "\n",
      "Complimenti! avete scritto ed eseguito il vostro primo programma python!\n",
      "\n",
      "### Usare Python ###\n",
      "Esistono due modi di usare python:\n",
      "\n",
      "* **script** scrivere uno script ed eseguirlo con il comando **python myscript.py**\n",
      "* **console** lavorare con la shell di python, che permette di eseguire il codice \n",
      "\n",
      "Recentemente, grazie agli sforzi del team di IPython, un terzo metodo \u00e8 possibile, ed \u00e8 proprio quello che state osservando: il notebook online. \u00c8 uno strumento eccezionale, ma per ora cerchiamo di capire le basi, ovvero la shell.\n",
      "\n",
      "La shell di python \u00e8 uno strumento estremamente potente ed utile, \n",
      "specie nella sua versione potenziata, **IPython**.\n",
      "I tre grandi principali vantaggi della shell sono:\n",
      "\n",
      "* eseguire semplici operazioni senza perdere tempo a scrivere script e \n",
      "salvarli per cose che magari faremo una volta soltanto\n",
      "* usare l'help interattivo di python per leggere l'help di una funzione \n",
      "(spesso contenente anche esempi di come usarla) senza dover cercare in \n",
      "mezzo a dei grossi manuali\n",
      "* fare prototyping del codice, ovvero controllare se i comandi che stiamo \n",
      "per inserire in un programma fanno veramente quello che vogliamo noi\n",
      "\n",
      "### Espressivit\u00e0 ###\n",
      "\n",
      "Per chiarire il punto sull'espressivit\u00e0, vediamo ora un programma \n",
      "di esempio scritto in java, c++ e python e confrontiamoli come comprensibilit\u00e0.\n",
      "\n",
      "Questo programma legge del testo dall'utente e lo ristampa \n",
      "in un ciclo che termina quando l'utente non scrive pi\u00f9 nulla.\n",
      "\n",
      "***\n",
      "\n",
      "####versione in java####\n",
      "\n",
      "`import java.io.*;\n",
      "public class Echo {\n",
      "  public static void main(String[] args) throws IOException {\n",
      "    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n",
      "    String s;\n",
      "    while ((s = in.readLine()) != null)\n",
      "      System.out.println(s);  }}`\n",
      "\n",
      "***\n",
      "\n",
      "####versione in C++####\n",
      "\n",
      "`#include <iostream>\n",
      "using namespace std;\n",
      "int main() {\n",
      "  while(cin) {\n",
      "    getline(cin, input_line);\n",
      "    cout << input_line << endl;  };\n",
      "  return 0; }`\n",
      "\n",
      "***\n",
      "\n",
      "####versione in Python####\n",
      "\n",
      "`var = raw_input(\"scrivi: \")\n",
      "while var:\n",
      "    print var\n",
      "    var = raw_input(\"scrivi: \")`\n",
      "\n",
      "***\n",
      "\n",
      "Questo esercizio \u00e8 interessante perch\u00e8 il python ottiene un buon risultato \n",
      "pur essendo molto sfavorevole per questo confronto, essendo un'operazione quasi banale.\n",
      "\n",
      "Se togliamo la condizione di interruzione del testo \n",
      "(che non cambierebbe il codice in c++ o in java), potrei scrivere semplicemente:\n",
      "\n",
      "`while True:\n",
      "    print raw_input(\"scrivi: \")`\n",
      "\n",
      "in generale potete aspettarvi una riduzione delle righe di codice di circa 10 o 20 volte.\n",
      "\n",
      "Proviamo a  vedere alcuni esempi pi\u00f9 favorevoli (senza la controparte \n",
      "in C++, sarebbe troppo lunga per una slide, per non parlare del java)\n",
      "\n",
      "vediamo ora qualche esempio aggiuntivo di espressivit\u00e0 estrema:"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "***\n",
      "voglio ottenere i quadrati dei numeri dispari inferiori a 10"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "[ x**2 for x in xrange(10) if x%2 ]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "***\n",
      "il minimo comune multiplo di 27 e 51"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "from itertools import count\n",
      "next( x for x in count(1) if x%27==0 and x%51==0 )"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "***\n",
      "il minimo comune multiplo di un qualsiasi set di numeri (contenuti nel vettore a)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "from itertools import count\n",
      "a=[3,4,7]\n",
      "print next( x for x in count(max(a)+1) if all( x%i==0 for i in a ) )\n",
      "print next( x for x in count(max(a)+1) if not any( x%i for i in a ) )"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "***\n",
      "Ho un vettore che contiene quadruplette del tipo (x,y,z,valore). Voglio separarle in 4 vettori di numeri."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "dati= [ (1,2,3,0.1), (4,2,3,0.3), (6,2,1,0.8) ];"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "vediamo la scrittura esplicita (che \u00e8 gi\u00e0 molto pi\u00f9 comprensibile della corrispondente in altri linguaggi)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "x = list()\n",
      "y = list()\n",
      "z = list()\n",
      "v = list()\n",
      "for d in dati:\n",
      "    x.append(d[0])\n",
      "    y.append(d[1])\n",
      "    z.append(d[2])\n",
      "    v.append(d[3])\n",
      "print x, y, z, v"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "soluzione alternativa 1:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "x, y, z, v = zip(*dati)\n",
      "print x, y, z, v"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "soluzione alternativa 2:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "x,y,z,v = map(None,*dati)\n",
      "print x,y,z,v"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### i vantaggi della sintesi ####\n",
      "\n",
      "* Meno tempo necessario a scrivere\n",
      "* pi\u00f9 semplice da leggere (e quindi capire)\n",
      "* meno possibilit\u00e0 di errore\n",
      "* in caso di errore, pi\u00f9 semplice da controllare\n",
      "* riduzione del codice inutile\n",
      "* semplifica il prototyping (di nuovo per ridurre gli errori)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#Un caso di studio - analisi statistica dei dati#\n",
      "\n",
      "Vogliamo descrivere un insieme di dati tramite le sue propriet\u00e0 statistiche (minimo, massimo, media, etc...).\n",
      "\n",
      "Useremo questo esempio per vedere python e alcuni dettagli della buona programmazione.\n",
      "\n",
      "Partiremo dal semplice e saliremo al complesso, un passo alla volta.\n",
      "\n",
      "##Python come calcolatrice##\n",
      "\n",
      "Iniziamo con i tipi di dati numerici disponibili su python:\n",
      "\n",
      "* booleani (bool)\n",
      "* numeri interi (int)\n",
      "* numeri reali (float)\n",
      "* numeri complessi (complex)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "print 1 + 1\n",
      "print 1.0 - 1.0\n",
      "print True and False\n",
      "print (3.+4.j) * (2.+4.j)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "a = 2\n",
      "b = 3\n",
      "\n",
      "print a + b\n",
      "print b - a\n",
      "print b * a\n",
      "print b / a\n",
      "print a ** b\n",
      "print b % a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "come potete notare la divisione fra interi restituisce la parte intera con i decimali troncati.\n",
      "Questo comportamento \u00e8 stato corretto nella versione 3 di Python, \n",
      "ma \u00e8 possibile correggerla anche in quella che stiamo usando noi scrivendo il comando"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "from __future__ import division\n",
      "print b / a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "se fosse necessario sono disponibili funzioni pi\u00f9 avanzate, basta *importare* il *modulo* **math**.\n",
      "\n",
      "In questo modulo sono contenute tutte le pi\u00f9 comuni funzioni di calcolo matematico \n",
      "(esponenziali, seni, coseni, etc...).\n",
      "\n",
      "Questo modulo ha un equivalente per i numeri complessi chiamato **cmath**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import math\n",
      "import math as mt\n",
      "from math import sin\n",
      "from math import cos as cs\n",
      "\n",
      "print mt.e\n",
      "print mt.pi\n",
      "print mt.exp( 5. )\n",
      "print sin( 0.3 )\n",
      "print cs( 0.1 )"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Abbiamo importato le nostre funzioni sia come funzioni a se stanti, ovvero seno e cose, che importato l'intera libreria matematica ed utilizzate le sue funzioni accedendovi tramite il punto fra nome della libreria e nome della funzione. Entrambi i modi sono accettabili, e si possono usare a seconda dei vantaggi: tipicamente l'import diretto quando avete necessit\u00e0 di poche specifiche funzioni, mentre l'uso del punto \u00e8 conveniente se dovete usare molte funzioni delle stesso modulo o pi\u00f9 moduli importano funzioni simili.\n",
      "\n",
      "Esiste una terza maniera di importare, l'importazione completa della libreria, fatta tramire l'asterisco. Questa pu\u00f2 essere comoda quando si fa una breve sessione di shell, ma \u00e8 fortemente sconsigliata in script seri in quanto pu\u00f2 portare ad una gran confusione sull'origine di diverse funzioni."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### formattare l'output###\n",
      "\n",
      "spesso \u00e8 necessario stampare il risultato delle nostre operazioni in un modo \n",
      "non standard: pi\u00f9 o meno cifre decimali, allineamenti strani o simili.\n",
      "\n",
      "in generale per stampare un numero con del testo mescolato \u00e8 sufficiente scrivere"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "print \"la variabile a vale:\", a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "ma quando questo non bastasse \u00e8 possibile sfruttare la funzione \n",
      "**format** delle *stringhe* (vedremo meglio fra poco di cosa si tratti).\n",
      "\n",
      "Grazie a questa funzione, all'interno di una stringa viene sostituito il valore che \n",
      "diamo in pasto alla funzione nel punto delimitato dalle parentesi graffe {}"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "print \"la variabile a vale {}\".format(a)\n",
      "print \"a e b valgono rispettivamente {} e {}\".format(a, b)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "per impostare il numero di cifre decimali \u00e8 sufficiente utilizzare il comando :.n dove n \u00e8 il numero di cifre che desideriamo"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "print \"pi greca con 4 decimali = {:.4f}\".format(10 * mt.pi)\n",
      "print \"pi greca 3 decimali e notazione scientifica = {:.3e}\".format(10 * mt.pi)\n",
      "print \"pi greca con 4 cifre e padding a 10 caratteri = {:10.4}\".format(10 * mt.pi)\n",
      "print \"pi greca con 7 cifre e padding a 10 caratteri = {:10.7}\".format(10 * mt.pi)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\u00c8 da notare che la sostituzione crea una nuova stringa, e successivamente questa viene stampata. Questo significa che questa funzione \u00e8 disponibile indipendentemente dalla stampa."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "stampa_unione = \"{}.{}@unibo.it\".format('enrico', 'giampieri')\n",
      "print stampa_unione"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### chiedere aiuto ###\n",
      "nel caso fossero necessarie informazioni, \u00e8 possibile sfruttare la capacit\u00e0 di introspezione di python.\n",
      "tramite la funzione **help(math)** \u00e8 possibile avere tutte le informazioni su \n",
      "quali siano le funzioni contenute dentro il modulo math.\n",
      "\n",
      "Scrivendo **help(sum)** si possono avere informazioni sulla funzione *sum* \n",
      "(che somma tutti gli elementi che gli vengono passati).\n",
      "\n",
      "Per vedere tutti gli oggetti contenuti all'interno del modulo *math* senza usare il suo help \u00e8 possibile usare la funzione\n",
      "**dir(math)**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "help(sum)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##Interagire con l'utente##\n",
      "\n",
      "Abbiamo visto come sia possibile scrivere a terminale usando la funzione print.\n",
      "\n",
      "\u00c8 possibile anche leggere da terminale una stringa inserita dall'utente con il comando\n",
      "\n",
      "**raw_input(stringa_di_saluto)**\n",
      "\n",
      "Che mostra una stringa e subito dopo d\u00e0 la possibilit\u00e0 all'utente di inserire un testo qualsiasi.\n",
      "Logicamente questo approccio, per quanto comodo per i lavori pi\u00f9 semplici, risulta limitato in fase di produzione, specie perch\u00e8\n",
      "risulta difficile effettuare interazioni pi\u00f9 complicate.\n",
      "\n",
      "Per ottenere una maggiore interazione con l'utente \u00e8 necessario utilizzare una interfaccia grafica,\n",
      "che per\u00f2 non \u00e8 un'attivit\u00e0 con cui ci si cimenta volentieri.\n",
      "\n",
      "In nostro soccorso arriva una librerie esterna, **easygui** (ne esistono anche altre, ma questa \u00e8 la pi\u00f9 semplice e comoda).\n",
      "\n",
      "easygui si pu\u00f2 ottenere in vari modi:\n",
      "\n",
      "* se usate linux lo trovate nel vostro gestore dei pacchetti\n",
      "* **easy_install easygui** (se avete installato il programma easy_install)\n",
      "* **pip install easygui** (vedi sopra)\n",
      "* andate nel sito, scaricate il pacchetto, lo estraete e lanciate il comando **python setup.py install**\n",
      "* copiate il file **easygui.py** nella stessa directory del vostro script (possibile solo per le librerie pi\u00f9 piccole, come questa)\n",
      "\n",
      "tutti questi metodi sono standard per installare pacchetti, e vanno bene per installare qualsiasi libreria esterna.\n",
      "\n",
      "per vedere tutti gli widget messi a disposizione da questa libreria vedere [easygui tutorial](http://easygui.sourceforge.net/tutorial/index.html)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Per semplicit\u00e0 in questo tutorial ci limiteremo ad utilizzare **raw_input** per ottenere i dati dall'utente."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "testo = raw_input(\"scrivi il tuo nome: \")\n",
      "print \"ciao \" + testo + \"!\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "valore = raw_input('dammi un numero: ')\n",
      "print valore**2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Quando proviamo ad elevare al quadrato il nostro valore, ci ritroviamo di fronte ad un problema: **raw_input** ci restituisce una stringa, non un numero, per cui non posso effettuare operazioni matematiche sul mio input direttamente.\n",
      "\n",
      "Il modo pi\u00f9 semplice \u00e8 prendere il testo e convertirlo a float con la funzione **float()**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "valore = raw_input('dammi un numero: ')\n",
      "valore = float(valore)\n",
      "print valore**2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "se inseriamo una stringa che non sia un numero ci troviamo di fronte ad un errore, in cui python ci avvisa che qualcosa \u00e8 andato male.\n",
      "Per fortuna gli errori sono molto completi e spiegano dove e perch\u00e8 c'\u00e8 stato il problema."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "float(\"testo generico\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Diamo per buono che il numero sia stato inserito correttamente (vedremo dopo come gestire gli errori).\n",
      "\n",
      "In molte analisi statistiche ci ritroveremo a fare delle radici quadrate, che per\u00f2 sono mal \n",
      "definite per numeri negativi (nel campo dei reali, ovviamente).\n",
      "Vogliamo quindi avvisare il nostro utente che ci ha dato un valore non accettabile.\n",
      "Possiamo fare questo con un blocco **if**:\n",
      "\n",
      "    if condizione:\n",
      "        codice da eseguire se la condizione \u00e8 vera\n",
      "    elif condizione alternativa:\n",
      "        codice per la condizione alternativa\n",
      "    else:\n",
      "        codice se nessuno dei casi precedenti \u00e8 vero\n",
      "\n",
      "i due punti dopo la condizione indicano l'inizio di un blocco di codice, \n",
      "ad esempio quello da eseguire se la condizione if risultasse vera.\n",
      "Questo blocco **DEVE ESSERE INDENTATO CORRETTAMENTE**.\n",
      "Nel Python l'indentazione non \u00e8 opzionale ed \u00e8 necessario usarla in modo consistente, o l'interprete si lamenter\u00e0.\n",
      "la chiusura del blocco corrisponde alla fine dell'indentazione.\n",
      "\n",
      "sia il blocco *elif* che il blocco *else* sono opzionali"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "from math import sqrt\n",
      "valore = raw_input('dammi un numero: ')\n",
      "valore = float(valore)\n",
      "if valore>0:\n",
      "    print \"la sua radice quadrata \u00e8: \", sqrt(valore)\n",
      "elif valore==0:\n",
      "    print \"la radice di 0 \u00e8 0\"\n",
      "else:\n",
      "    print \"non posso calcolare la radice di un numero negativo\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "i blocchi e le condizioni possono essere indentate una dentro l'altra"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "valore = raw_input('dammi un numero: ')\n",
      "valore = float(valore)\n",
      "if valore>0:\n",
      "    if valore>10:\n",
      "        print \"troppo lungo, non ne ho voglia\"\n",
      "    else:\n",
      "        print \"la sua radice quadrata \u00e8: \", sqrt(valore)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "vengono considerate espressioni false:\n",
      "\n",
      "* il booleano False\n",
      "* il numero 0 (sia intero che float)\n",
      "* un contenitore vuoto (vedremo dopo)\n",
      "* l'oggetto None\n",
      "\n",
      "Tutte le altre sono considerate vere.\n",
      "\n",
      "Le espressioni posso essere combinate con le espressioni booleane di base, **not, and, or**, ma \u00e8 \n",
      "possibile anche usare gli operatori unari del c, **&,|**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "print not True\n",
      "print True and False , True & False\n",
      "print True or False , True | False"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Immaginiamo ora di avere un numero e di volerne prendere il valore assoluto. \n",
      "Nella libreria standard esiste la funzione **abs**, ma vogliamo realizzarne la nostra versione con if ed else.\n",
      "la versione estesa \u00e8:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "x = int(raw_input('dammi un numero: '))\n",
      "if x>0:\n",
      "    print x\n",
      "else:\n",
      "    print -x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Esiste in questo caso una sintassi pi\u00f9 rapida e comoda, che permette di inserire il tutto in un solo comando:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "x = int(raw_input('dammi un numero: '))\n",
      "print x if x>0 else -x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Questi if-else possono essere concatenati in modo da fare condizioni multiple"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "x = int(raw_input('dammi un numero: '))\n",
      "print x if x>0 else -x if x<0 else 0"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Che si legge nella seguente maniera:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "print x if x>0 else (-x if x<0 else 0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "in cui l'if else interno viene eseguito per decidere cosa debba ritornare la clausola else."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##Primi passi con i dati##\n",
      "\n",
      "iniziamo ora a vedere davvero come si possa lavorare con dei dati.\n",
      "\n",
      "Python fornisce diverse classi per raccogliere dati, quella che useremo ora \u00e8 la pi\u00f9 semplice, la **lista**\n",
      "\n",
      "*(nota: da questo momento in poi, per comodit\u00e0 negli esercizi, non user\u00f2 pi\u00f9 le funzioni di easygui ma user\u00f2 dei\n",
      "valori fissati, in modo da far vedere vari casi)*"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "a = [0,1,6,2,9,3,0,4]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Una lista pu\u00f2 contenere un qualsiasi numero di dati, anche di tipi misti, comprese altre stringhe.\n",
      "La seguente \u00e8 quindi una lista perfettamente legale:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "b = [1.0 , 3, True, 4.+3.j, \"testo\", [ \"lista\", \"testo\"] ]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "l'operatore *+* permette di accodare diverse liste:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "a+b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Questa operazione crea una nuova lista contenente la coda delle due, ma non le modifica. \n",
      "\u00c8 possibile estendere la lista a con il contenuto di b usando il metodo **extend**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "a.extend(b)\n",
      "print a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "per aggiungere un solo elemento alla lista \u00e8 invece possibile usare il metodo **append**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "a.append(100)\n",
      "print a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###elementi di una lista###\n",
      "per accedere ai dati di una lista si usano le parentesi quadrate [ ].\n",
      "\u00c8 possibile specificare interi range di valori, in cui vengono presi dal primo all'ultimo-1.\n",
      "\n",
      "La scelta di numerare le liste da 0 ad N-1 \u00e8 conforme con la prassi del C, e pu\u00f2 risultare talvolta innaturale, per\u00f2 ha dei grandi vantaggi in termini di operazioni di accesso diretto agli elementi che la scelta \u00e8 ricaduta sul mantenere questo notazione."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "print a[:]\n",
      "print a[0]\n",
      "print a[-1]\n",
      "print a[1:4]\n",
      "print a[:-1]\n",
      "print a[3:]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Se si hanno liste di liste \u00e8 possibile concatenare le estrazioni"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "a = [1, 2, [3, 4]]\n",
      "print a[0]\n",
      "print a[2]\n",
      "print a[2][0]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Nel caso si abbia una lista di lunghezza nota, ad esempio di due elementi, \u00e8 possibile \n",
      "estrarre gli elementi direttamente in pi\u00f9 variabili contemporaneamente"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "a, b = [1, 2]\n",
      "print a,b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "questo rende lo scambio di variabili particolarmente semplice:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "print a,b\n",
      "b,a=a,b\n",
      "print a,b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "per verificare la presenza di un elemento dentro una lista, si pu\u00f2 usare il comando **in**."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "primi = [1, 2, 3, 5, 7, 11, 13, 17, 19]\n",
      "print 12 in primi\n",
      "print 17 in primi"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###Identit\u00e0 delle liste###\n",
      "\n",
      "In python le variabili non \"contengono\" il loro valore, ma sono solo dei nomi che si da agli oggetti.\n",
      "\n",
      "Questo significa che se imponiamo una variabile uguale ad una lista, \n",
      "ogni modifica effettuata sulla prima si ripercuoter\u00e0 sulla seconda"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "a = [0, 1, 2]\n",
      "b = a\n",
      "print a,b\n",
      "a[0]=5\n",
      "print a,b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "possiamo verificare se due variabili puntano alla stessa lista con il comando **is**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "print a is b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "per copiare il contenuto di una lista valore per valore, \n",
      "creandone cos\u00ec una copia che non dipenda dalla prima, si pu\u00f2 usare il comando [:]"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "c = a[:]\n",
      "print c\n",
      "print c is a\n",
      "a[0] = 0\n",
      "print c"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Per visualizzare queste cose \u00e8 possibile utilizzare l'ottimo tutor online per python:\n",
      "\n",
      "<http://people.csail.mit.edu/pgbovine/python/>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###Iterazioni sulle liste###\n",
      "\n",
      "Consideriamo ora di voler prendere tutti i dati contenuti in una lista \n",
      "e di volerne creare una nuova contenente la radice quadrata di tutti gli elementi."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "c = [ 2.0, 5.0, 9.0, 2.0, 0.1, 1e-3, 1e2]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Usando le nozioni di programmazione classica pensiamo di dover scrivere un ciclo **while** sulla lista, \n",
      "ed effettivamente \u00e8 un metodo possibile, anche se molto poco performante"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "from math import sqrt\n",
      "d = []\n",
      "idx = 0\n",
      "L = len(c)\n",
      "while idx<L:\n",
      "    d.append(sqrt(c[idx]))\n",
      "    idx += 1\n",
      "print d"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Una soluzione migliore \u00e8 utilizzare il ciclo **for** che in python \u00e8 uno strumento eccezionalemente potente.\n",
      "Permette infatti di scorrere direttamente tutti gli elementi della lista, in ordine, senza doversi preoccupare di indici"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "d = []\n",
      "for elemento in c:\n",
      "    d.append( sqrt(elemento) )\n",
      "print d"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "se volessimo controllare di non lanciare la funzione *sqrt* su numeri negativi, possiamo inserire un controllo if che aggiunge\n",
      "l'elemento solo se positivo"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "c = [2.0, -3, 4.0]\n",
      "d = []\n",
      "for elemento in c:\n",
      "    if elemento>=0:\n",
      "        d.append( sqrt(elemento) )\n",
      "print d"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Una maniera alternativa, pi\u00f9 elegante soprattutto in caso le condizioni di abbandono risultino numerose, \u00e8 l'uso del comando\n",
      "**continue**, che salta direttamente all'iterazione successiva del ciclo, fratello del comando **break** che interrompe\n",
      "completamente il ciclo. Strutturando il ciclo in quest maniera di evita di innestare troppo il codice e lo si rende\n",
      "pi\u00f9 leggibile."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "c = [2.0, -3, 4.0]\n",
      "d = []\n",
      "for elemento in c:\n",
      "    if elemento<0:\n",
      "        continue\n",
      "    d.append( sqrt(elemento) )\n",
      "print d"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Ancora meglio, \u00e8 possibile usare uno strumento eccezionalemente potente, la **list comprehension**, che permette di \n",
      "scrivere questo stesso identico ciclo saltando tutti gli step intermedi, ottenendo anche una sintassi molto pi\u00f9 chiara:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "d = [ sqrt(elemento) for elemento in c if elemento>=0  ]\n",
      "print d"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Questo genere di operazioni sono estremamente generali, e sono la base della cosiddetta *programmazione funzionale*.\n",
      "\n",
      "In questo modo si sfoglia un insieme di elementi, si scelgono solo quelli che rispettano una certa condizione e a quelli\n",
      "che accetto applico una certa funzione.\n",
      "\n",
      "vediamo un esempio concreto:\n",
      "\n",
      "Leggo da terminale una stringa che penso contenere dei numeri, e voglio ottenere un array contenente questi numeri.\n",
      "Posso ottenere una lista di sottostringhe con la funzione **split**, controllare se sono numeri con la funzione **isnumeric**\n",
      "e convertirli in interi con la funzione **int**.\n",
      "\n",
      "La funzione complessiva risulta essere la seguente:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "print \"3 4 5\".split()\n",
      "print \"4,5,6\".split(',')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "print \"12\".isdigit()\n",
      "print \"er\".isdigit()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "testo=\" e 4 5 0 testo 12\"\n",
      "txt_list = testo.split()\n",
      "print [ int(s) for s in txt_list if s.isdigit() ]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Un piccolo consiglio utile: se volete splittare delle liste in cui vi siano presenti pi\u00f9 caratteri di separazione, la maniera pi\u00f9 comoda risulta essere quella di convertire i separatori gli uni negli altri con la funzione **replace** per poi fare un unico split."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "testo = '1 2,3, 4;5'\n",
      "testo = testo.replace(',', ' ')\n",
      "print testo\n",
      "testo = testo.replace(';', ' ')\n",
      "print testo\n",
      "testo.split()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "visto che la funzione replace ritorna una stringa, \u00e8 in realt\u00e0 possibile accodare tutte queste operazioni in un'unica riga senza creare variabili intermedie"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "testo = '1 2,3, 4;5'\n",
      "print testo.replace(',', ' ').replace(';', ' ').split()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###gestione degli errori e funzioni###\n",
      "\n",
      "Provando ad inserire dei numeri decimali o con un segno negativo, \n",
      "ci possiamo rendere conto che per\u00f2 il nostro metodo non funziona come ci aspetteremmo, \n",
      "la funzione di selezione non si comporta come vorremmo, per\u00f2 non abbiamo altre maniere di verificare.\n",
      "Dobbiamo quindi scrivere una nostra funzione che ci permetta di verificare la condizione che desideriamo.\n",
      "\n",
      "Per scriverla useremo un approccio molto brutale: tenteremo di convertire il nostro numero con la funzione float.\n",
      "Se tutto dovesse procedere bene daremo il nostro nulla osta ritornando True.\n",
      "\n",
      "Se per\u00f2 dovesse esserci un problema (ovvero la stringa non pu\u00f2 essere convertita in un numero), Python\n",
      "creer\u00e0 una **Eccezione**, che rappresenta un errore. Questa cosa tenderebbe a far interrompere l'esecuzione del programma,\n",
      "ma possibile controllare questa situazione con un comando **try except**, che permette di eseguire del codice e specificare\n",
      "come il programma si debba comportare quando si verifica un determinato errore.\n",
      "\n",
      "Per intercettare l'errore di conversione, che solleva una **ValueError Exception**, utilizzeremo il seguente codice"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "try:\n",
      "    float(\"pippo\")\n",
      "except ValueError as e:\n",
      "    print e"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Se volessimo catturare pi\u00f9 tipi di errore dal nostro codice, possiamo racchiudere \n",
      "tutti i tipi che ci interessano fra parentesi. Di solito l'help specifica quali tipi di errori una funzione solleva, \n",
      "ma con il terminale potete giocare con la vostra funzione per vedere cosa succede.\n",
      "Posso inserire diversi blocchi **except** con istruzioni diverse in base ad errori diversi."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "val = \"pippo\"\n",
      "#prova anche\n",
      "#val = \"0\"\n",
      "try:\n",
      "    1/float(val)\n",
      "except (ValueError, ZeroDivisionError) as e:\n",
      "    print e"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "val = \"pippo\"\n",
      "#prova anche\n",
      "#val = \"0\"\n",
      "try:\n",
      "    1/float(val)\n",
      "except ValueError as e:\n",
      "    print \"non posso convertire la stringa\"\n",
      "except ZeroDivisionError as e:\n",
      "    print \"stai dividendo per zero\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Questa \u00e8 una pratica molto comune nel python al posto dei blocchi if-else.\n",
      "Si dice di solito **\u00e8 pi\u00f9 semplice chiedere il perdono che il permesso**.\n",
      "La sua esecuzione \u00e8 pi\u00f9 rapida, ed evita delle lunghissime liste di controllo dati.\n",
      "\n",
      "La struttura completa di un blocco try \u00e8 la seguente:\n",
      "\n",
      "    try:\n",
      "        codice che vorremmo eseguire\n",
      "    except tipi_di_eccezioni as nome_eccezione:\n",
      "        codice nel caso di fallimento\n",
      "    else:\n",
      "        codice da eseguire nel caso il codice fosse andato a buon fine\n",
      "    finally:\n",
      "        codice finale di pulizia delle risorse usate. viene eseguito sempre e comunque!"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Inseriamo quindi questa gestione delle eccezioni in una funzione che \n",
      "chiameremo per testare se il nostro numero \u00e8 convertibile.\n",
      "\n",
      "La scrittura di una funzione \u00e8 composta dal \n",
      "comando **def** seguito dal nome della funzione e dai suoi parametri, \n",
      "seguiti poi da un blocco di codice il cui comando return specifica\n",
      "cosa la funzione ritorni."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def somma(a, b):\n",
      "    return a + b\n",
      "\n",
      "print somma(2, 3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Nel nostro caso vogliamo che la funzione ritorni vero quando la nostra stringa \u00e8 convertibile in un float, \n",
      "falso se questo non fosse possibile. Dobbiamo quindi inserire il nostro try except dentro la funzione."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def isfloat(stringa):\n",
      "    try:\n",
      "        float(stringa)\n",
      "        return True\n",
      "    except ValueError:\n",
      "        return False\n",
      "\n",
      "isfloat('pippo')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Possiamo anche scrivere la nostra funzione in modo pi\u00f9 generico, nel caso volessimo decidere a posteriori se convertire\n",
      "in int, float o complex nel momento del lancio."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def isnumber(stringa, tipo=float):\n",
      "    try:\n",
      "        tipo(stringa)\n",
      "        return True\n",
      "    except ValueError:\n",
      "        return False\n",
      "\n",
      "print isnumber(\"3.14\")\n",
      "print isnumber(\"tre\")\n",
      "print isnumber(\"3\", int)\n",
      "print isnumber(\"3.12\", tipo=int)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Abbiamo inserito un secondo parametro, il tipo in cui vogliamo convertire, e lo abbiamo impostato di default nel tipo float.\n",
      "Quello che passiamo al secondo parametro \u00e8 **la funzione che useremo per la conversione**.\n",
      "\u00c8 infatti possibile passare le funzioni come argomento di una funzione come qualsiasi altro oggetto.\n",
      "\n",
      "La nostra operazione di ricezione dei dati diventa quindi la seguente, usando la funzione appena definita: "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "testo = \"1,2,3\"\n",
      "a, b, c = testo.split(',')\n",
      "print a, b, c"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "testo = 'a   1  e  24.5'\n",
      "print testo.split()\n",
      "print [ float(s) for s in testo.split() if isnumber(s) ]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Data una stringa di testo ora abbiamo una stringa di numeri.\n",
      "Questa nostra funzione divider\u00e0 in numeri indipendentemente dai caratteri di nuova riga o tabulazione, quindi\n",
      "possiamo prendere l'intero contenuto in numeri di un file di testo.\n",
      "\n",
      "###lettura da file di testo###\n",
      "\n",
      "Per leggere una riga di file di testo lo apriamo con la funzione **open** e lo leggiamo una riga alla volta con la funzione\n",
      "**readline**. La funzione **readlines** (con la s finale) ci permette di fare un ciclo su tutte le righe del file\n",
      "Per scrivere possiamo invece usare la funzione **write**."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "f = open(\"dimostrazione.data\",\"w\")\n",
      "f.write(\" 1 2 3 4 5 6 \\n 9 8 7 6 5 \\n 6 3 9 1 67 \")\n",
      "f.close()\n",
      "\n",
      "f = open(\"dimostrazione.data\",'r')\n",
      "for riga in f:\n",
      "    print riga\n",
      "f.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Una versione alternativa, pi\u00f9 *politicamente corretta* del codice qui sopra si ha usando il costrutto **with**, \n",
      "che si occupa da solo della gestione della chiusura del file anche in caso di errori di lettura.\n",
      "\n",
      "Utilizziamo anche la redirezione del print verso file, \n",
      "per mantenere una sintassi coerente con la scrittura che useremmo di solito."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "with open(\"dimostrazione.data\",\"w\") as f:\n",
      "    print >>f, \" 1 2 3 4 5 6 \"\n",
      "    print >>f, \" 9 8 7 6 5 \"\n",
      "    print >>f, \" 6 3 9 1 67 \"\n",
      "\n",
      "with open(\"dimostrazione.data\",'r') as f:\n",
      "    for riga in f:\n",
      "        print riga"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Possiamo ora trasformare ogni riga in una lista di numeri con la list comprehension che abbiamo scritto in precedenza:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "f = open(\"dimostrazione.data\",'r')\n",
      "for riga in f:\n",
      "    print [ float(s) for s in riga.split() if isnumber(s) ]\n",
      "f.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Vogliamo ora scrivere un sommario per ogni riga che ne stampi minimo, massimo e media.\n",
      "Per far questo creiamo una funzione che prenda una lista  e ci restituisca tutti i parametri di nostro interesse.\n",
      "Possiamo utilizzare a questo scopo le funzioni min, max e sum definite nella libreria standard.\n",
      "Potremmo farlo richiamando ogni volta tutte e tre le funzioni, ma sarebbe una palese \n",
      "violazione del principio DRY se dovessimo farlo anche solo due volte."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def sommario(sequenza):\n",
      "    return min(sequenza),max(sequenza),sum(sequenza)/len(sequenza)\n",
      "\n",
      "print sommario([6.0, 3.0, 9.0, 1.0, 67.0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "f = open(\"dimostrazione.data\",'r')\n",
      "for riga in f:\n",
      "    lista = [ float(s) for s in riga.split() if isnumber(s) ]\n",
      "    print sommario(lista)\n",
      "f.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "La nostra funzione restituisce molti valori contemporaneamente tramite un oggetto \n",
      "che assomiglia ad una lista, chiamato **tupla**.\n",
      "Una tupla \u00e8 una lista in cui ogni posizione ha un significato preciso (il primo elemento \u00e8 il minimo, il secondo \u00e8 il massimo\n",
      "ed il terzo \u00e8 la media) al contrario della lista in cui ogni posizione \u00e8 concettualmente\n",
      "identica e, una volta creata, non pu\u00f2 essere modificata. Le tuple ci permettono quindi di spostare *pacchetti di informazione*\n",
      "In giro per il nostro programma come un'entit\u00e0 unica.\n",
      "\n",
      "Esiste anche una classe **namedtuple** nel modulo standard **collections** che estende questa idea alla sua logica conclusione \n",
      "permettendo di assegnare dei nomi alle varie posizioni, creando sottoclassi specifiche con dei nomi assegnati alle posizioni"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from collections import namedtuple\n",
      "Sommario_tupla = namedtuple( 'Sommario', 'minimo massimo media')\n",
      "a = Sommario_tupla( 2, 4, 3 )\n",
      "a = Sommario_tupla( minimo=2, massimo=4, media=3 ) \n",
      "print a\n",
      "print a[0], a.minimo\n",
      "print a[1], a.massimo\n",
      "print a[2], a.media"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Ridefiniamo quindi la nostra funzione sommario con questa nuova struttura e eseguiamola su tutto il nostro file"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from collections import namedtuple\n",
      "Sommario_tupla = namedtuple( 'Sommario', 'minimo massimo media')\n",
      "\n",
      "def sommario(sequenza):\n",
      "    return Sommario_tupla(min(sequenza),max(sequenza),sum(sequenza)/len(sequenza))\n",
      "\n",
      "def isnumber(stringa, tipo=float):\n",
      "    try:\n",
      "        tipo(stringa)\n",
      "        return True\n",
      "    except ValueError:\n",
      "        return False\n",
      "\n",
      "f = open(\"dimostrazione.data\",'r')\n",
      "for riga in f:\n",
      "    print sommario ( [ float(s) for s in riga.split() if isnumber(s) ])\n",
      "f.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ClasseComplessa = namedtuple(\"complessa\",\"a b c\")\n",
      "prova = ClasseComplessa(1,'a',[1,2,3])\n",
      "prova.c[0]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## istogrammi e dizionari##\n",
      "\n",
      "Ora non vogliamo pi\u00f9 fare delle statistiche sommarie dei nostri dati, ma vogliamo invece farne l'istogramma, ovvero contare\n",
      "quante volte osserviamo ciascun valore.\n",
      "\n",
      "Per fare questo useremo una struttare dati chiamata **dizionario**, che concettualmente \u00e8 una lista di valori i cui indici non\n",
      "sono dati da un numero ma da un qualsiasi oggetto (con delle limitazioni che vedremo dopo).\n",
      "\n",
      "Vediamo come sarebbe fatto un semplice dizionario per contenere gli indirizi di alcune persone"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dizionario_vuoto = dict()\n",
      "dizionario_vuoto = {}\n",
      "\n",
      "indirizzi = dict()\n",
      "indirizzi['francesco'] = \"via brecce bianche 50\"\n",
      "indirizzi['michele'] = \"via beccaria 3\"\n",
      "indirizzi['antonella'] = \"piazza europa 2\"\n",
      "\n",
      "print indirizzi"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print indirizzi.keys()\n",
      "print indirizzi.values()\n",
      "print indirizzi.items()\n",
      "\n",
      "print indirizzi[\"antonella\"]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for k, v in indirizzi.iteritems():\n",
      "    print k, v"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\u00e9 possibile fare delle iterazioni anche sui dizionari: l'iterazione corrisponde al valore delle chiavi e \n",
      "non del contenuto (come sarebbe per liste e tuple)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in indirizzi:\n",
      "    print i"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in indirizzi:\n",
      "    print i, indirizzi[i]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Per accedere a chiavi ed elementi contemporaneamente tramite un iteratore (molto utile nel caso di dizionari molto grandi, parleremo meglio degli iteratori in seguito) potete usare la funzione **iteritems**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "for k, v in indirizzi.iteritems():\n",
      "    print k, v"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "matrice = dict()\n",
      "matrice[(1,2)] = 0\n",
      "matrice[(3,4)] = 1\n",
      "matrice[(6,9)] = 2\n",
      "\n",
      "print matrice"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Come potete vedere le chiavi non sono in ordine alfabetico, ma in un ordine misto. \n",
      "Questo dipende da come \u00e8 fatto dentro un dizionario.\n",
      "nel caso fosse necessario avere le chiavi ordinate \u00e8 possibile utilizzare il metodo **sorted**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in sorted(indirizzi):\n",
      "    print i"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Questa funzione mette in ordine anche le tuple, ordinandole in base al primo elemento, poi al secondo in caso di parit\u00e0 e cos\u00ec\n",
      "via.\n",
      "\u00c8 possibile anche avere le coppie chiave valore ordinate per valore invece che per chiave, \n",
      "usando il parametro *key* della funzione *sorted*, che specifica una funzione sulla base della quale ordinare.\n",
      "Per definire questa funzione useremo una funzione **lambda**, che permette di definire funzioni al volo senza assegnargli\n",
      "un nome, e serve per evenienze come questa in cui pensiamo di usare la funzione una sola volta.\n",
      "\n",
      "La useremo per specificare che deve usare solo il secondo valore della tupla per ordinare."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in sorted(indirizzi.items(), key=lambda item: item[1]):\n",
      "    print i"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "una versione pi\u00f9 raffinata si pu\u00f2 scrivere con la funzione **itemgetter** del modulo *operator*,che \u00e8 una versione pi\u00f9 raffinata\n",
      "della funzione *lambda* che abbiamo appena scritto. Permette di specificare a quali elementi della tupla dare la priorit\u00e0 per\n",
      "l'ordinamento"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from operator import itemgetter\n",
      "for i in sorted(indirizzi.items(), key=itemgetter(1,0)):\n",
      "    print i"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Creiamo ora i nostri dati con l'uso della funzione **randint** del modulo standard **random**, che genera una certa quantit\u00e0 di numeri interi compresi fra due numeri assegnati. \n",
      "\n",
      "Per generare questi numeri random usiamo la funzione **xrange** invece di range. ha la stessa funzione ma evita la creazione di liste temporanee,evitando spreco di memoria (approfondiremo in seguito nella sezione sugli iteratori)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from random import randint\n",
      "print randint(1,6)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dati = [ randint(1,6) for i in xrange(20) ]\n",
      "print dati"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Quello che andremo a fare \u00e8 sommare 1 ad ogni occorrenza del numero che compare.\n",
      "Dobbiamo per\u00f2 verificare che quella chiave sia gi\u00e0 presente, o otterremo un'eccezione di tipo\n",
      "KeyError.\n",
      "Abbiamo due possibilit\u00e0 a questo proposito: usare un if e testare se la chiave \u00e8 presente o provarci comunque ed in\n",
      "caso di errore inizializzare il valore esplicitamente."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dati = [ randint(1,6) for i in xrange(30) ]\n",
      "contatore_1 = dict()\n",
      "for n in dati:\n",
      "    if n in contatore_1:\n",
      "        contatore_1[n]+=1\n",
      "    else:\n",
      "        contatore_1[n]=1\n",
      "\n",
      "contatore_2 = dict()\n",
      "for n in dati:\n",
      "    try:\n",
      "        contatore_2[n]+=1\n",
      "    except KeyError:\n",
      "        contatore_2[n]=1\n",
      "\n",
      "print contatore_1\n",
      "print contatore_2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Questo problema pu\u00f2 essere ovviato se abbiamo una stima di quali siano tutti i possibili elementi che ci aspettiamo di incontrare e preinizializzare il dizionario. Questo permette di risparmiare controlli ed in caso di input non previsti o non accettabili restituisce automaticamente un errore, ma ovviamente \u00e8 applicabile solo ad un set limitato di casi. \n",
      "\n",
      "Ne approfittiamo per mostrare anche la possibilit\u00e0 di creare un dizionario in maniera simile alla list comprehension, detta **dictionary comprehension**, in cui si specifica sia la chiave che il valore da assegnare"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "contatore_3 = { n:0 for n in xrange(1,7) }\n",
      "\n",
      "for d in dati:\n",
      "    contatore_3[d] += 1\n",
      "print contatore_3"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Un quarto metodo passa per l'uso della funzione **get**, che permette di specificare un valore di default nel caso la chiave specificata non esista."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "contatore_4 = {}\n",
      "for d in dati:\n",
      "    contatore_4[d] = contatore_4.get(d, 0)+1\n",
      "print contatore_4"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "L'utilizzo dei dizionari per contare le occorrenze di oggetti \u00e8 tanto comune che esiste una classe apposta \n",
      "nella libreria standard **collections** chiamata **Counter** che effettua proprio questo lavoro"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from collections import Counter\n",
      "from random import randint as dado\n",
      "a = Counter( dado(1, 6) for i in xrange(10) )\n",
      "print a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a.update( dado(1, 6) for i in xrange(10) )\n",
      "print a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b = Counter( dado(1, 6) for i in xrange(10) )\n",
      "print a+b\n",
      "print a-b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "c = Counter()\n",
      "c.update( {1:0.3, 4:0.5, 2:4} )\n",
      "print c"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## I set\n",
      "\n",
      "Oltre alle liste ed ai dizionari esiste un terzo tipo di contenitore predefinito nel python, e sono i **set**, usati per descrivere degli insieme di oggetti senza possibili ripetizioni, di cui si occupa lui in automatico.\n",
      "\n",
      "I set vengono utilizzati per trovare gli oggetti unici in una lista (rimuovendo i doppioni), o per trovare gli elementi in comune fra due liste."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "insieme = set()\n",
      "insieme.add(1)\n",
      "print insieme"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "set([1, 2, 3, 4, 5, 1, 2, 3])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "I set supportano le funzioni base degli insieme, ovvero unioni, intersezioni e differenze"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "minori_10 = set(range(10))\n",
      "quadrati_20 = set([ x**2 for x in xrange(20)])\n",
      "\n",
      "#con l'or unisco i due insiemi\n",
      "print minori_10 | quadrati_20\n",
      "# con l'and ne faccio l'intersezione\n",
      "print minori_10 & quadrati_20\n",
      "#con il meno ne faccio la differenza\n",
      "print quadrati_20 - minori_10"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Un uso comune dei set \u00e8 per generare la sottolista degli elementi unici di una lista, rimuovendo tutti i doppioni"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "base = [1, 1, 2, 2, 3]\n",
      "list(set(base))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##Iteratori e generatori##\n",
      "\n",
      "Abbiamo ottenuto finora un programma di 16 righe che legge un file e scrive un sommario dei dati contenuti in esso\n",
      "riga per riga.\n",
      "\n",
      "Ora desideriamo che questo sommario sua fatto su *tutto* il file, senza dividerlo per righe.\n",
      "\n",
      "Per fare questo possiamo combinare insieme tutte le liste generate da ogni riga in una lista di liste, per poi unirle\n",
      "in qualche modo in una lista unica da esaminare con la funzione *sommario*\n",
      "\n",
      "Una maniera abbastanza semplice di compiere questa operazione \u00e8 usare un **generatore**\n",
      "Un generatore \u00e8 una speciale funzione che non ritorna una volta sola, ma pu\u00f2 farlo molteplici volte tramite il comando yield\n",
      "invece del classico return.\n",
      "\n",
      "Una volta creato il generatore, si possono vedere i risultati successivi con la funzione **next**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def contaLettere(n=10):\n",
      "    lettere = \"abcdefghijklmnopqrstuvwxyz\"\n",
      "    for i in range(n):\n",
      "        yield lettere[i]\n",
      "\n",
      "\n",
      "generatore = contaLettere(3)\n",
      "print generatore\n",
      "print generatore.next()\n",
      "print generatore.next()\n",
      "print generatore.next()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Il grande vantaggio che mi danno i generatori \u00e8 che li posso usare dentro un ciclo come se fossero liste.\n",
      "Nel fare questo per\u00f2 non devo costruire da nessuna parte la lista, tanto che posso creare anche dei generatori\n",
      "potenzialmente infiniti"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "generatore = contaLettere(5)\n",
      "for i in generatore:\n",
      "    print i,\n",
      "    \n",
      "for i in contaLettere(10):\n",
      "    print i,"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "I generatori sono per\u00f2 ad uso singolo. Se ho gi\u00e0 utilizzato un generatore in un ciclo precedente, non posso\n",
      "pi\u00f9 utilizzarlo, devo crearne uno nuovo."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "generatore = contaLettere(5)\n",
      "print \"ciclo 1:\"\n",
      "for i in generatore:\n",
      "    print i,\n",
      "\n",
      "print \"ciclo 2:\"\n",
      "for i in generatore:\n",
      "    print i,"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Il generatore che voglio scrivere quindi andr\u00e0 a leggere una lista di liste (gli insiemi di numeri letti \n",
      "per ogni riga) ed un elemento alla volta me li restituisce tutti"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = [ [1,2], [3,4], [5,6], [7,8]]\n",
      "for i in a:\n",
      "    print i\n",
      "\n",
      "def unisci(a):\n",
      "    for lista in a:\n",
      "        for elemento in lista:\n",
      "            yield elemento\n",
      "\n",
      "for i in unisci(a):\n",
      "    print i\n",
      "\n",
      "complessivo = list(unisci(a))\n",
      "print complessivo"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "I generatori sono uno strumento potentissimo, e ci permettono di scrivere in modo semplice codice che altrimenti risulterebbe\n",
      "molto complesso.\n",
      "\n",
      "Il nostro programma pu\u00f2 essere scritto in questo modo:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from collections import namedtuple\n",
      "Sommario_tupla = namedtuple( 'Sommario', 'minimo massimo media')\n",
      "\n",
      "def sommario(sequenza):\n",
      "    return Sommario_tupla(min(sequenza),max(sequenza),sum(sequenza)/len(sequenza))\n",
      "\n",
      "def unisci(a):\n",
      "    for lista in a:\n",
      "        for elemento in lista:\n",
      "            yield elemento\n",
      "\n",
      "f = open(\"dimostrazione.data\",'r')\n",
      "lista_totale = []\n",
      "for riga in f:\n",
      "    lista_totale.append( [ float(s) for s in riga.split() if isnumber(s) ])\n",
      "print lista_totale"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "lista_ridotta=list()\n",
      "for i in unisci(lista_totale):\n",
      "    lista_ridotta.append(i)\n",
      "#esattamente uguale\n",
      "lista_ridotta=list( unisci(lista_totale) )\n",
      "print lista_ridotta\n",
      "print \n",
      "print sommario(lista_ridotta)    \n",
      "f.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Il nostra programma ora funziona discretamente, ma ha un grosso difetto: accumula tutti i dati che riceviamo prima di usarli.\n",
      "\n",
      "Questo significa che per file molto grandi, salvare tutti i dati che riceviamo comporta un grande spreco di memoria.\n",
      "\n",
      "Sfruttando in maniera furba i generatori potremmo evitare questo problema. Possiamo infatti scrivere una serie di generatori\n",
      "che restituiscono i loro valori (senza salvarli da nessuna parte) e passarli ad altri generatori in una cascata di analisi dati."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Per fare questo dobbiamo per\u00f2 scriversi una nostra versione delle funzioni min, max e media.\n",
      "\n",
      "Quelle fornite di base da python andrebbero benissimo, ma nel mezzo che usiamo per questa dimostrazione una scelta tecnica\n",
      "(a mio parare poco felice) ci impedisce di portare a termine il nostro lavoro.\n",
      "\n",
      "Come possiamo quindi scriverci queste nostre funzioni? Per prima cosa, grazie alle tuple, non \u00e8 necessario\n",
      "scrivere tre funzioni distinte che quindi esaminino i dati per tre volte di fila,ma \u00e8 sufficiente una sola funzione\n",
      "che lo faccia una volta sola.\n",
      "\n",
      "Possiamo quindi calcolare minimo e massimo con dei semplici confronti progressivi, mentre una somma progressiva ci dar\u00e0\n",
      "poi il valore della media, contanto il numero di elementi osservati."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def sommario(valori):\n",
      "    minimo = massimo = None\n",
      "    totale = 0.\n",
      "    N = 0\n",
      "    for val in valori:\n",
      "        totale += val\n",
      "        massimo = val if ( massimo is None or val>=massimo) else massimo\n",
      "        minimo = val if ( minimo is None or val<=minimo) else minimo\n",
      "        N+=1\n",
      "    return Sommario_tupla( minimo = minimo, massimo = massimo, media = totale/N )\n",
      "\n",
      "print sommario(range(11))\n",
      "#xrange \u00e8 un generatore fino al numero dato\n",
      "print sommario(xrange(11))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Scriviamo ora il nostro programma in una maniera pi\u00f9 furba usando i **generator comprehension** che, \n",
      "come il nome pu\u00f2 far intuire, sono identici alle list comprehension ma ritornano un generatore \n",
      "su cui effettuare un ciclo invece che una lista.\n",
      "\n",
      "La particolarit\u00e0 di questi generatori \u00e8 che i valori non vengono letti (o generati) finch\u00e8 l'iterazione non viene svolta e vengono\n",
      "generati solo gli elementi effettivamente usati, risparmiando una gran quantit\u00e0 di memoria ed operazioni :).\n",
      "\n",
      "Per unire gli elementi poi non utilizzeremo il generatore scritto da noi ma uno preesistente nella \n",
      "libreria **itertools**, chiamato **chain**, di cui richiameremo la funzione **from_iterable**, che \u00e8 sostanzialemente\n",
      "identica al generatore scritto da noi."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = xrange(11) \n",
      "print a\n",
      "\n",
      "generatore = ( i**2 for i in a )\n",
      "print generatore\n",
      "for num in generatore:\n",
      "    print num"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from collections import namedtuple\n",
      "\n",
      "Sommario = namedtuple( 'Sommario', 'minimo massimo media')\n",
      "\n",
      "def sommario(valori):\n",
      "    minimo = massimo = None\n",
      "    media = 0.\n",
      "    N = 0\n",
      "    for val in valori:\n",
      "        media += val\n",
      "        massimo = val if val>massimo else massimo\n",
      "        minimo = val if ( minimo is None or val<None) else minimo\n",
      "        N+=1\n",
      "    return Sommario( minimo = minimo, massimo = massimo, media = media/N )\n",
      "\n",
      "f = open(\"dimostrazione.data\",'r')\n",
      "#prendo ogni linea e la divido nei suoi pezzi\n",
      "#ottengo un iteratore che restituisce delle liste\n",
      "linee = ( linea.split() for linea in f )\n",
      "#con la funzione chain le unisco in un unico iteratore che mi d\u00e0 i valori uno alla volta\n",
      "dati_testo = unisci( linee )\n",
      "#trasformo tutti questi in numeri\n",
      "#posso saltare il controllo perch\u00e8 s\u00f2 che sono solo dati numerici\n",
      "numeri = ( float(s) for s in dati_testo)\n",
      "#d\u00f2 il mio iteratore in pasto alla funzione che scrive il sommario\n",
      "print sommario(numeri)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Con poche righe in pi\u00f9 otteniamo quindi un programma che possa lavorare con un file \n",
      "di dimensioni qualsiasi senza alcun problema.\n",
      "\n",
      "Con solo un paio di generatori in pi\u00f9 possiamo scriverne uno che legga tutti i file di un certo tipo dentro una cartella\n",
      "e ne combini insieme il risultato.\n",
      "\n",
      "Per fare questo dobbiamo interagire con il sistema operativo, e questo si f\u00e0 tramite il modulo standard **os**.\n",
      "\n",
      "Per ottenere la lista di tutti i file nella directory di lavoro (in questo caso la cartella home del mio computer)\n",
      "si pu\u00f2 utilizzare la funzione **listdir**, mentre per filtrare solo i file che interessano si pu\u00f2 impostare un filtro\n",
      "basato sulla funzione **filter** del modulo **fnmatch**, che fornisce delle funzionalit\u00e0 basilari di pattern matching."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import os\n",
      "for f in os.listdir('.'):\n",
      "    print f"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import fnmatch as fm\n",
      "print fm.fnmatch(\"testo.txt\",'*.txt')\n",
      "print fm.fnmatch(\"dati.dat\",'*.txt')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import os\n",
      "import fnmatch as fm\n",
      "\n",
      "file_testo = ( testo for testo in os.listdir('.') if fm.fnmatch(testo,'*.txt') )\n",
      "for i in file_testo:\n",
      "    print i"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "La funzione **os.walk** \u00e8 una versione potenziata di listdir, che data una cartella la esplora e poi ripete per tutte\n",
      "le sue sottocartelle, e di ciascuna ritorna il path, le sottocartelle ed i file contenuti."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "ottenuti = ( testo for testo in os.walk('./dimostrazione/'))\n",
      "for i in ottenuti:\n",
      "    print i"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "ottenuti = ( testo for testo in os.walk('./dimostrazione/'))\n",
      "for path,dirlist,files in ottenuti:\n",
      "    print files"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Quando si lavora con i file pu\u00f2 venire spontaneo unire il percorso con la semplice somma fra stringhe.\n",
      "Questo pu\u00f2 per\u00f2 creare dei problemi perch\u00e8 i sistemi windows non usano lo stesso carattere per indicare le \n",
      "cartelle (lo slash / ) e quindi se si portasse il programma in sistemi diversi si potrebbero avere degli errori.\n",
      "\n",
      "Per evitare questo si pu\u00f2 usare la funzione os.path.join, che fonde un file con il suo path in modo coerente con quello\n",
      "usato dal sistema operativo.\n",
      "\n",
      "Nel mio caso, lavorando sotto linux, il risultato \u00e8 identico, ma pensare in modo indipendente dal sistema\n",
      "operativo \u00e8 una di quelle abitudini che \u00e8 smepre meglio prendere fin da subito."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "path = './dimostrazione/'\n",
      "testo = 'log.txt'\n",
      "\n",
      "#PERICOLOSO\n",
      "percorso = path + testo\n",
      "print percorso\n",
      "\n",
      "#SICURO\n",
      "percorso = os.path.join(path, testo)\n",
      "print percorso"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Una versione pi\u00f9 elaborata della lineaa qui sopra, che sfrutta principi che abbiamo gi\u00e0 visto, \n",
      "estrae tutte le linee da tutti i file di un certo tipo all'interno di \n",
      "un albero di directory che vengono esplorate completamente.\n",
      "\n",
      "* **os.walk** esplora tutte le sottodirectory a partire da una directory data, e per ciascuna ritorna una lista di file\n",
      "* questa lista di file viene trasformata in una lista di tuple (direcotry file)\n",
      "* queste liste vengono poi fuse insieme con il *chain.from_iterable*\n",
      "* se il file rispetta il criterio dato (in questo caso essere un file di testo) viene creato il percorso completo\n",
      "al file con la funzione **os.path.join** che crea un percorso appropriato al sistema operativo in uso\n",
      "* questi file vengono aperti in lettura e su ciascuno \u00e8 richiamato il metodo *readlines* per ottenere il generatore\n",
      "delle linee\n",
      "* queste linee vengono a loro volta accorpate con una seconda chiamata di *chain.from_iterable*"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import os\n",
      "import itertools as it\n",
      "import fnmatch as fm\n",
      "base = \"./dimostrazione/\"\n",
      "filtro = \"*.txt\"\n",
      "liste_file = (  zip(it.repeat(path),filelist) for  path, dirlist, filelist in os.walk(base) )\n",
      "#for i in liste_file: print i"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "singoli_file_tuple = it.chain.from_iterable( liste_file )\n",
      "singoli_file = (os.path.join(path,name) for path,name in singoli_file_tuple \n",
      "                    if fm.fnmatch(name,filtro)  )\n",
      "#for i in singoli_file: print i"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "iters_linee = ( open(testo).readlines() for testo in singoli_file )\n",
      "linee_fuse = it.chain.from_iterable( iters_linee )\n",
      "#for i in linee_fuse: print i"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\u00c8 importante ricordare sempre, quando si usano i generatori, che sono oggetti di uso singolo: una volta che lo avete\n",
      "consumato per fare un conto, non potrete passarlo in un ciclo per stamparne i valori.\n",
      "\n",
      "Questo \u00e8 causa di molti errori le prime volte che si usano i generatori.\n",
      "Esiste la possibilit\u00e0 di clonarli usando la funzione **tee** del modulo itertools, ma non la consiglio perch\u00e8 spreca buona parte\n",
      "del vantaggio di usare i generatori in quanto f\u00e0 una cache dei valori osservati."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "a = ( x for x in xrange(10) )\n",
      "b = list(a)\n",
      "for i in a:\n",
      "    print i"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "se la vostra necessit\u00e0 \u00e8 solo stamparne i risultati lungo la catena di elaborazione, un workaround \u00e8 definire una funzione\n",
      "che stampa il valore e poi lo restuituisce inalterato."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "def echo(x):\n",
      "    print x\n",
      "    return x\n",
      "\n",
      "a = ( echo(x) or x for x in xrange(10) )\n",
      "b = list(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "----"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Prendiamo ora come esempio il seguente problema:\n",
      "\n",
      "Ho un insieme di file di testo contenente informazioni su di una \n",
      "distribuzione tridimensionale sparsa (come la densit\u00e0 di probabilit\u00e0 nello spazio, la densit\u00e0 di molecole in una sostanza\n",
      "o la dose depositata su di un oggetto in seguito ad irradiazione).\n",
      "\n",
      "Vogliamo valutare la quantit\u00e0 totale sommando il valore sui \n",
      "singoli pixel derivanti dalle varie distribuzioni nei singoli file.\n",
      "\n",
      "Iniziamo quindi come in precedenza leggendo in ordine tutte le righe, trasformandole poi in un dizionario da usare con \n",
      "i nostro Counter. Per fare questo possiamo sfruttare un equivalente della list comprehension applicata ai dizionari, in cui \n",
      "costruiamo sia la chiave che il valore, compreso fra parentesi graffe invece che quadrate."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import os\n",
      "import itertools as it\n",
      "import fnmatch as fm\n",
      "from collections import Counter\n",
      "base = \"./dimostrazione/\"\n",
      "filtro = \"*.dose\"\n",
      "liste_file = (it.izip(it.repeat(path),filelist) for  path, dirlist, filelist in os.walk(base))\n",
      "singoli_file_tuple = it.chain.from_iterable( liste_file )\n",
      "singoli_file = (os.path.join(path,name) for path,name in singoli_file_tuple \n",
      "                    if fm.fnmatch(name,filtro)  )\n",
      "iters_linee = ( open(testo).readlines() for testo in singoli_file )\n",
      "linee_fuse = it.chain.from_iterable( iters_linee )\n",
      "\n",
      "indici_str= ( linea.split() for linea in linee_fuse )\n",
      "indici = ( (int(x),int(y),int(z),float(v)) for x,y,z,v in indici_str )\n",
      "a = Counter()\n",
      "for x,y,z,v in indici:\n",
      "    a[(x,y,z)]+=v\n",
      "print a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##Una digressione in filosofia##\n",
      "Se il mio unico interesse fosse stato ridurre il numero di linee di codice avrei potuto riunire molti dei generatori\n",
      "che ho scritto separatamente nel programma sovrastante in un unico generatore.\n",
      "\n",
      "Per\u00f2, come potete vedere nello spazio sottostante, l'effetto sulla comprensibilit\u00e0 del codice \u00e8 devastante.\n",
      "Senza rifletterci bene neppure io che ho scritto questa riga (divisa su pi\u00f9 righe solo per farla entrare in schermo)\n",
      "riuscirei a capirne il funzionamento se non dopo attente riflessioni."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import os\n",
      "import itertools as it\n",
      "import fnmatch as fm\n",
      "from collections import Counter\n",
      "base = \"./dimostrazione/\"\n",
      "filtro = \"*.dose\"\n",
      "indici_str = ( linee.split() for  path, dirlist, filelist in os.walk(base) \n",
      "              for nome in it.izip(it.repeat(path),filelist) if fm.fnmatch(nome[1],filtro)\n",
      "              for linee in open(os.path.join(*nome)).readlines())\n",
      "for nome in indici_str:\n",
      "    print nome"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Dal punto di vista di esecuzione \u00e8 **perfettamente** equivalente a quanto scritto in precedenza, ma non serve essere esperti\n",
      "programmatori per rendersi conto che questa seconda versione \u00e8 meno gestibile.\n",
      "\n",
      "Questo diventa un limite enorme per un programma su cui dovremo mettere le mani pi\u00f9 di una volta: per citare\n",
      "uno dei grandi della programmazione, Brian Kernighan:\n",
      "\n",
      ">**Tutti sanno che fare debugging \u00e8 due volte pi\u00f9 difficile che scrivere un programma. \n",
      "Se quindi scrivi un programma pi\u00f9 astutamente che puoi, come pensi di riuscire mai a farne il debug?**\n",
      "\n",
      "Una buona linea guida quando si programma \u00e8 usare la filosofia DRY KISS:\n",
      "\n",
      "* **Don't Repeat Yourself**: non reinventare la ruota, non scrivere pi\u00f9 volte codice che faccia la stessa cosa, \n",
      "non usare valori hardcoded, creare classi e funzioni che si occupino di svolgere i compiti ripetuti.\n",
      "* **Keep It Simple, Stupid!**: non complicarti la vita, scrivi il codice che ti serve e che sai funzionare,\n",
      "non cercare di scrivere codice che possa fare qualsiasi cosa o che richieda spiegazioni controintuitive (morte\n",
      "ai casi speciali!), riduci al minimo il numero di oggetti, classi e funzioni in circolazion.\n",
      "\n",
      "Questi due principi, anche se molto basilari, permettono gi\u00e0 di scrivere un codice che sia dignitoso \n",
      "sia in scrittura che in fase di mantenimento.\n",
      "\n",
      "Il *bonton* della programmazione \u00e8 alla base dell'intera scrittura di python, e pu\u00f2 essere letto ogni volta che volete\n",
      "scrivendo la seguente linea di codice:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "import this"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "L'ultima nota che vorrei fare \u00e8 a proposito delle prestazioni del python, senza entrare nel merito delle librerie \n",
      "di calcolo scientifico, che risolvono moltissimo questo problema.\n",
      "\n",
      "Diciamolo chiaramente:\n",
      "\n",
      "###l'esecuzione di codice python \u00e8 molto pi\u00f9 lenta di quella del codice C\n",
      "\n",
      "Questo \u00e8 un dato di fatto,ma \u00e8 solo una faccia del problema.\n",
      "Dovete pensare che il tempo reale di esecuzione di un programma non \u00e8tra quando lanciate il programma ed ottenete i risultati,\n",
      "ma fra quando **iniziate a lavorarci** fintanto che non otteniate dei **risultati corretti**.\n",
      "\n",
      "Per ottenere dei risultati corretti in fretta, prima ancora che un codice che viene eseguito velocemente, vi serve un codice\n",
      "che sia rapido da scrivere e che sia molto semplice da controllare e debuggare.In questo campo il Python vince sul C\n",
      "di ordini di grandezza.\n",
      "\n",
      "ricordate quanto detto da Donald Knuth (creatore del TeX e di buona parte dell'informatica teorica):\n",
      "\n",
      "###L'ottimizzazione prematura \u00e8 fonte di ogni male\n",
      "\n",
      "preoccuparsi di avere il codice pi\u00f9 veloce di un paio di secondi quando ancora non si \u00e8 scritto neppure una linea di codice\n",
      "mi sembra l'estremo dell'ottimizazione prematura.\n",
      "\n",
      "#Con questo si conclude la lezione sul linguaggio python. A seguire una lezione sulle librerie di calcolo scientifico"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "#questo snippet mi permette di usare una visualizzazione pi\u00f9 carina\n",
      "from IPython.core.display import HTML\n",
      "def css_styling():\n",
      "    styles = open(\"./styles/custom.css\", \"r\").read()\n",
      "    return HTML(styles)\n",
      "css_styling()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}