{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lez 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**list comprehensions**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[n for n in range(5)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# combinare elementi di due liste se non sono uguali\n",
    "[(x,y) for x in [1,2,3] for y in  [3,1,4] if x!=y]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrice = [\n",
    "...     [1, 2, 3, 4],\n",
    "...    [5, 6, 7, 8],\n",
    "...     [9, 10, 11, 12],\n",
    "... ]\n",
    "matrice     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  Calcolare la matrice trasposta\n",
    "[[ riga[i_colonna] for riga in matrice] for i_colonna in range(len(matrice[0]))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# scrivere con lambda la funzione dell'area del triangolo\n",
    "area = lambda h,b : b*h/2  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "area(3,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**map**(funzione, lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = lambda x: x+1\n",
    "lista =[1,2,3,4]\n",
    "list(map(f,lista)) #applica f a ogni elemento della lista e genera una nuova lista [f(1),f(2),f(3),f(4)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fare la mappa della funzione doppio x*2 dei primi 10 numeri interi.\n",
    "list(map(lambda x: x*2, range(1,11)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**filter**(funzione booleana, lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = lambda x: x>2\n",
    "lista =[1,2,3,4]\n",
    "list(filter(f,lista))  #filter(f_bool,list) filtra gli elementi che soddisfano il predicato f_bool."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fare la lista dei numeri pari dei primi 10 numeri interi.\n",
    "list(filter(lambda x: x%2==0,range(1,11)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**reduce**(funzione, lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce \n",
    "# ritorna un solo valore, chiamando ricorsivamente coppie di elementi\n",
    "reduce( lambda x,y: max(x,y) , [2,35,6,9] )   #somma degli elementi di una lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fare la sommma dei primi 5 numeri interi \n",
    "reduce(lambda x,y: x+y, range(1,6))\n",
    "# 1+2, 3+3, 6+4, 10+5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def creaListaCSV(file):\n",
    "    with open(file) as csvfile: \n",
    "        listaCSV=[]\n",
    "        for riga in csvfile:\n",
    "            s = riga.strip().split(';')\n",
    "            listaCSV.append(s)\n",
    "    return(listaCSV)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def creaListaCSVCompatta(file):\n",
    "    with open(file) as csvfile: \n",
    "        listaCSV = [riga.strip().split(';') for riga in csvfile]\n",
    "    return(listaCSV)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['TIZIO', 'CAIO'], ['4', '9'], ['3', '9'], ['5', '4'], ['10', '4'], ['5', '6'], ['12', '2'], ['10', '4'], ['7', '8'], ['7', '9'], ['5', '7'], ['2', '11'], ['2', '3'], ['4', '7'], ['6', '6'], ['12', '4'], ['12', '5'], ['10', '9'], ['12', '1'], ['1', '4'], ['5', '6'], ['8', '3'], ['4', '1'], ['12', '12'], ['10', '2'], ['2', '8'], ['7', '5'], ['8', '2'], ['8', '8'], ['7', '1'], ['1', '8'], ['4', '6'], ['7', '5'], ['7', '12'], ['12', '11'], ['8', '2'], ['8', '12'], ['10', '6'], ['6', '4'], ['6', '5'], ['3', '9'], ['5', '8'], ['10', '3'], ['3', '5'], ['4', '6'], ['8', '10'], ['1', '2'], ['7', '8'], ['4', '9'], ['10', '5'], ['8', '6']]\n"
     ]
    }
   ],
   "source": [
    "print(creaListaCSVCompatta(\"files/dadi.csv\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from libreria import creaLista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "fileDadi = creaLista(\"files/dadi.csv\")\n",
    "nomi = fileDadi [0]\n",
    "partite = fileDadi[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# trasformo stringhe in int\n",
    "n_partite = len(partite)\n",
    "n_giocatori = len(partite[0])\n",
    "for i in range(n_partite):  \n",
    "    for j in range(n_giocatori):\n",
    "        partite[i][j]=int(partite[i][j]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "vincite = [0 for i in  range(n_giocatori)]             # inizializzo a zero il vettore delle vincite\n",
    "patte = 0                                              # inizializzo a zero il numero di patte"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vincite: [23, 24]\n",
      "Patte: 3\n"
     ]
    }
   ],
   "source": [
    "for partita in partite:\n",
    "    if min(partita)!= max(partita):                     # controllo che almeno un punteggio sia diverso \n",
    "        for j in range(n_giocatori):\n",
    "            if partita[j] == max(partita):\n",
    "                vincite[j]+=1                           # incremento di 1 il numero di vincite del giocatore j-esimo\n",
    "    else:\n",
    "        patte +=1\n",
    "print('Vincite:',vincite)\n",
    "print('Patte:',patte)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['CAIO']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vincitori = [nomi[j] for j in range(n_giocatori) if vincite[j]==max(vincite)]\n",
    "vincitori"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['CAIO']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "winners=[]\n",
    "for j in range(n_giocatori):\n",
    "    if vincite[j]==max(vincite):\n",
    "        winners.append(nomi[j])\n",
    "winners"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcoloVincitori(file):\n",
    "    from libreria import creaLista\n",
    "    fileDadi = creaLista(file)\n",
    "    nomi = fileDadi [0]\n",
    "    partite = fileDadi[1:]\n",
    "    print(nomi)\n",
    "    \n",
    "    n_partite = len(partite)\n",
    "    n_giocatori = len(partite[0])\n",
    "    for i in range(n_partite):  \n",
    "        for j in range(n_giocatori):\n",
    "            partite[i][j]=int(partite[i][j]) \n",
    "        \n",
    "    vincite = [0 for i in  range(n_giocatori)]             \n",
    "    patte = 0 \n",
    "    for partita in partite:\n",
    "        if min(partita)== max(partita):  \n",
    "            patte +=1\n",
    "        else:\n",
    "            for j in range(n_giocatori):\n",
    "                if partita[j] == max(partita):\n",
    "                    vincite[j]+=1                                \n",
    "    print(vincite)\n",
    "    vincitori = [nomi[j] for j in range(n_giocatori) if vincite[j]==max(vincite)]\n",
    "        \n",
    "    return vincitori"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['TIZIO', 'CAIO']\n",
      "[23, 24]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['CAIO']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calcoloVincitori(\"files/dadi.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Copiare un file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_out=open(\"files/copiaProvaTesto.txt\",\"w\")       #apre un nuovo file, se c'è un altro con stesso nome lo distrugge\n",
    "with open(\"files/provaTesto.txt\",\"r\") as f_in: \n",
    "    for riga in f_in:\n",
    "        print(riga, end=\"\", file=f_out)          ### !!!! senza end=\"\" aggiungete una riga vuota ogni riga letta!!!!\n",
    "f_out.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# alternativa usando f_out.write()\n",
    "f_out=open(\"files/copiaProvaTesto2.txt\",\"w\")\n",
    "with open(\"files/provaTesto.txt\",\"r\") as f_in: \n",
    "    f_out.write(f_in.read())\n",
    "f_out.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filtra(f_in,f_out,parola):\n",
    "    f_out=open(f_out,\"w\") \n",
    "    with open(f_in, \"r\") as f_in: \n",
    "        for riga in f_in:\n",
    "            if parola in riga:\n",
    "                print(riga, end=\"\", file=f_out) \n",
    "    f_out.close() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtra(\"files/provaTesto.txt\",\"files/filtroProva.txt\",'file')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uso delle liste per pile e code\n",
    "\n",
    "Lista: sequenza di elementi [elemento, elemento, elemento]\n",
    "\n",
    "L'ordine della lista è l'unico modo per riconoscere gli elementi. Accesso sequenziale, visitabile tramite un indice!!! Posso metttere in ordine gli elementi solo se sono tutti dello stesso tipo!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pila\n",
    "In una pila l'elemento che si cancella è quello che viene inserito per ultimo. Lo stack implementa lo schema **LIFO** (Last In First Out) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pila = [3, 4, 5]\n",
    "pila.append(6)\n",
    "pila.append(7)\n",
    "print(pila)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pila.pop()    # per default pop rimuove l'ulitmo elemento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pila"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Coda\n",
    "L'elemento cancellato è quello che è rimasto più tempo nell'insieme. La queues implementa lo schema **FIFO** (First In First Out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coda = [3, 4, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coda.pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ex : \n",
    "Scrivere una funzione che valuta un'espressione scritta con la notazione polacca \n",
    "https://it.wikipedia.org/wiki/Notazione_polacca\n",
    "\n",
    "Consideriamo solo operazioni binarie: +,−,∗,/\n",
    "e solo valori interi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scannerizzare l’espressione da destra a sinistra\n",
    "\n",
    "per ogni simbolo:\n",
    "\n",
    "\tse il simbolo è un operando allora mettilo in una pila\n",
    "    \n",
    "\tse è un operatore op allora:\n",
    "    \n",
    "\t\ttogli il primo elemento dalla pila e salvalo in x\n",
    "        \n",
    "\t\ttogli il primo elemento dalla pila e salvalo in y\n",
    "        \n",
    "            spingi il risultato  x op y nella pila \n",
    "            \n",
    "ritorna la testa della pila come risultato"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hint:\n",
    "\n",
    "Creare una funzione isoperator(elem) che valuta se elem è un operatore op = +,-,\\,*. Creare una funzione comp(op,x,y) che dato un operatore op e due numeri x, y mi ritorna il risultato dell'operazione z = x op y . Creare una funzione polf(s) che scansione da destra gli elementi di s, se sono operandi li aggiunge ad una pila se sono operatori (lo valuta usando la funz isoperator(elem) ) rimuove dalla pila gli ultimi due elementi x,y e aggiunge alla pila il risultato di comp(op,x,y)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metodo per implementare un algoritmo\n",
    "\n",
    "- identificare nell'algoritmo la azioni di base da eseguire\n",
    "- per ogni azione fornire un'implementazione e testarla con l'interprete python\n",
    "- fare una funzione e testarla\n",
    "- combinare le varie implementazioni\n",
    "- testare la funzione nell'interprete di python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Soluzione Esercizio notazione polacca\n",
    "\n",
    "###### Algoritmo:\n",
    "\n",
    "- Scannerizzare l’espressione da destra a sinistra\n",
    "\n",
    "- per ogni simbolo:\n",
    "\n",
    "\t- se il simbolo è un operando allora mettilo in una pila\n",
    "    \n",
    "\t- se è un operatore op allora:\n",
    "    \n",
    "\t\t- togli il primo elemento dalla pila e salvalo in x\n",
    "        \n",
    "\t\t- togli il primo elemento dalla pila e salvalo in y\n",
    "        \n",
    "        - spingi il risultato  x op y nella pila \n",
    "            \n",
    "- ritorna la testa della pila come risultato\n",
    "\n",
    "\n",
    "###### Task:\n",
    "\n",
    "-1- scannerizzare l'espressione da destra a sinistra\n",
    "\n",
    "-2- verificare se il simbolo è un operatore od un operando\n",
    "\n",
    "-3- implementare le operazione di append e push e pop in python\n",
    "\n",
    "-4- dato un operatore, eseguire l'operazione associata"
   ]
  }
 ],
 "metadata": {
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}