Lezione 1b - Iteratori e Big Data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Big Data e Big Problem\n",
    "Normalmente si può trovare come definizione di big data la seguente:\n",
    "\n",
    "    I dati sono troppo grandi per entrare in memoria/disco rigido\n",
    "    \n",
    "Esiste però un altro problema Big:\n",
    "\n",
    "    Anche su dati piccoli, il mio modello potrebbe richiedere più\n",
    "    risorse di quelle a mia disposizione"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The Cancer Genome Atlas\n",
    "\n",
    "https://www.cancer.gov/about-nci/organization/ccg/research/structural-genomics/tcga\n",
    "\n",
    "<img src=\"https://github.com/UniboDIFABiophysics/PLSBigDataNetworks/raw/master/img/TCGA_prostata.png\" width=\"900\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"https://github.com/UniboDIFABiophysics/PLSBigDataNetworks/raw/master/img/cpu_memoria.png\" width=\"900\"/>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Nei big data dobbiamo fare delle scelte\n",
    "\n",
    "Semplificando, ci sono 3 variabili nel nostro sistema:\n",
    "\n",
    "* il **tempo** che siamo disponibili ad aspettare\n",
    "* lo **spazio** su RAM che siamo disponibili ad allocare\n",
    "* l'ammontare di informazioni che vogliamo ottenere (statistical **power**)\n",
    "\n",
    "Tanto più ottimizziamo uno di questi parametri, tanto più ci rimettiamo negli altri due."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"https://github.com/UniboDIFABiophysics/PLSBigDataNetworks/raw/master/img/power_triangle.png\" width=\"400\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Questo schema non tiene conto anche di altri fattori:\n",
    "\n",
    "* la leggibilità e trasferibilità del codice (potremmo scrivere in codice binario)\n",
    "* il tempo che serve all'analista per produrre il codice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"https://github.com/UniboDIFABiophysics/PLSBigDataNetworks/raw/master/img/oph_cluster.png\" width=\"900\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Leggere files (grandi)\n",
    "\n",
    "\n",
    "Quando abbiamo a che fare con files molto grandi, per leggerli è utile usare la funzione `open`.\n",
    "\n",
    "Questa funzione può essere usata per delimitare un blocco di codice all'interno del quale il file è aperto.\n",
    "\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": "slide"
    }
   },
   "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": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "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'\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "with open('prova.txt') as file:\n",
    "    \n",
    "    for line in file:\n",
    "        \n",
    "        print(repr(line))\n",
    "        \n",
    "        print(len(line))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "_io.TextIOWrapper"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- L'output della funzione `open` non è il contenuto del file ma un oggetto di python che permette di leggere e modificare il file sul disco.\n",
    "\n",
    "- Iterare sull'oggetto \"file\" significa iterare sulle sue righe.\n",
    "\n",
    "- Sulla RAM non viene mai caricato tutto il file ma solo una riga alla volta."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Un problema di esempio - rinominare i file di una (grande) collezione audio\n",
    "\n",
    "Ovviamente si tratta di un problema giocattolo.\n",
    "\n",
    "Cosa succederebbe se avessimo un milione di files da rinominare?\n",
    "\n",
    "E se per ciascun file non dovessi solo rinominare, ma fare analisi complicate?\n",
    "\n",
    "I principi rimangono gli stessi, soltanto più estremi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "! rm -fR notebookfiles/fakeaudio\n",
    "\n",
    "! mkdir -p notebookfiles/fakeaudio\n",
    "\n",
    "! mkdir -p notebookfiles/fakeaudio/Albums/PinkFloyd/TheWall\n",
    "\n",
    "! touch notebookfiles/fakeaudio/Albums/PinkFloyd/TheWall/The\\ Thin\\ Ice.MP3\n",
    "\n",
    "! touch notebookfiles/fakeaudio/Albums/PinkFloyd/TheWall/Another\\ Brick\\ In\\ The\\ Wall\\ -\\ Part\\ 1.MP3\n",
    "\n",
    "! mkdir -p notebookfiles/fakeaudio/OST/TheBindingOfIsaac/Rebirth/\n",
    "\n",
    "! touch notebookfiles/fakeaudio/OST/TheBindingOfIsaac/Rebirth/My\\ Innermost\\ Apocalypse.MP3\n",
    "\n",
    "! touch notebookfiles/fakeaudio/OST/TheBindingOfIsaac/Rebirth/NONTOCCARE.TXT\n",
    "\n",
    "! echo \"un testo inutile\" > notebookfiles/fakeaudio/OST/TheBindingOfIsaac/Rebirth/NONTOCCARE.TXT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "notebookfiles/fakeaudio/:\r\n",
      "totale 8\r\n",
      "drwxrwxr-x 3 claudia claudia 4096 gen 26 11:26 Albums\r\n",
      "drwxrwxr-x 3 claudia claudia 4096 gen 26 11:26 OST\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/Albums:\r\n",
      "totale 4\r\n",
      "drwxrwxr-x 3 claudia claudia 4096 gen 26 11:26 PinkFloyd\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/Albums/PinkFloyd:\r\n",
      "totale 4\r\n",
      "drwxrwxr-x 2 claudia claudia 4096 gen 26 11:26 TheWall\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/Albums/PinkFloyd/TheWall:\r\n",
      "totale 0\r\n",
      "-rw-rw-r-- 1 claudia claudia 0 gen 26 11:26 'Another Brick In The Wall - Part 1.MP3'\r\n",
      "-rw-rw-r-- 1 claudia claudia 0 gen 26 11:26 'The Thin Ice.MP3'\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/OST:\r\n",
      "totale 4\r\n",
      "drwxrwxr-x 3 claudia claudia 4096 gen 26 11:26 TheBindingOfIsaac\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/OST/TheBindingOfIsaac:\r\n",
      "totale 4\r\n",
      "drwxrwxr-x 2 claudia claudia 4096 gen 26 11:26 Rebirth\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/OST/TheBindingOfIsaac/Rebirth:\r\n",
      "totale 4\r\n",
      "-rw-rw-r-- 1 claudia claudia  0 gen 26 11:26 'My Innermost Apocalypse.MP3'\r\n",
      "-rw-rw-r-- 1 claudia claudia 17 gen 26 11:26  NONTOCCARE.TXT\r\n"
     ]
    }
   ],
   "source": [
    "! ls -lR notebookfiles/fakeaudio/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import os  # pip install os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "./notebookfiles/fakeaudio/\n",
      "['OST', 'Albums']\n",
      "[]\n",
      "\n",
      "./notebookfiles/fakeaudio/OST\n",
      "['TheBindingOfIsaac']\n",
      "[]\n",
      "\n",
      "./notebookfiles/fakeaudio/OST/TheBindingOfIsaac\n",
      "['Rebirth']\n",
      "[]\n",
      "\n",
      "./notebookfiles/fakeaudio/OST/TheBindingOfIsaac/Rebirth\n",
      "[]\n",
      "['My Innermost Apocalypse.MP3', 'NONTOCCARE.TXT']\n",
      "\n",
      "./notebookfiles/fakeaudio/Albums\n",
      "['PinkFloyd']\n",
      "[]\n",
      "\n",
      "./notebookfiles/fakeaudio/Albums/PinkFloyd\n",
      "['TheWall']\n",
      "[]\n",
      "\n",
      "./notebookfiles/fakeaudio/Albums/PinkFloyd/TheWall\n",
      "[]\n",
      "['Another Brick In The Wall - Part 1.MP3', 'The Thin Ice.MP3']\n"
     ]
    }
   ],
   "source": [
    "directory = \"./notebookfiles/fakeaudio/\"\n",
    "for basepath, listdir, listfiles in os.walk(directory):\n",
    "    print()\n",
    "    print(basepath)\n",
    "    print(listdir)\n",
    "    print(listfiles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "directory = \"./notebookfiles/fakeaudio/\"\n",
    "\n",
    "for basepath, listdir, listfiles in os.walk(directory):\n",
    "    \n",
    "    for filename in listfiles:\n",
    "        \n",
    "        new_filename = filename.lower()\n",
    "        \n",
    "        os.rename( os.path.join(basepath, filename),\n",
    "                  \n",
    "                   os.path.join(basepath, new_filename) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "notebookfiles/fakeaudio/:\r\n",
      "totale 8\r\n",
      "drwxrwxr-x 3 claudia claudia 4096 gen 26 11:26 Albums\r\n",
      "drwxrwxr-x 3 claudia claudia 4096 gen 26 11:26 OST\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/Albums:\r\n",
      "totale 4\r\n",
      "drwxrwxr-x 3 claudia claudia 4096 gen 26 11:26 PinkFloyd\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/Albums/PinkFloyd:\r\n",
      "totale 4\r\n",
      "drwxrwxr-x 2 claudia claudia 4096 gen 26 11:27 TheWall\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/Albums/PinkFloyd/TheWall:\r\n",
      "totale 0\r\n",
      "-rw-rw-r-- 1 claudia claudia 0 gen 26 11:26 'another brick in the wall - part 1.mp3'\r\n",
      "-rw-rw-r-- 1 claudia claudia 0 gen 26 11:26 'the thin ice.mp3'\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/OST:\r\n",
      "totale 4\r\n",
      "drwxrwxr-x 3 claudia claudia 4096 gen 26 11:26 TheBindingOfIsaac\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/OST/TheBindingOfIsaac:\r\n",
      "totale 4\r\n",
      "drwxrwxr-x 2 claudia claudia 4096 gen 26 11:27 Rebirth\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/OST/TheBindingOfIsaac/Rebirth:\r\n",
      "totale 4\r\n",
      "-rw-rw-r-- 1 claudia claudia  0 gen 26 11:26 'my innermost apocalypse.mp3'\r\n",
      "-rw-rw-r-- 1 claudia claudia 17 gen 26 11:26  nontoccare.txt\r\n"
     ]
    }
   ],
   "source": [
    "!ls -lR notebookfiles/fakeaudio/  # elenca i files di tutte le subdirectories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "qui però sto anche cambiando il nome a tutti i file che sono presenti nelle directory, anche se non sono dei file audio!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "! rm -fR notebookfiles/fakeaudio\n",
    "\n",
    "! mkdir -p notebookfiles/fakeaudio\n",
    "\n",
    "! mkdir -p notebookfiles/fakeaudio/Albums/PinkFloyd/TheWall\n",
    "\n",
    "! touch notebookfiles/fakeaudio/Albums/PinkFloyd/TheWall/The\\ Thin\\ Ice.MP3\n",
    "\n",
    "! touch notebookfiles/fakeaudio/Albums/PinkFloyd/TheWall/Another\\ Brick\\ In\\ The\\ Wall\\ -\\ Part\\ 1.MP3\n",
    "\n",
    "! mkdir -p notebookfiles/fakeaudio/OST/TheBindingOfIsaac/Rebirth/\n",
    "\n",
    "! touch notebookfiles/fakeaudio/OST/TheBindingOfIsaac/Rebirth/My\\ Innermost\\ Apocalypse.MP3\n",
    "\n",
    "! touch notebookfiles/fakeaudio/OST/TheBindingOfIsaac/Rebirth/NONTOCCARE.TXT\n",
    "\n",
    "! echo \"un testo inutile\" > notebookfiles/fakeaudio/OST/TheBindingOfIsaac/Rebirth/NONTOCCARE.TXT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./notebookfiles/fakeaudio/OST/TheBindingOfIsaac/Rebirth/My Innermost Apocalypse.MP3\n",
      "./notebookfiles/fakeaudio/Albums/PinkFloyd/TheWall/Another Brick In The Wall - Part 1.MP3\n",
      "./notebookfiles/fakeaudio/Albums/PinkFloyd/TheWall/The Thin Ice.MP3\n"
     ]
    }
   ],
   "source": [
    "directory = \"./notebookfiles/fakeaudio/\"\n",
    "\n",
    "for basepath, listdir, listfiles in os.walk(directory):\n",
    "\n",
    "    for filename in listfiles:\n",
    "    \n",
    "        if filename.lower().endswith('mp3'):\n",
    "            \n",
    "            new_filename = filename.lower()\n",
    "            \n",
    "            os.rename(os.path.join(basepath, filename),\n",
    "            \n",
    "                      os.path.join(basepath, new_filename))\n",
    "            \n",
    "            print(os.path.join(basepath, filename))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "notebookfiles/fakeaudio/:\r\n",
      "totale 8\r\n",
      "drwxrwxr-x 3 claudia claudia 4096 gen 26 11:27 Albums\r\n",
      "drwxrwxr-x 3 claudia claudia 4096 gen 26 11:27 OST\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/Albums:\r\n",
      "totale 4\r\n",
      "drwxrwxr-x 3 claudia claudia 4096 gen 26 11:27 PinkFloyd\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/Albums/PinkFloyd:\r\n",
      "totale 4\r\n",
      "drwxrwxr-x 2 claudia claudia 4096 gen 26 11:27 TheWall\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/Albums/PinkFloyd/TheWall:\r\n",
      "totale 0\r\n",
      "-rw-rw-r-- 1 claudia claudia 0 gen 26 11:27 'another brick in the wall - part 1.mp3'\r\n",
      "-rw-rw-r-- 1 claudia claudia 0 gen 26 11:27 'the thin ice.mp3'\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/OST:\r\n",
      "totale 4\r\n",
      "drwxrwxr-x 3 claudia claudia 4096 gen 26 11:27 TheBindingOfIsaac\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/OST/TheBindingOfIsaac:\r\n",
      "totale 4\r\n",
      "drwxrwxr-x 2 claudia claudia 4096 gen 26 11:27 Rebirth\r\n",
      "\r\n",
      "notebookfiles/fakeaudio/OST/TheBindingOfIsaac/Rebirth:\r\n",
      "totale 4\r\n",
      "-rw-rw-r-- 1 claudia claudia  0 gen 26 11:27 'my innermost apocalypse.mp3'\r\n",
      "-rw-rw-r-- 1 claudia claudia 17 gen 26 11:27  NONTOCCARE.TXT\r\n"
     ]
    }
   ],
   "source": [
    "! ls -lR notebookfiles/fakeaudio/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Ci sono tre operazioni fondalmentali per l'analisi dati:\n",
    "\n",
    "* iterazione lazy\n",
    "* map (ripete un'operazione su tutti gli elementi)\n",
    "* filter (seleziona solo una parte degli elementi)\n",
    "\n",
    "Altri tipi di operazioni che discuteremo saranno:\n",
    "\n",
    "* reduce (comporre insieme gli elementi)\n",
    "* functional programming\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iterazione Lazy\n",
    "\n",
    "Che cosa intendiamo con iterazione **lazy**?\n",
    "\n",
    "Le operazioni non vengono compiute finchè il risultato non è richiesto!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In Python questa cosa è gestita da degli oggetti chiamati **iteratori**.\n",
    "\n",
    "Sono gli oggetti su cui faccio i cicli **for**.\n",
    "\n",
    "$\\rightarrow$ Un iteratore può essere percorso una volta sola!\n",
    "\n",
    "Questo è controintuitivo: se provo a fare un ciclo for su di una lista, lo posso fare quante volte voglio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- prima iterazione ---\n",
      "1\n",
      "2\n",
      "3\n",
      "--- seconda iterazione ---\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3]\n",
    "\n",
    "print(\"--- prima iterazione ---\")\n",
    "for elemento in lista:\n",
    "    print(elemento)\n",
    "    \n",
    "print(\"--- seconda iterazione ---\")\n",
    "for elemento in lista:\n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Ma se provo a farlo su di un file, lo posso leggere una volta sola!\n",
    "\n",
    "Se volessi rileggerlo, dovrei aprirlo di nuovo!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# creiamo il file NONTOCCARE\n",
    "! echo \"un testo inutile\" > ./NONTOCCARE.TXT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import os # pip install os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home/claudia/Documenti/Didattica/AA2021_2022/2022_PLS/PLSBigDataNetworks'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd() # in quale cartella mi trovo?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Lezione 1a - Introduzione a Python.ipynb',\n",
       " 'hsa_repr.txt',\n",
       " 'Lezione 1b - Iteratori e Big Data.ipynb',\n",
       " 'README.md',\n",
       " 'Lezione 2 - ricostruire la divina commedia con le catene di Markov.slides.html',\n",
       " 'installazione_miniconda3_python_spyder.pdf',\n",
       " 'statistica_singoli_caratteri.tsv',\n",
       " 'statistica_coppie_caratteri.tsv',\n",
       " 'Lezione 1b - Iteratori e Big Data.slides.pdf',\n",
       " 'Lezione 3 - Network Biologici.ipynb',\n",
       " 'Lezione 1a - Introduzione a Python.slides.pdf',\n",
       " 'prova.txt',\n",
       " '.git',\n",
       " 'Lezione 1a - Introduzione a Python.slides.html',\n",
       " 'img',\n",
       " 'Lezione 2 - ricostruire la divina commedia con le catene di Markov.pdf',\n",
       " 'NONTOCCARE.TXT',\n",
       " 'markov_0_lettere.txt',\n",
       " 'divina_commedia_with_copyright_notice.txt',\n",
       " 'Lezione 3 - Network Biologici.pdf',\n",
       " '.ipynb_checkpoints',\n",
       " 'Lezione 1b - Iteratori e Big Data.slides.html',\n",
       " 'divinacommedia_cleaned.txt',\n",
       " 'installazione_miniconda3_python_spyder.pptx',\n",
       " 'Lezione 3 - Network Biologici.slides.html',\n",
       " 'Lezione 2 - ricostruire la divina commedia con le catene di Markov.ipynb',\n",
       " 'notebookfiles',\n",
       " 'hsa.txt']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir() # quali files e sotto-cartelle ci sono?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- prima iterazione ---\n",
      "'un testo inutile\\n'\n",
      "--- seconda iterazione ---\n"
     ]
    }
   ],
   "source": [
    "directory = \"./\"\n",
    "filename = \"NONTOCCARE.TXT\"\n",
    "\n",
    "position = directory + filename\n",
    "\n",
    "with open(position) as file:\n",
    "    \n",
    "    print(\"--- prima iterazione ---\")\n",
    "    for line in file:\n",
    "        print(repr(line))\n",
    "        \n",
    "    print(\"--- seconda iterazione ---\")\n",
    "    for line in file:\n",
    "        print(repr(line))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Python ce lo nasconde, ma in realtà ogni volta che iteriamo sulla lista lui crea un nuovo iteratore che scorre la lista e poi scompare.\n",
    "\n",
    "Possiamo farlo esplicitamente con il comando **iter**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "prima iterazione\n",
      "1\n",
      "2\n",
      "3\n",
      "seconda iterazione\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3]\n",
    "\n",
    "iteratore_lista = iter(lista)\n",
    "\n",
    "print(\"prima iterazione\")\n",
    "for elemento in iteratore_lista:\n",
    "    print(elemento)\n",
    "    \n",
    "print(\"seconda iterazione\")\n",
    "for elemento in iteratore_lista:\n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list_iterator"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(iteratore_lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Non sempre è possibile evitare di caricare l'intero data set.\n",
    "\n",
    "Supponiamo di voler calcolare tutte le combinazioni di elementi di una sequenza: non possiamo risolvere questo problema senza tenere in memoria l'intera sequenza!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Map\n",
    "\n",
    "Un tipo di operazione molto frequente sulle sequenze è il cosiddetto **mapping**, ovvero applicare una funzione a tutti gli elementi di una lista, uno alla volta ed indipendentemente dagli altri.\n",
    "\n",
    "Ad esempio, avendo una serie di numeri, potrei voler prendere il quadrato di ciascuno."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36]\n"
     ]
    }
   ],
   "source": [
    "numeri = [0, 1, 2, 3, 4, 5, 6]\n",
    "\n",
    "quadrati = []\n",
    "for numero in numeri:\n",
    "    quadrato = numero **2\n",
    "    quadrati.append(quadrato)\n",
    "    \n",
    "print(quadrati)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Questo può essere espresso in modo più conciso con una *comprehension*, che è funzionalmente identica al ciclo visto prima, ma più sintetica"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36]\n"
     ]
    }
   ],
   "source": [
    "numeri = [0, 1, 2, 3, 4, 5, 6]\n",
    "\n",
    "quadrati = [x**2 for x in numeri]\n",
    "\n",
    "print(quadrati)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Il concetto di **map** è un'astrazione di questo procedimento.\n",
    "\n",
    "Python fornisce una funzione, chiamata appunto **map**, che prende in input una funzione ed un oggetto iterabile e ritorna un iteratore i cui elementi sono il risultato dell'operazione."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<map object at 0x7fd6c40df128>\n"
     ]
    }
   ],
   "source": [
    "def quadrato(n):\n",
    "    return n**2\n",
    "\n",
    "numeri = [0, 1, 2, 3, 4, 5, 6]\n",
    "quadrati = map(quadrato, numeri)\n",
    "print(quadrati)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Ricordiamoci che il risultato delle operazioni sugli iteratori, quando possibile, è a sua volta un iteratore!\n",
    "\n",
    "Siamo noi che dobbiamo esplicitamente **concretizzare** l'iterazione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(quadrati)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Ricordiamoci che l'iterazione è compiuta una volta sola, quindi se vogliamo il risultato dobbiamo salvarcelo alla prima concretizzazione!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(quadrati)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Filter\n",
    "\n",
    "Le operazioni **filter** selezionano un sottoinsieme dei dati e risultano nella generazione di un secondo iteratore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]\n"
     ]
    }
   ],
   "source": [
    "numeri = [-2, -1, 0, 1, 2]\n",
    "positivi = []\n",
    "for numero in numeri:\n",
    "    if numero > 0:\n",
    "        positivi.append(numero)\n",
    "\n",
    "print(positivi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "In modo simile all'operazione di **map**, anche l'operazione di **filter** ha un costrutto nel linguaggio tramite le *comprehension*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]\n"
     ]
    }
   ],
   "source": [
    "numeri = [-2, -1, 0, 1, 2]\n",
    "positivi = [x for x in numeri if x > 0]\n",
    "print(positivi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "ed esattamente come prima, abbiamo una funzione che prende una funzione di filtro (che ci dice se l'elemento è accettabile o no) e la applica ad un operatore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]\n"
     ]
    }
   ],
   "source": [
    "def is_positive(n):\n",
    "    \n",
    "    return n > 0\n",
    "\n",
    "positivi = filter(is_positive, numeri)\n",
    "\n",
    "print(list(positivi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Reduce\n",
    "\n",
    "questa operazione combina gli elementi di un iteratore in un elemento unico"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "numeri = [1, 2, 3, 4]\n",
    "\n",
    "totale = 0\n",
    "\n",
    "for numero in numeri:\n",
    "    \n",
    "    totale += numero\n",
    "    \n",
    "print(totale)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Come per casi precedenti, esiste una funzione preesistente per effettuare le operazioni di riduzione: la funzione **reduce**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "def somma(a, b):\n",
    "    \n",
    "    return a + b\n",
    "\n",
    "numeri = [1, 2, 3, 4]\n",
    "\n",
    "totale = reduce(somma, numeri)\n",
    "\n",
    "print(totale)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Questo tipo di operazioni è così comune che ci sono una serie di operazioni predefinite:\n",
    "\n",
    "* **sum** per la somma\n",
    "* **min** e **max** per il minimo e massimo\n",
    "\n",
    "e così via"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Una tipica riduzione, che useremo molto, è la stima delle frequenze."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({1: 3, 2: 2, 3: 2, 4: 5})"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "numeri = [ 1, 1, 1, 2, 2, 3, 3, 4, 4, 4, 4, 4 ]\n",
    "\n",
    "Counter( numeri )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Una proprietà importante delle riduzioni è che i risultati si possono combinare: dati i conteggi su due serie, posso sommare insieme i due conteggi ed ottenere i conteggi totali fra le due serie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Map - Reduce\n",
    "\n",
    "il famoso metodo MAP-REDUCE è una combinazione di queste idee:\n",
    "\n",
    "* prendo una sequenza, la divido in sottosequenze\n",
    "* invio le sequenze a diversi computer\n",
    "* compio una riduzione su ciascuna sottosequenza\n",
    "* raccolgo le sottosequenze e le combino insieme\n",
    "* tutto questo fatto in modo ricorsivo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}