Introduzione a Python - Parte terza.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuple, Stringhe, Dizionari, Insieme e Oggetti\n",
    "Abbiamo visto come con python possiamo definire semplicemente dei **numeri** (interi, decimali, complessi), delle **liste** di elementi (che possiamo usare per rappresentare dei vettori) e delle **funzioni**.\n",
    "\n",
    "Ci restano da vedere molto velocemente:\n",
    "\n",
    "1. **tuple**\n",
    "2. **stringhe**\n",
    "3. **dizionari**\n",
    "4. **insiemi**\n",
    "5. **oggetti**\n",
    "\n",
    "Le vediamo brevemente direttamente nel workspace."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple e Liste\n",
    "Le liste sono sequenze di elementi che non possono essere modificati. Ogni elemento di una tupla può essere di qualsiasi tipo, e gli elementi possono essere tutti di tipi diversi tra loro.\n",
    "Diversamente dalle liste, da una tupla non si possono rimuovere o aggiungere elementi: è un oggetto di tipo *read only* (come Complex). A differenza delle liste, le tuple sono rappresentate come una sequenza di oggetti racchiusi tra parentesi tonde (per le liste si usa le quadre)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x=2,4\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(x, x[0], x[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x[1] = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a,b = 2,4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a,b = b,a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operazioni su tuple\n",
    "Con le tuple è possibile effettuare operazioni di concatenamento, indicizzazione, *slicing* e *repetition*.\n",
    "\n",
    "**ESEMPIO**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "t1 = (2, 'ciao', 5)\n",
    "t2 = (3.14, 987)\n",
    "# Concatenazione\n",
    "print('concatenazione:', t1+t2)\n",
    "# Indicizzazione\n",
    "print('indicizzazione:',t1[1])\n",
    "# Slicing\n",
    "print('slicing:',(t1+t2)[2:])\n",
    "# Repetition\n",
    "print('repetition:',t2*3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTA:** Per definire una tuple di lunghezza pari a uno, ovvero di un singolo elemento, bisogna usare la strana sintassi `(1,)`: si noti la virgola dopo l'uno."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a=(1)\n",
    "b=(1,)\n",
    "print(type(a), type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ESERCIZIO 1:** Scrivere una funzione che prende in input due tuple e restituisce una tupla che contiene gli elementi che sono sia nella prima che nella seconda tupla. Scrivere anche una funzione di test che comprenda qualche caso significativo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def Intersect(As, Bs):\n",
    "    # COMPLETARE\n",
    "    # COMPLETARE\n",
    "    return As\n",
    "\n",
    "def UnitTest():\n",
    "    # COMPLETARE\n",
    "    # COMPLETARE\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ESERCIZIO 2:** (*obiettivo: intuire il vantaggio di poter avere anche oggi non mutabili*)\n",
    "\n",
    "Si scriva una funzione che prenda in input due **liste** e che rimuove dalla prima lista ogni elemento che compare nella seconda lista. La funzione non ritorna nulla, ma **modifica** la prima lista data in input. \n",
    "\n",
    "Si può usare il metodo `L.remove(e)` che rimuove dalla lista `L` il primo elemento uguale a `e`. Per testare se un elemento appartiene ad una lista basta eseguire il controllo `e in L`:\n",
    "```\n",
    "if 3 in [1,2,3,4,5]:\n",
    "    print('ok')\n",
    "else:\n",
    "    print('failed')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def RimuoviDuplicati(As, Bs):\n",
    "    # DA COMPLETARE\n",
    "    # DA COMPLETARE\n",
    "    pass\n",
    "\n",
    "L1 = [2, 4, 2, 5, 6, 6, 3, 2, 9, 4]\n",
    "L2 = [2, 4, 7]\n",
    "RimuoviDuplicati(L1, L2)\n",
    "print('L1 =', L1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Il problema di *aliasing*\n",
    "Si consideri l'esempio seguente, ripreso dal Capitolo 5 del libro di riferimento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Techs = ['MIT', 'Caltech']\n",
    "Ivys = ['Harvard','Yale','Penn']\n",
    "U1 = [Techs, Ivys]\n",
    "U2 = [['MIT', 'Caltech'], ['Harvard','Yale','Penn']]\n",
    "print(U1 == U2)\n",
    "print(id(U1) == id(U2)) # la funzione id() restituisce l'identificativo unico di un oggetto python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Techs.append('Standford')\n",
    "print(U1 == U2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "U1[0].remove('Standford')\n",
    "print(Techs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTA:** abbiamo due percorsi diversi che portano allo stesso oggetto di tipo lista: il primo attraverso il nome della lista `Techs`, il secondo attraverso il primo elemento della lista `U1`.  Basta modificare uno dei due, che il cambiamento si riflette sull'altro: si parla in questo caso di **side effect**, in quanto si potrebbero introdurre degli effetti non desiderati, difficili da individuare. Notare che problemi di questo tipo non si hanno con strutture dati di tipo *read only*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stringhe\n",
    "\n",
    "Le stringhe sono delle sequenze di caratteri con una implementazione builtin molto efficiente. Anche le stringhe sono degli oggetti di tipo *read only* e non possono essere modificate. I metodi che operano sulle stringhe, sono delle funzioni che restituiscono delle nuove stringhe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "commento = \"Enrico, stai sereno!\"\n",
    "for c in commento:\n",
    "    print(c.upper(), end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Per vedere alcuni metodi utili sulle funzioni, ricordarsi di usare il **tab** destro per l'autocompletion dopo il nome+punto di una variabile:\n",
    "\n",
    "`commento. '+' <tab>`\n",
    "\n",
    "Esempio:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#commento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# INDICIZZAZIONE E SLICING\n",
    "print(commento[3], commento[-1], commento[2:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(commento.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(commento.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da notare che la funzione `upper` non ha modifcato la stringa `commento`, ma ha restituito una nuova lista con tutte le lettere maiuscole. La maggior parte delle funzioni standard di python che opera sulle stringhe operano in questo modo. Per maggiori dettagli, potete sempre consultare `help(str)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "commento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metodi utili sulle stringhe\n",
    "I seguenti metodi sono tutti molto utili e restituiscono delle nuove stringhe lasciando la stringa iniziale immutata:\n",
    "\n",
    "* `s.count(s1)`: conta qualche volte la stringa `s1` è contenuta in `s`\n",
    "* `s.find(s1)`: restituisce l'indice della stringa `s` in cui ha trovato per la prima volta la stringa `s1`; altrimenti restituisce -1\n",
    "* `s.rfind(s1)`: come sopra, ma inizia dalla fine di `s` (la `r` sta per `reversed`)\n",
    "* `s.replace(old,new)`: sostituisce tutte le sottostringhe uguali a `old` in `s` con la stringa `new`\n",
    "* `s.strip()`: rimuove tutti i caratteri blanks dalla stringa `s`\n",
    "* `s.split(d)`: suddivide la stringa in sottostringhe usando il carattere `d` come separatore"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dizionari\n",
    "I dizionari sono una struttura dati molto utilizzati in python. Sono delle strutture dati che corrispondono a delle liste di coppie **(key, value)**. I dizionari sono degli oggetti **mutabili** come le liste, ma non sono una sequenza ordinata, e quindi non possono essere indicizzati con dei numeri interi.\n",
    "\n",
    "La **key** viene utilizzata come chiave per indicizzare un **value**. Per esempio:\n",
    "\n",
    "`Dict[\"hello\"] = \"ciao\"`\n",
    "\n",
    "Abbiamo la chiave \"hello\" utilizzata per indicizzare l'elemento \"ciao\" nel dizionario Dict. Per semplicita', potete pensare ai dizionari a come dei vettori di elementi indicizzati da altri oggetti **immutabili**, come ad esempio delle stringhe.\n",
    "\n",
    "**ESEMPIO:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Creo un dizionario vuoto\n",
    "Vocabolario = dict()\n",
    "print(type(Vocabolario))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Vocabolario[\"keep\"] = \"stai\"\n",
    "Vocabolario[\"calm\"] = \"sereno\"\n",
    "print(\"Enrico,\", Vocabolario[\"keep\"], Vocabolario[\"calm\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# E` possibile enumerare i dizionari con un ciclo for\n",
    "Vocabolario[\"hello\"] = \"ciao\"\n",
    "for key in Vocabolario:\n",
    "    print(\"chiave:\", key, \"- valore:\", Vocabolario[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metodi utili sui dizionari\n",
    "I seguenti metodi sono molto utili per usare i dizionari:\n",
    "\n",
    "* `len(d)`: restituisce il numero di elementi nel dizionario `d`\n",
    "* `d.keys()`: restituisce una vista delle chiavi del dizionario `d`\n",
    "* `d.values()`: restituisce una vista dei valori del dizionario `d`\n",
    "* `key in d`: restituisce `True` se la chiave `key` è nel dizionario `d`\n",
    "* `d.get(key, value)`: restituisce `d[key]` se `key` è in `d`, altrimenti restituisce il valore `value`\n",
    "* `d[key] = value`: associa il valore `value` alla chiave `key` nel dizionario `d`\n",
    "* `del d[key]`: rimuove la chiave `k` dal dizionario `d`\n",
    "* `for key in d`: itera sulle chiavi del dizionario `d`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Insiemi\n",
    "È possibile definire degli insiemi di elementi usando oggetti di tipo `set`: questi sono delle collezioni non ordinate di oggetti mutabili (più precisamente su cui è definita una funzione di `hash`). Sono molto utili quando si deve controllare l'appartenenza di un elemento ad un dato insieme, avere delle collezioni di oggetti senza duplicati, oppure se si devono effetturare delle operazioni su insiemi come unione, intersezione e differenza tra insiemi.\n",
    "\n",
    "Per maggiori dettagli, si rimanda alla [documentazione ufficiale](https://docs.python.org/3.6/library/stdtypes.html?highlight=set#set).\n",
    "\n",
    "**ESEMPIO:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "A = set([2,3,4,2,4,6,7,8])\n",
    "print(A)\n",
    "print(3 in A)\n",
    "B = set([4,4,2,1])\n",
    "A = A.intersection(B)\n",
    "print(A)\n",
    "A = A.difference(B)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classi e Oggetti\n",
    "\n",
    "Il piu' semplice esempio di built-in oggetto in python e' il tipo `complex`:\n",
    "\n",
    "`x = 1+3j`\n",
    "\n",
    "In questo caso una semplice implementazione in python potrebbe essere:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class MyComplex:\n",
    "    \n",
    "    def __init__(self, Real, Img):\n",
    "        self.real = Real\n",
    "        self.img = Img\n",
    "        \n",
    "    def __str__(self):\n",
    "        s = str(self.real)\n",
    "        if self.img >= 0:\n",
    "            s += '+'\n",
    "        s += str(self.img)+'j'\n",
    "        return s\n",
    "    \n",
    "    def coniugate(self):\n",
    "        return MyComplex(self.real, -self.img)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "c = MyComplex(1,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(c.coniugate())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "c.img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "c.img = 5\n",
    "print(c.coniugate())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Lettura di file di testo\n",
    "Per leggere un file di testo chiamato `filename`, bisogna prima \"aprirlo\" con il comando `open(filename, mode)` usando la modalità `mode='r'`. Si usi invece `mode='w'` se si vuole scrivere un nuovo file oppure `mode='a'` se vuole aggiungere righe in coda ad un file esistente. Il metodo `open` restituisce un file *handle* (una sorta di puntatore) per poter accedere al file e manipolarne il contenuto.\n",
    "\n",
    "**ESEMPIO:** Il seguente codice, apre il file di testo `train-small.csv` (il suffisso \".csv\" sta per \"comma separated values\") e ne legge una riga alla volta stampandola a video. Il file contiene le informazioni di 10 passeggeri del Titanic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "doc = open('data/train-small.csv', 'r')\n",
    "for row in doc:\n",
    "    print(row)\n",
    "doc.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si noti che in effetti ogni riga del file contiene una serie di valori separati da una virgola e che è come se ogni riga contennesse già il carattere `\\n` che stampa delle righe vuote.\n",
    "\n",
    "### Metodi utili per manipolare files\n",
    "I seguenti metodi sono molto utili per manipolare dei files:\n",
    "\n",
    "* `open(filename, mode)`: apre il file chiamato \"filename\" in modalità `mode` (lettura, scrittura, aggiunta)\n",
    "* `pf.read()`: restituisce un'unica stringa contenente l'intero contenuto del file\n",
    "* `pf.readline()`: restituisce la prossima riga associata al file handler `pf`\n",
    "* `pf.readlines()`: restituisce una lista di stringhe, una per ciascuna riga contenuta nel file\n",
    "* `pf.write(s)`: scrive la stringa `s` nel file `pf`\n",
    "* `pf.writeLines(S)`: scrive ciascun elemento della collezione di stringhe contenute in `S` in una riga diversa del file `pf`\n",
    "* `pf.close()`: chiude il file handler `pf`\n",
    "\n",
    "\n",
    "**ESERCIZIO 3:** Si scriva una funzione che prenda in input un nome di un file, apra il file in lettura, e su ogni riga:\n",
    "\n",
    "1. rimuove i caratteri `\\n`. Suggerimento: usare la funzione `replace()`\n",
    "2. rimuove le doppie virgolette `\"`\n",
    "3. divide la riga in sottostringhe. Suggerimento: usare la funzione `split()`\n",
    "\n",
    "Infine la funzione deve restituire il numero di persone che nell'elenco hanno il secondo campo pari a 1. Si testi la funzione usando il file `train.csv` che si trova nella cartella `data`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def ReadAndCount(filename):\n",
    "    # DA COMPLETARE\n",
    "    return 0\n",
    "\n",
    "print(ReadAndCount('data/train.csv'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**ESERCIZIO 4:** Si scriva una funzione simile alla precedente, chiamata `ReadAndPlotAge`, ma che restituisca una lista contenente l'èta di ciascun passegero (il sesto campo di ciascuna riga). Si usi tale lista per fare due plot (si vedano i notebook della seconda lezione e relativi esempi di uso di matplotlib con la funzione `hist`):\n",
    "\n",
    "1. Si rappresenti l'istogramma dell'età dei passegeri usando 8 bin\n",
    "2. Si rappresenti la distribuzione cumulatà dell'età dei passengeri, usando 100 bins\n",
    "\n",
    "Si testi la funzione usando il `train.csv`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def ReadAndPlotAge(filename):\n",
    "    # DA COMPLETARE\n",
    "    # DA COMPLETARE\n",
    "    # DA COMPLETARE\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ESERCIZIO 5:** Si scriva simile alla precedente, chiamata `ReadAndPlotFare`, ma che usi il prezzo del biglietto invece dell'età dei passeggeri."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def ReadAndPlotFare(filename):\n",
    "    # DA COMPLETARE\n",
    "    # DA COMPLETARE\n",
    "    # DA COMPLETARE\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ESERCIZIO 6:** Si scriva una funzione, chiamata `ReadAndPlot`, che generalizzi le due precedenti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def ReadAndPlot(filename):\n",
    "    # DA COMPLETARE\n",
    "    # DA COMPLETARE\n",
    "    # DA COMPLETARE\n",
    "    pass"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}