{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<H1 style=\"font-size:50px\">5: Input e Output</H1>\n",
    "\n",
    "<div style = \"width:95%; padding:5px 10px 5px;  margin:50px 0px 10px 10px; font-size:18px\">\n",
    "<UL>\n",
    "    <LI> Come scrivere sullo schermo\n",
    "    <LI> Come controllare il modo con cui le informazioni sono scritte \n",
    "    <LI> Come leggere e scrivere su file\n",
    "</UL>\n",
    "</div>\n",
    "\n",
    "<hr>\n",
    "\n",
    "In questa sezione descriviamo come specificare il formato con cui stampare le informazioni sia sullo shermo che in un file.\n",
    "\n",
    "## 5.1 Stampare sullo standard output (normalmente lo schermo)\n",
    "\n",
    "\n",
    "La funzione `print` è il comando utilizzato più comunemente per stampare informazioni sullo “standard output device” che normalmente è lo schermo.\n",
    "\n",
    "Ci sono due modi per usare print.\n",
    "\n",
    "###  5.1.1 print semplice\n",
    "\n",
    "Il modo più facile di usare il comando `print` è passargli l'elenco delle variabili da stampare separate da un virgola. Qualche esempio:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 'test text'\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The answer is\", a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The answer is\", a, \"and the string contains\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python aggiunge uno spazio tra ogni coppia di oggetti che viene stampata.\n",
    "\n",
    "Python va a capo dopo ogni chiamata a print. Per impedirlo, usate il parametro `end=` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Comportamento di default\n",
    "print(\"Printing in line one\")\n",
    "print(\"...still printing in line one (just kidding).\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sostituendo il simbolo di 'a capo' (\\n) con uno spazio nel primo statement'\n",
    "print(\"Printing in line one\",end=\" \")\n",
    "print(\"...still printing in line one (now it works).\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1.2 Come controllare la rappresentazione delle variabili numeriche sotto forma di stringhe\n",
    "\n",
    "Un sistema built-in di formattazione permette una grande flessibilità.\n",
    "\n",
    "Le idee fondamentali attraverso esempi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"{} needs {} pints\".format('Peter',4)     # inserire i valori nell'ordine in cui devono comparire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"{0} needs {1} pints\".format('Peter', 4)   # specificare l'indice dell'elemento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"{1} needs {0} pints\".format('Peter', 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"{name} needs {number} pints\".format(    # specificare il nome dell'elemento da\n",
    "    name='Peter',number=4)               # stampare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\"Pi is approximately {:f}.\".format(math.pi)     # si può spcificare il format per i reali.\n",
    "                                                # Notate che il format è introdotto da \":\" \n",
    "                                                # all'interno della parentesi graffa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una specificazione di formato del tipo `W.Df` significa che il numero reale deve essere stampato con una lunghezza totale di `W` caratteri e `D` cifre dopo il punto decimale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Pi is approximately {:.2f}.\".format(math.pi)   # si può specificare il numero di cifre dopo la virgola"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\"Pi is approximately {:6.2f}.\".format(math.pi)  # e la lunghezza totale"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un esempio di come mescolare formati e ordine delle variabili:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"{1:10.8f} --- {0:7.3e} pints\".format(3*math.pi, math.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1.3 f-strings: il metodo più semplice e recente di specificare il format\n",
    "\n",
    "È sufficiente mettere il simbolo `f`, da cui il nome f-strings, di fronte al delimitatore iniziale della stringa e poi, all'interno della stringa stessa specificare variabile e formato fra parentesi graffe. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_a = math.pi\n",
    "print(f\"a = {my_a:7.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"2*Pi is approximately {2*math.pi:4.2f}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comandi di formattazione\n",
    "\n",
    "Una lista dei formati comunemente usati usando l'unità astronomica (distanza media Sole-Terra in metri): AU = 149597870700 m.\n",
    "\n",
    "| specifier         |         style         |  Example output for AU|\n",
    "|:------------------|:---------------------:|----------------------:|\n",
    "| `f` |     floating point    |  `149597870700.000000`|\n",
    "| `e` |  exponential notation |         `1.495979e+11`|\n",
    "| `g` |  shorter of %e or %f  |          `1.49598e+11`|\n",
    "| `d` |        integer        |         `149597870700`|\n",
    "| `x` |       exadecimal      |           `22d4ba5a6c`|\n",
    "| `o` |       octal      |           `2132456455154`|\n",
    "| `s` |  `str()` |         `149597870700`|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "AU = 149597870700  # unità astronomica [m]\n",
    "AU_f = f\"{AU:f}\"        # la prima linee della tavola\n",
    "AU_f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "AU_f1 = f\"{AU:.1f}\"        # la prima linee della tavola con una sola cifra dopo il punto\n",
    "AU_f1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "AU_e = f\"{AU:e}\"       # la seconda linee della tavola. Il formato esponenziale ha una cifra prima del punto.\n",
    "AU_e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "AU_e4 = f\"{AU:.4e}\"       # la seconda linee della tavola con quattro cifre dopo il punto\n",
    "AU_e4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tabulare dati con le f-strings\n",
    "Il simbolo >, <, ^ allinea le variabili a destra, sinistra, centro dello spazio disponibile. L'allineamento a destra è il default per le variabili numeriche; l'allineamento a sinistra è il default per quasi tutte gli altri tipi di variabili."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  dato 1   dato 2   dato 3\n",
      "------------------------------\n",
      "       1        2        3\n",
      "       5        6        7\n",
      "       8        9       10\n"
     ]
    }
   ],
   "source": [
    "Table = [[1,2,3],[5,6,7],[8,9,10]]\n",
    "info = [\"dato 1\",\"dato 2\",\"dato 3\"]\n",
    "print(f\"{info[0]:>8s} {info[1]:>8s} {info[2]:>8s}\")\n",
    "print(30*'-')\n",
    "for i in range(len(Table)):\n",
    "    print(f\"{Table[i][0]:8d} {Table[i][1]:8d} {Table[i][2]:8d}\") \n",
    "#    print(f\"{Table[i][0]:i8} {Table[i][1]:i8} {Table[i][2]:i8}\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Separando più chiaramente le colonne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------\n",
      "|   dato 1 |   dato 2 |   dato 3 |\n",
      "----------------------------------\n",
      "|        1 |        2 |        3 |\n",
      "|        5 |        6 |        7 |\n",
      "|        8 |        9 |       10 |\n",
      "----------------------------------\n"
     ]
    }
   ],
   "source": [
    "Table = [[1,2,3],[5,6,7],[8,9,10]]\n",
    "info = [\"dato 1\",\"dato 2\",\"dato 3\"]\n",
    "print(34*'-')\n",
    "print(f\"| {info[0]:>8s} | {info[1]:>8s} | {info[2]:>8s} |\")\n",
    "print(34*'-')\n",
    "for i in range(len(Table)):\n",
    "    print(f\"| {Table[i][0]:8d} | {Table[i][1]:8d} | {Table[i][2]:8d} |\") \n",
    "print(34*'-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Effetto di allineamenti diversi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------\n",
      "| dato 1   |  dato 2  |   dato 3 |\n",
      "----------------------------------\n",
      "|    1     | 2        |        3 |\n",
      "|    5     | 6        |        7 |\n",
      "|    8     | 9        |       10 |\n",
      "----------------------------------\n"
     ]
    }
   ],
   "source": [
    "Table = [[1,2,3],[5,6,7],[8,9,10]]\n",
    "info = [\"dato 1\",\"dato 2\",\"dato 3\"]\n",
    "print(34*'-')\n",
    "print(f\"| {info[0]:8s} | {info[1]:^8s} | {info[2]:>8s} |\")\n",
    "print(34*'-')\n",
    "for i in range(len(Table)):\n",
    "    print(f\"| {Table[i][0]:^8d} | {Table[i][1]:<8d} | {Table[i][2]:8d} |\") \n",
    "print(34*'-')\n",
    "#    print(f\"{Table[i][0]:i8} {Table[i][1]:i8} {Table[i][2]:i8}\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Come incolonnare numeri reali e interi richiedendo lo stesso numero di cifre dopo il punto di separazione:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      dato 1       dato 2       dato 2\n",
      "------------------------------------------\n",
      "        1.20         2.00         3.14\n",
      "       -5.00         6.17         7.00\n",
      "        8.00         9.00        10.00\n"
     ]
    }
   ],
   "source": [
    "Table = [[1.2,2,3.14],[-5.0,6.17,7],[8,9,10]]\n",
    "info = [\"dato 1\",\"dato 2\",\"dato3\"]\n",
    "print(f\"{info[0]:>12s} {info[1]:>12s} {info[1]:>12s}\")\n",
    "print(42*'-')\n",
    "for i in range(len(Table)):\n",
    "    print(f\"{Table[i][0]:12.2f} {Table[i][1]:12.2f} {Table[i][2]:12.2f}\") \n",
    "#    print(f\"{Table[i][0]:i8} {Table[i][1]:i8} {Table[i][2]:i8}\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ulteriori informazioni\n",
    "\n",
    "-   Esempi <http://docs.python.org/library/string.html#format-examples>\n",
    "\n",
    "-   [Python Enhancement Proposal 3101](http://www.python.org/dev/peps/pep-3101/)\n",
    "\n",
    "-   [Python library String Formatting Operations](http://docs.python.org/library/stdtypes.html#string-formatting-operations)\n",
    "\n",
    "-   [Old string formatting](http://docs.python.org/tutorial/inputoutput.html#old-string-formatting)\n",
    "\n",
    "-   [Introduction to Fancier Output Formatting, Python tutorial, section 7.1](http://docs.python.org/tutorial/inputoutput.html)\n",
    "\n",
    "- [pyformat.info](https://pyformat.info/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.2 Leggere e scrivere files\n",
    "\n",
    "Ecco un programmma che\n",
    "\n",
    "1.  crea un file di nome `test.txt`,\n",
    "\n",
    "2.  scrive del testo nel file,\n",
    "\n",
    "4. chiude il file.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I dati che vengono immagazzinati nel file `test.txt` sono:\n",
    "\n",
    "```\n",
    "Writing text to file. This is the first line.\n",
    "And the second line.\n",
    "Third line!!!!!!!\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Scrivere in un file\n",
    "out_file = open(\"test.txt\", \"w\")          # Il file viene aperto/creato in scrittura.\n",
    "                                          # 'w' vuol dire write.\n",
    "out_file.write(\"Writing text to file. This is the first line.\\n\"+\\\n",
    "               \"And the second line.\\n Third line!!!!!!!\")\n",
    "# Il singolo carattere \"\\n\" segnala la fine di una riga. Vuol dire \"a capo\".\n",
    "out_file.close()                          # chiude il file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La cella seguente\n",
    "\n",
    "1. apre il file di nome `test.txt`,\n",
    "\n",
    "2.  legge il testo dal file,\n",
    "\n",
    "3.  stampa il testo sullo schermo.\n",
    "\n",
    "4. chiude il file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " \n",
    "# 2. Leggere dal file\n",
    "in_file = open(\"test.txt\", \"r\")           # Il file viene aperto in lettura. 'r' vuol dire read.\n",
    "text = in_file.read()                     # Legge tutto il file in una variabile \"text\" di \n",
    "                                          # tipo stringa\n",
    "in_file.close()                           # chiude il file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3. Mostrare i dati\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Più in dettaglio, il file viene aperto con il comando `open`. L'oggetto file aperto viene assegnato alla variabile `out_file`. Il testo viene scritto nel file usando il metodo `out_file.write`. Si noti che nell'esempio più sopra, al metodo `write` è stata passata una stringa. Si possono usare, ovviamente, tutte specificazioni di formato discusse in precedenza — si veda [formatted printing](#Formatted-printing) e [new style formatting](#New-style-string-formatting). È buona pratica usare `close()` su tutti i files in cui si è finito di leggere e scrivere. Se un programma Python finisce in modo controllato (cioè non per una caduta di tensione o un improbabile bug del linguaggio o del sistema operativo) tutti i files aperti vengono chiusi non appena i file objects vengono distrutti. Tuttavia, chiuderli esplicitamente non appena possibile è uno stile migliore di programmazione.\n",
    "\n",
    "### Metodi ed esempi di lettura e scrittura su file\n",
    "\n",
    "Creiamo un file chiamato `myfile.txt` che contiene le tre linee di testo seguenti:\n",
    "\n",
    "    This is the first line.\n",
    "    This is the second line.\n",
    "    This is a third and last line."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il metodo write non aggiunge il carattere `newline (\\n)` alla fine di ogni operazione di scrittura"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('myfile.txt', 'w')\n",
    "f.write('This is the first line.\\n'\n",
    "        'This is the second line.\\n'\n",
    "        'This is the third and last line.')\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modi equivalenti:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f1 = open('myfile1.txt', 'w')\n",
    "f1.write('This is the first line.\\n''This is the second line.\\n''This is the third and last line.')\n",
    "f1.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f2 = open('myfile2.txt', 'w')\n",
    "f2.write('This is the first line.\\n'+'This is the second line.\\n'+'This is the third and last line.')\n",
    "f2.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "È sbagliato passare a `write` più stringhe separate da virgole. `write` accetta un solo argomento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f3 = open('myfile3.txt', 'w')\n",
    "f3.write('This is the first line.\\n','This is the second line.\\n','This is the third and last line.')\n",
    "f3.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### fileobject.read()\n",
    "\n",
    "Il metodo `fileobject.read()` legge tutto il file, e lo restituisce come una singola stringa (inclusi i caratteri di \"a capo\" `\\n`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('myfile.txt', 'r')\n",
    "f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### fileobject.readlines()\n",
    "\n",
    "Il metodo `fileobject.readlines()` restituisce una lista di stringhe, in cui ciascun elemento della lista corrisponde a una linea del file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('myfile.txt', 'r')\n",
    "f.readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Questo metodo viene spesso utilizzato per iterare sulle linee, compiendo delle operzioni su ciascuna linea. Per esempio:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('myfile.txt', 'r')\n",
    "for line in f.readlines():\n",
    "    print(f\"{len(line)} characters\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si noti che `readlines()` immagazzina tutto il file in una lista di stringhe. Non è un problema se si è sicuri che il file è piccolo e che può essere contenuto nella memoria disponibile.\n",
    "\n",
    "In questo caso, possiamo chiudere il file prima di processarne il contenuto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('myfile.txt', 'r')\n",
    "lines = f.readlines()\n",
    "f.close()\n",
    "for line in lines:\n",
    "    print(\"%d characters  %s\" % (len(line),line))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Come iterare sulle linee (file object)\n",
    "\n",
    "Esiste una notazione ancora più semplice per leggere un file linea per linea che (1) legge solo una linea alla volta (e quindi è adatto anche a files grandi) e (2) produce un codice più compatto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('myfile.txt', 'r')\n",
    "for line in f:\n",
    "    print(f\"{len(line)} characters\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In questo caso, il \"file handle\" `f` agisce come un iteratore e restituisce la linea seguente a ogni iterazione del  for-loop fino alla fine del file (quando il for-loop finisce). In alternativa si può usare il metodo `readline` che restituisce una riga alla volta:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('myfile.txt', 'r')\n",
    "l1 = f.readline()\n",
    "print(l1)\n",
    "l2 = f.readline()\n",
    "print(l2)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Nozioni più avanzate: il context manager `with`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La documentazione di Python consiglia accedere ai file con la keyword `with`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('myfile.txt') as f:\n",
    "    for line in f:\n",
    "        print(f\"{len(line)} characters\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Questa notazione chiude automaticamente il file alla fine delle operazioni contenute nel blocco `with` anche se il programma si fermasse per un errore. Il comando `close` non è più necessario."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lettura/scrittura su file in directory diversa da quella di lavoro\n",
    "\n",
    "La directory di lavoro si trova con il comando (magico)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pwd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Aprire un file già esistente utilizzando il path assoluto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(r\"/Users/maina/cernbox/python/MyCourse/path_test_dir/pippo1.txt\") as filein:\n",
    "    for line in filein:\n",
    "        print(f\"{line} :: {len(line)} characters\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creare un nuovo file utilizzando il path assoluto e passando il parametro `\"w\"` al comando `open`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines = [\"pippo\", \"pluto\", \"non c'è trippa per gatti\"]\n",
    "with open(r\"/Users/maina/cernbox/python/MyCourse/path_test_dir/pippo2.txt\",\"w\") as fileout:\n",
    "    for line in lines:\n",
    "        fileout.write(line+\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = open(r\"/Users/maina/cernbox/python/MyCourse/path_test_dir/pippo2.txt\")\n",
    "res = test.read()\n",
    "print(res)\n",
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aprire un file già esistente utilizzando il path relativo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(r\"../path_test_dir/pippo1.txt\") as filein:\n",
    "    for line in filein:\n",
    "        print(f\"{line} :: {len(line)} characters\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notate come nelle celle precedenti il path venga passato in stringhe che hanno la lettera `r` prima del delimitatore. Questo tipi di stringhe si chiamano `raw strings`. Tutto il testo contenuto nella stringa viene scritto esattamente come appare, per esempio \"\\n\" viene interpretato come `backslash` + `n` e non come il simbolo di `a capo`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Nozioni più avanzate: zip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Partendo da due o più oggetti iterabili (stringhe, liste, ntuple) di uguale lunghezza restituisce un iteratore che combina\n",
    "il contenuto degli oggetti di partenza.<BR>\n",
    "Esempi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = [1,2,3]\n",
    "l2 = ['a','b','c']\n",
    "list(zip(l1,l2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = 'pippo'\n",
    "l2 = 'pluto'\n",
    "list(zip(l1,l2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = [1,2,3,4,5]\n",
    "l2 = 'pluto'\n",
    "list(zip(l1,l2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style = \"width:95%; padding:5px 10px 5px; border-style:solid; border-width:0px 0px 0px 10px; border-color:#b8d0d0; margin:20px 0px 10px 10px\">\n",
    "    <h4> Imparare Facendo</h4>\n",
    "    \n",
    "<OL>\n",
    "<LI>Aprite in lettura il file \"../Data/Iris_Dataset.csv\" assegnandolo alla variabile <b>filein</b>.\n",
    "<OL>\n",
    "    <LI>Importate il contenuto del file nella variabile <b>filein</b> usando il metodo <b>read</b>.\n",
    "    <LI>Chiudete il file.\n",
    "    <LI>Separate le linee con <b>split</b> usando il carattere \"\\n\" (newline) come separatore.\n",
    "    <LI>Saltate la prima riga e stampate le cinque righe seguenti sullo schermo.\n",
    "</OL>\n",
    "<LI>Aprite in lettura il file \"../Data/Iris_Dataset.csv\" assegnandolo alla variabile <b>filein</b>.\n",
    "<OL>\n",
    "    <LI>Importate il contenuto del file nella lista <b>fileList</b> usando il metodo <b>readlines</b>.\n",
    "    <LI>Chiudete il file.\n",
    "    <LI>Estraete il secondo valore da ciascuna riga, la prima esclusa. Stampate il valore numerico sullo schermo. \n",
    "</OL>\n",
    "</OL>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Informazioni ulteriori\n",
    "\n",
    "[Input and output, Tutorial, Section 7.2](http://docs.python.org/tutorial/inputoutput.html)"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}