{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lez1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y=2**4 #potenza\n",
    "x=2**5 # assegnazione\n",
    "print(x,y,sep=' [separatore] ', end=' [questo lo metto alla fine] ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a='ciao ' #stringa\n",
    "b= 'come va? ' # altra stringa\n",
    "c=a+b #concatenazione tra stringhe\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d=c*5 #concatenazione multiple \n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e= input('Inserisci un numero: ') # prendo un input da tastiera e lo salvo in e\n",
    "print('Hai scritto: {} il successore è {}'.format(e,int(e)+1)) # string.format,  \n",
    "print(type(e)) #considerate che e è una strnga!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "10/3 #divisione \n",
    "10//3 # dividendo di 10/3 \n",
    "10%3 #resto della divisione "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "123423%3 # 123423 è divisibile per 3!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lez2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prodotto(n,m): #definiamo una funzione!\n",
    "    p=n*m\n",
    "    return p\n",
    "\n",
    "print('Il prodotto di {} e {} fa {}'.format(2,3,prodotto(2,3)) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#le funzioni possono avere anche dei valor di default per gli argomenti\n",
    "def funzione(n,m=1,t=1):      # se io nella chiamata non do un valore al secondo argomento lui prende\n",
    "    p=n**m + t                 # quello di default\n",
    "    return p\n",
    "\n",
    "print(funzione(2))\n",
    "print(funzione(2,3))\n",
    "print(funzione(2,3,3))\n",
    "print(funzione(2,t=3)) #in questo caso m assume il valore di default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#operatore booleani\n",
    "a = True\n",
    "b = False \n",
    "print(a and b) #congiunzione\n",
    "print(a or b) #disgiunzione \n",
    "print(not a ) #negazione "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1/0 #chiaramente torna un errore \"division by zero\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#tuttavia se scrivo... \n",
    "False and 1/0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#... o se scrivo\n",
    "True or 1/0 \n",
    "#non succede nulla. Python non esegue la divisione perchè riesce ad assegnare il valore di verità alle due formule\n",
    "#indipendentemente da quello che viene scritto al secondo argomento ovvero 1/0, che quindi non verrà valutato!!. \n",
    "#Python esegue le operazioni solo se strettamente necessario (concetto di lazy evaluation). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Funzioni Booleane"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help('stringa'.isalpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'stri2222nga'.isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'10'.isdecimal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'10'.isdecimal() and 'stringa'.isalpha() and len('snixuniecerubceiurce')>10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# operatori di confronto.\n",
    "34>3\n",
    "2<3 \n",
    "3>=2\n",
    "3!=2 #3 diverso da 2\n",
    "(3<2) or (3>2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### If-else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=8\n",
    "if(n>3):\n",
    "    print('{} è maggiore di 3'.format(n))\n",
    "elif(0<=n<=3):\n",
    "    print('{} è compreso tra 0 e 3 (inclusi) '.format(n))\n",
    "else:\n",
    "    print('{} è negativo'.format(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lez3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### While"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "x=0                                       \n",
    "while x !=2:                              # condizione iniziale (per entrare all' inizio deve essere non soddisfatta!!)\n",
    "    x=random.randint(1,10)                # istruzione che modifica la condizione del while\n",
    "    print(x,end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lez4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### operatore *in*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = '+748'\n",
    "print('4' in s) #ritorna true se 4 è in s. VALE PER TUTTE LE STRUTTURE SEQUENZIALI come liste, tuple... ma anche per \n",
    "#i set etc... \n",
    "print(3 in ['2',3,789])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ciclo For"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "l'operatore in si usa per fare i cicli for.\n",
    "\n",
    "for i in sequenza di elementi:\n",
    "    \n",
    "    istruzioni eseguite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in 'disegno' :\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(4):  # lafunzione range(n) è usata per iterare da 0 fino a n-1\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(2,4):  #posso anche specificare da quele valore partire\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#classico esempio.... stampare tutti gli elementi della struttura sequenziale (una stringa in questo caso!)\n",
    "s ='ciaoo'\n",
    "for i in range(len(s)) :\n",
    "    print(s[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Funzioni Ricorsive \n",
    "Le funzioni possono richiamare se stesse, in modo ricorsivo. La struttura è la seguente\n",
    "\n",
    "def funzione(n):\n",
    "\n",
    "    if condizione di uscita (tipo n==0):\n",
    "        fai qualcosa\n",
    "    else:\n",
    "        funzione(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contoallarovesciaRic(n):\n",
    "    if n <= 0:\n",
    "        print('Via!')  # LA CONDIZIONE DI USCITA è FONDAMENTALE PER NON RIMANERE INCASTRATI NEL LOOP RICORSIVO!\n",
    "    else:\n",
    "        print(n)\n",
    "        contoallarovesciaRic(n-1)\n",
    "contoallarovesciaRic(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lez5\n",
    "\n",
    "#### Liste\n",
    "Sequenza ordinata di elementi eterogenei e **mutabili**!!! con può essere anche elementi di tipo diverso.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [\"ciao\", 2.0, 5, [10, 20]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#posso costruire una lista partendo range.\n",
    "list(range(2,10,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#posso costruire una lista partendo da una stringa.\n",
    "s1 = 'ciao come stai?'\n",
    "print(list(s1))\n",
    "#posso costruire una lista partendo da una stringa e applicando la funzione split.\n",
    "s2 = s1.split(' ') # equivalemente s1.split(\" \")\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Accedere a un elemento: **x[ indice ]** \n",
    "# <-- Python e molti altri linguaggi cominciano a contare da zero. \n",
    "x = [23,3,2,65, 6,7,8,9,10]\n",
    "y = x[1:6:2] #dall'elemento di indice 1 fino all'elemento di indice 6 (escluso), con step 2  .\n",
    "z = x[::2] #dall'inizio alla fine, con step 2. \n",
    "x, y, z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [23,3,2,65, 6,7,8,9,10]\n",
    "print([1,2]+[4,5])     # concatenazione\n",
    "print([1,2]*3)          # ripetizione  concatenata\n",
    "x[1:3]=['ciccia','casa','pluto'] #sostituisco gli elementi dall'indice 1 all'indice 3 (escluso)\n",
    "print(x) \n",
    "x[1:3]=[] #elimino gli elementi dall'indice 1 all'indice 3 (escluso)\n",
    "print(x) \n",
    "del x[0:2] #cancello i primi due elementi\n",
    "print(x) "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "**ord**\n",
    "Signature: ord(c, /)\n",
    "Docstring: Return the Unicode code point for a one-character string.\n",
    "Type:      builtin_function_or_method"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "**len**\n",
    "Signature: len(obj, /)\n",
    "Docstring: Return the number of items in a container.\n",
    "Type:      builtin_function_or_method"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "**in**\n",
    "Serve per vedere se un elemento è in una lista e per ciclare sulla lista con il for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#classico ciclo for\n",
    "for i in range(0,5,1):\n",
    "    print('x[{}]={}'.format(i,x[i]), end='   ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#assegnazione per liste\n",
    "list1 = ['carlo','magno']\n",
    "print('prima: list1='+str(list1))\n",
    "list2=list1 # list2 ed list1 puntano alla stesso oggetto in memoria. \n",
    "list2[0]='alessandro' #tutte le modifiche che faccio su list2 le sto facendo anche su list1!!!!\n",
    "print('dopo: list1='+str(list1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#quando si effettua la copia \n",
    "list3 = ['11',7,23]\n",
    "list4 = list3.copy()  # oppure list4=list3[:]\n",
    "# list4 punta a un oggetto diverso da list3\n",
    "print('list3 e list4  puntano allo stesso oggetto? '+str( id(list4)==id(list3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tuttavia al loro interno ci sono delle variabili list3[0],list3[1],list3[3], list4[0],list4[1],list4[3]\n",
    "#che puntano ai medesimi oggetti... \n",
    "for i in range(len(list3)):\n",
    "    print('list3[{}] e list4[{}] puntano allo stesso oggetto? {}'.format(i,i,id(list3[i])==id(list4[i])))\n",
    "# bisogna fare attenzione se alcuni di questi oggetti sono oggetti mutabili\n",
    "# occhio liste annidate\n",
    "# per copiare liste annidate posso usare deepcopy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# I metodi delle liste modificano l'oggetto di partenza, i metodi delle stringhe non modificano la lista stessa !!!!\n",
    "list3 = ['11',7,23]\n",
    "print(list3)\n",
    "print(list3.append(1000000))  ### aggiunge elemento a list 3 ma non restituisce nessun valore\n",
    "print(list3)\n",
    "list3.pop(0)             ### toglie elemento zero a list 3\n",
    "print(list3)\n",
    "list3.extend([6666,9999])           \n",
    "print(list3)\n",
    "list3.sort()           \n",
    "print(list3)\n",
    "\n",
    "print(list3*2)       # ho creato una nuova lista\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lez6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuple\n",
    "liste di valori separati da virgole!!!  Sono immutabili!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tupla1 = (2,)\n",
    "tupla2 = 2,\n",
    "print(type(tupla1), type(tupla2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(a,b,c) = (1,2,3)\n",
    "print('a =',a, ';  b =',b,';  c =',c, )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dizionari\n",
    "dizionario = {chiave: valore}, la chiave può essere un qualsisi oggetto **immutabile**, come tuple, stringe, interi etc..\n",
    "!!!! NON è una struttura ordinata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diz1 = dict()\n",
    "diz2 = {}\n",
    "print(type(diz1),type(diz2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Voti={'Antonio':27, 'Erica':30, 'Luca':20, 'Caterina':18 }\n",
    "Voti['Antonio']                      #leggere un valore\n",
    "Voti['Ludovica'] = 30                #aggiungere un elemento\n",
    "Voti['Antonio']=Voti['Antonio']-1    #cambiare un valore\n",
    "del Voti['Luca']                     #cancellare un elemento\n",
    "Voti"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(Voti))\n",
    "print(list(Voti.keys()))   #lista chiavi\n",
    "print(list(Voti.values())) #lista valori\n",
    "print(list(Voti.items()))  #lista chiavi-valori\n",
    "print('Ludovica' in Voti.keys() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#non è ordinato, e non rispetta l'ordine di inserimento!! \n",
    "for i in Voti:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lez7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set\n",
    "collezione non ordinata di oggetti **unici** e **immutabili**!!! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a={'a','a','a','c','b','s'} #a=set('s','5')\n",
    "b = set('abracadabra')\n",
    "print(type(a),type(b))\n",
    "a, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.add('pippo')\n",
    "print(a)\n",
    "a.remove('pippo')\n",
    "print(a)\n",
    "print ('a - b ', a - b)  # differenza\n",
    "print ('a | b ', a | b)  # unione, or logico.  \n",
    "print ('a & b ', a & b)  #intersezione, and logico.\n",
    "print('a^b      ' , a^b)           #simmetric difference\n",
    "print('a' in a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8]\n",
      "[0, 2, 4, 6, 8]\n",
      "[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6)]\n",
      "[[1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [3, 6, 9, 12, 15], [4, 8, 12, 16, 20], [5, 10, 15, 20, 25]]\n"
     ]
    }
   ],
   "source": [
    "pari1 = [2*n for n in range(5) ]\n",
    "print(pari1)\n",
    "pari2 = [n for n in range(10) if n%2==0]\n",
    "print(pari2)\n",
    "dadi = [(x,y) for x in range(1,7) for y in  range(1,7)]\n",
    "print(dadi)\n",
    "#definire la lista [[1,2,3,..,n],[2*1,2*2,...,2*n],...,[n*1,n*2,n*n]]\n",
    "def matrice(n):\n",
    "    return [[colonna*riga for colonna in range(1,n+1)] for riga in range(1,n+1)]\n",
    "print(matrice(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lettura  File\n",
    "open(file, mode=**'r'**, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open('files/provaTesto.txt','r')  #leggo\n",
    "for line in file:\n",
    "    print(line.strip())\n",
    "file.close()  #dopo aver lavorato con un file bisogna chiuderlo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# per non dover ogni volta chiudere il file posso usare with:\n",
    "with open('files/provaTesto.txt') as file: \n",
    "    s=file.read()   # stringa\n",
    "print(type(s), s)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('files/provaTesto.txt') as file: \n",
    "    s=file.readlines()      # lista\n",
    "print(type(s), s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lez8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scrittura File \n",
    "open(file, mode=**'w'**, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"files/example.txt\", \"w\") as file: #file è una variabile che si riferisce al file testuale (examples.txt) che ho creato \n",
    "    file.write(\"ciao\\ncome va?\\n\")           # nella cartella files in modalità di lettura (\"w\") \n",
    "    \n",
    "with open('files/example.txt') as file: \n",
    "    s=file.read()\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aggiunta di testo su File \n",
    "open(file, mode=**'a'**, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"files/example.txt\", \"a\")as file:\n",
    "    file.write(\"ciao\\ncome va?\\n\")\n",
    "    \n",
    "with open('files/example.txt') as file: \n",
    "    s=file.read()\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### lambda Expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#funzioni anonime\n",
    "f = lambda x : x*2      ## f(x)=x*2\n",
    "g = lambda x : x+1      ## f(x)=x+1\n",
    "somma = lambda x,y: x+y    ## somma(x,y) = x+y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### map , filter e reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#map (f, [1,2,3,4]) applica f a ogni elemento della lista e genera una nuova lista [f(1),f(2),f(3),f(4)]\n",
    "list(map(lambda x: x+1,[1,2,3,4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#filter(f,list) filtra gli elementi che soddisfano il predicato f.\n",
    "list(filter(lambda x: x>2,[1,2,3,4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#reduce si trova in un pacchetto specifico. \n",
    "from functools import reduce # con questa lista stiamo dicendo dal package functools prendi la funzione reduce\n",
    "product = reduce((lambda x, y: x * y), [1, 2, 3, 4])\n",
    "print(product)"
   ]
  }
 ],
 "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
}