Lezione 1a - Introduzione a Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduzione a Python\n",
    "\n",
    "https://www.python.org\n",
    "\n",
    "Potete trovare questa lezione (ed altre) sul mio sito github:\n",
    "\n",
    "https://github.com/EnricoGiampieri/lezionipython\n",
    "\n",
    "un ottimo tutorial online lo potete trovare alla pagina:\n",
    "\n",
    "http://www.scipy-lectures.org/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Il Python è un linguaggio interpretato di alto livello.\n",
    "\n",
    "Questa è una maniera complicata per dire che evita moltissimi dei dolori della programmazione classica: il fatto che sia interpretato significa che non sono necessari step di compilazione, rendendo più semplice il ciclo sviluppo - esecuzione - correzione\n",
    "\n",
    "Python ha come principale linea guida il concetto di **leggibilità**, cercando il più possibile di rendere semplice agli sviluppatori scrivere librerie semplici ed intuitive.\n",
    "\n",
    "Questo permette di utilizzare soltanto python per sviluppare i prototipi del codice fino ad arrivare al codice di produzione, semplificando e velocizzando l'intero processo che parte dall'idea che si vuole implementare fino ad ottenere il risultato finale."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Python supporta di base tutte le operazioni matematiche più comuni, compreso il supporto per la matematica complessa, e tutti i costrutti più comuni di programmazione (e molti altri) come:\n",
    "\n",
    "- if, elif, else\n",
    "- cicli for e while\n",
    "- definizione di funzioni e classi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Permette inoltre di programmare con molti approcci diversi:\n",
    "- procedurale\n",
    "- ad oggetti\n",
    "- funzionale\n",
    "- vettoriale\n",
    "\n",
    "Faremo una breve introduzione alla programmazione in pyhton, senza entrare nel dettaglio delle caratteristiche del linguaggio, introducendo quindi solo una parte delle possibilità offerte da questo linguaggio e dalle sue librerie.\n",
    "\n",
    "Conoscere un minimo di python e delle sue librerie di calcolo numerico ci permetterà di toccare con mano molti dei problemi che affronteremo lungo il corso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "----\n",
    "## Utilizzare Python\n",
    "\n",
    "Esistono molti modi diversi di lavorare tramite Python.\n",
    "\n",
    "Il fondamentale è tramite la shell di python, un terminale che esegue le righe di comando mano a mano che vengono inserite, ed è estremamente utile per testare il codice al volo prima di inserirlo dentro un programma. Il terminale di python si può lanciare da terminale digitando **python**.\n",
    "\n",
    "    >>> Dimostrazione"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Il secondo metodo è scrivere uno (o più) script contenente i comandi che si vogliono eseguire, e farlo eseguire da python come un programma qualsiasi tramite il comando \n",
    "\n",
    "**python nomedelfile.py**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Le cose più interessanti di trovano però andando a cercare fra i vari programmi disponibili.\n",
    "\n",
    "Uno degli editor più famosi per il calcolo scientifico in python è **Spyder** (http://code.google.com/p/spyderlib/), che fornisce un'interfaccia molto simile a quella di Matlab. È unprogramma molto solido e funzionale, ed è un'ottima piattaforma su cui lavorare.\n",
    "\n",
    "Un'altro approccio è l'utilizzo di un IDE (Integrated Development Environment) completo, quale PyCharm, Wing o Eclipse. Il mio personale preferito, molto più semplice ma con tutte le funzioni che mi servono è **Atom** (https://ide.atom.io/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Fra tutti lo strumento però in assoluto più potente è sicuramente **IPython** (http://ipython.org/). IPython fornisce tre programmi:\n",
    "\n",
    "- la IPython shell, che è descrivibile come un terminale python sotto steroidi, che può tranquillamente sostituire la shell di sistema\n",
    "- La QTConsole, che contiene un ibrido fra una shell ed un sistema di gestione tramite GUI, e permette l'utilizzo dei grafici inline invece che in finestre separate.\n",
    "- Il Notebook, ovvero quello che stò usando in questo momento, che è un'interfaccia web ad un serve di esecuzione che permette di mescolare testo, codice, grafica e formule in un unico insieme. In particolare quello che stò usando in questo momento è la versione **3.6** di IPython"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "----\n",
    "## Procurarsi python\n",
    "\n",
    "Python arriva di base installato con un gran numero di librerie sia sotto linux che sotto macOSX, mentre invece và installato da zero su windows.\n",
    "\n",
    "Installare nuove librerie è molto semplice sfruttando il programma **pip**, che permette di dire a python quale libreria si desidera e lui la scaricherà ed installerà sul sistema. Il programma è a riga di comando e quasi tutte le librerie numeriche richiedono però la presenza di un compilatore, quindi potrebbe non essere comodo per chi non è abituato a lavorare da terminale."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Una comoda alternativa sono le librerie all-inclusive. Queste sono normalmente a pagamento, ma arrivano con python e tantissime librerie preinstallate e configurate per il sistema in uso. Fra le principali ci sono:\n",
    "\n",
    "- **Enthought Python Distribution**, probabilmente la più rodata, è disponibile per tutti i sistemi ed offre una versione gratuita per chi fà parte dell'università \n",
    "- **Anaconda**, concorrente moderno della EPD, è gratuita e forse la migliore disponibile al momento\n",
    "- **Python(x, y)**, gratuito e ben testato, ma purtroppo presente solo per windows\n",
    "- **Sage**, completamente gratuito, che comprende oltre a python anche un gran numero di programmi per la matematica accessibili da tramite python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- **Wakari**, un sito che offre un ambiente di sviluppo integrato sul browser. Molto completo ma richiede la connessione internet non installando nulla sul pc.\n",
    "- In modo simile il sito **pythonanywhere** fornisce un servizio gratuito per provare una shell di python online.\n",
    "- Il servizio **PiCloud**, che fornisce accesso a una rete di supercomputer amazon, fornisce anche la possibilità di lavorare online con dei notebook che girano sui loro server."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "----\n",
    "## Basi del linguaggio\n",
    "\n",
    "Vediamo subito il primo programma di default, Hello World:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Ok, questo era facile. Possiamo usare la funzione print per stampare (quasi) qualsiasi cosa:intanto lo usiamo per vedere i risultati di alcune operazioni matematiche"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "(-7+22j)\n",
      "256\n"
     ]
    }
   ],
   "source": [
    "print(1)\n",
    "print(1 + 2)\n",
    "print((4 + 5j) * (2 + 3j))\n",
    "print(4 ** 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Nelle vecchie versioni di Python (2.7 o inferiori) la divisione fra numeri interi restituiva un intero (come in C). Nella nuova versione (python 3, quello che utilizzeremo per queste lezioni) questo comportamento è stato modificato, ed ora la divisione fra numeri restituisce il valore decimale come ci si attenderebbe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6666666666666666"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 / 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Per avere la divisione intera si utilizza un operatore specifico, usando il doppio segno di divisione."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 // 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Per ottenere le stesso comportamento nelle vecchie versioni si può utilizzare il comando:\n",
    "\n",
    "    from __future__ import division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from __future__ import division, print_function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Per utilizzare funzioni matematiche più avanzate abbiamo bisogno di utilizzare una delle librerie che arrivano con python, la libreria **math**, che ci mette a disposizione una lunga lista di funzioni. per utilizzare math basta scrivere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Ed ora abbiamo accesso a tutte le funzioni necessarie. Se avessimo bisogno di lavorare con i numeri complessi, esiste una libreria gemella chiamata **cmath**.\n",
    "\n",
    "Per avere più informazioni sulla libreria che andiamo ad usare possiamo utilizzare due comandi molto utili, **dir** per sapere quali siano le sue funzioni, ed **help** per averne una descrizione. Visto che il risultato di **help(math)** è piuttosto lungo, eviterò di mostrarlo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']\n"
     ]
    }
   ],
   "source": [
    "print(dir(math))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "*dir* mi ritorna una lista con i nomi di tutte le funzioni presenti dento math. Per usarle basta scrivere \n",
    "\n",
    "    nomelibreria.nomefunzione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.exp(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Se voglio sapere cosa faccia di preciso una di quelle funzioni basta usare la funzione help"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function log1p in module math:\n",
      "\n",
      "log1p(...)\n",
      "    log1p(x)\n",
      "    \n",
      "    Return the natural logarithm of 1+x (base e).\n",
      "    The result is computed in a way which is accurate for x near zero.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math.log1p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n",
      "1.4210804127942926\n"
     ]
    }
   ],
   "source": [
    "print(math.pi)\n",
    "print(math.log1p(math.pi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4210804127942926"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log( math.pi + 1.0 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Se avete bisogno di poche funzioni e non volete digitare ogni volta il nome della libreria potete importare solo una parte dei nomi, che saranno poi disponibili senza bisogno di fare riferimenti alla librerie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6931471805599453\n"
     ]
    }
   ],
   "source": [
    "from math import radians, log1p, modf\n",
    "\n",
    "print(log1p(1.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Potreste trovare alcuni tutorial su internet che propongono di importare le funzioni da una libreria con il seguente comando:\n",
    "\n",
    "    from math import *\n",
    "    \n",
    "Evitatelo come la peste.\n",
    "\n",
    "Questo comando importa infatti tutti i nomi di funzioni dalla libreria, sovrascrivendo possibili funzioni già esistenti.\n",
    "Questo comportamento potrebbe riservarvi delle sorprese molto spiacevoli, e di cui è difficile rendersi conto!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Inclusi nel linguaggio di base arrivano anche molte strutture dati estremanente utili. Una lista non esaustiva include:\n",
    "\n",
    "- liste\n",
    "- stringhe\n",
    "- set\n",
    "- dizionari\n",
    "- deque\n",
    "- heap\n",
    "\n",
    "Una menzione particolare la meritano i dizionari, che permettono di memorizzare dei dati in modalità random (ovvero non sequenziale) accedendovi tramite nomi esplicativi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('334-5678901', 'Via Larga 34, Bo')\n"
     ]
    }
   ],
   "source": [
    "rubrica = dict()\n",
    "rubrica['Ludovico Fabbri'] = ('334-5678901', \n",
    "                              'Via Larga 34, Bo')\n",
    "print(rubrica['Ludovico Fabbri'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Se provo a cercare un elemento assente, Python si lamenta in modo rumoroso.\n",
    "\n",
    "Questo è un design intenzionale, meglio fallire presto in modo chiaro che non dare risultati inaspettati!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'enrico giampieri'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-48-353ef568a7d1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mrubrica\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'enrico giampieri'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'enrico giampieri'"
     ]
    }
   ],
   "source": [
    "rubrica['enrico giampieri']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "non trovato\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(rubrica['enrico giampieri'])\n",
    "except KeyError:\n",
    "    print(\"non trovato\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### funzioni\n",
    "\n",
    "È possibile definire le proprie funzioni tramite il comando **def**.\n",
    "In questo caso creerò una funzione che prende due oggetti e ne restituisce la somma.\n",
    "\n",
    "A python non interessa di che oggetti di tratti, fintantochè sia definita fra di loro una somma.\n",
    "Posso usare questa funzione per sommare indifferentemente fra di loro numeri, stringhe, liste o distribuzioni di probabilità."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "hello world!\n",
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "def mia_funzione(a, b):\n",
    "    return a+b\n",
    "\n",
    "print(mia_funzione(1, 2))\n",
    "print(mia_funzione('hello ', 'world!'))\n",
    "print(mia_funzione([1, 2, 3], [4, 5, 6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### iterazioni\n",
    "\n",
    "Python supporta le iterazioni sia con il costrutto while che con il for. Il for in pyhton è un ciclo speciale estremamente potente, ed è quindi il modo principale di scrivere cicli.\n",
    "\n",
    "Nel classico modo di scrivere cicli, per scorrere una lista di oggetti devo fare un ciclo sopra gli indici della lista, stando attento a trovare bene i bordi, e poi operare sul mio oggetto. Prendiamo ad esempio il caso di voler stampare tutto il contenuto di una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "lista_ingredienti = ['pane', 'pomodori', 'farina', 'acqua', 'sale', 'mozzarella']\n",
    "lunghezza = len(lista_ingredienti)\n",
    "idx = 0\n",
    "while idx < lunghezza:\n",
    "    print(lista_ingredienti[idx])\n",
    "    idx += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Due delle linee di questo codice (trovare la lunghezza della lista e ricavarne l'elemento) sono sempre presenti. Per ovviare a queste linee superflue, il python permette di usare il ciclo for per scorrere direttamente gli elementi della lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "acqua\n",
      "farina\n"
     ]
    }
   ],
   "source": [
    "lista_ingredienti = (\"acqua\", \"farina\")\n",
    "for ingrediente in lista_ingredienti:\n",
    "    print(ingrediente)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Se voglio leggere un file ho a disposizione la funzione `open`.\n",
    "\n",
    "Questa funzione può essere usata per delimitare un blocco di codice all'interno del quale il file è aperto.\n",
    "Al termine delle operazioni, questo verrò chiuso in modo automatico e sicuro, evitando che rimanga aperto e venga corrotto da altri processi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting prova.txt\n"
     ]
    }
   ],
   "source": [
    "%%file prova.txt\n",
    "tonno\n",
    "mandibola\n",
    "rum\n",
    "pinocchio\n",
    "sigmoide"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'tonno\\n'\n",
      "6\n",
      "'mandibola\\n'\n",
      "10\n",
      "'rum\\n'\n",
      "4\n",
      "'pinocchio\\n'\n",
      "10\n",
      "'sigmoide'\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "with open('prova.txt') as file: #commento\n",
    "    for line in file:\n",
    "        print(repr(line))\n",
    "        print(len(line))"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}