{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ricapitolazione Lez 1\n",
    "\n",
    "- Ambienti di programmazione, python IDLE, shell ed editor di file \n",
    "- Istruzione di stampa (print())\n",
    "- Gestione delle espressioni nella shell o nell’editor\n",
    "- Tipi intero, stringa, float, algebre sul tipo, \n",
    "- funzione type(), e funzioni per  cambiare tipo, int(), str()\n",
    "- Istruzione di assegnazione (e.g. x = 5)\n",
    "- Istruzione di input()\n",
    "- funzioni f(x), funzioni di una certa classe x.f()\n",
    "- librerie, es librerie math e random\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lezione 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Buona programmazione: nomi parlanti, commenti\n",
    "\n",
    "I nomi devono sempre iniziare con una lettera, parole composte CiaoGigi o Ciao_gigi. \n",
    "Usare sempre nomi sensati che aiutino a comprender il codice\n",
    "\n",
    "Di solito lettere tutte maiuscole usate per costanti. è una convenzione!\n",
    "\n",
    "Python ha 28 parole riservate che non si possono usare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "and = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int = 5   # è un problema di python, negli altri linguaggi da errore se usi nomi predefiniti\n",
    "           # stesso errore in matlab (provate con min e max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int('5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print = 5\n",
    "print ('ciao')    # avete ucciso la funzione predefinita di python "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "primoElem = 5\n",
    "    secElem = 5 # attenti all'indentazione\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funzioni "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int('5') # restituisce un valore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = print('5') # non restituisce niente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len('stringa')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'stringa'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = x.replace('r','a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definizione di funzioni"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "def <nome funzione> (<parametri formali>):              # intestazione\n",
    "    blocco di istruzioni                                # corpo\n",
    "    return<valore>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def raddoppia (n):    # input\n",
    "    n=n*2\n",
    "    return n          # output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raddoppia(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!!!! Una funzione può avere o no input, output ed effetti collaterali !!!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = raddoppia(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stampaciao():\n",
    "    print('ciao')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stampaciao()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Java ed in C dovete dichiarare in anticipo il tipo dentro la funzione! Questo permette un controllo più forte, è più robusto, ho un controllo maggiore su quello che succede!\n",
    "In python no, potente ma anche pericoloso! Python non prevede il controllo di tipi!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raddoppia('cavolo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raddoppia([0,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raddoppia(raddoppia(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def raddoppia (n):             # n è il parametro FORMALE  \n",
    "    n=n*2\n",
    "    return n\n",
    "\n",
    "raddoppia(4)                # 4 è il parametro ATTUALE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OSS: Ricordatevi che vedete il risultato di raddoppia (6) solo dentro la shell, se scrivete sull'editor la funzione radoppia(6) senza assegnarla a nessuna variabile, l'istruzione non viene visualizzata ed è completamente persa!State attenti! La shell va usata per capire, è comodo vedere il risultato subito!!! Non programmate tutto dentro la shell!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def raddoppia (n):       # variabili e parametri sono locali      \n",
    "    a=n*2                # non c'è memoria fuori dei valori assegnati dentro \n",
    "    b=5                  # ad una def di funzione se non li ritorno          \n",
    "    return a             # i nomi delle variabili sono locali"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ildoppio = raddoppia(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ildoppio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Funzioni con più parametri "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prodotto(n,m):\n",
    "    p=n*m\n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tab vede anche la nostra funzione ora\n",
    "prodotto(3,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I parametri della chiamata (i parametri attuali) devono corrispondere come numero a quelli formali a meno che io non abbia dato un valore di default ai miei parametri. \n",
    "(In altri linguaggi anche il tipo deve essere lo stesso)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funzioni con parametri inizializzati"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def potenza(n,m=1):      # se io nella chiamata non do un valore al secondo param lui prende\n",
    "    p=n**m                 # quello di default\n",
    "    return p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anche questo è difficile da fare con altri linguaggi di programmazione!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "potenza(2,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!!!! I default devono sempre essere in fondo alla lista !!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "potenza(2,m=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lavorare per funzioni permette di separare i problemi!!!\n",
    "\n",
    "Esempio: i controlli che un numero in input sia un intero dentro il codice appesantice il codice, faccio il controllo in modo differente. La soluzione è scrivere una funzione una volta per tutte che controlla che il numero è intero!!!\n",
    "\n",
    "Le funzioni ci permettono di concentrare istruzioni complesse in un blocco di codice con un nome di vostra fantasia\n",
    "\n",
    "Un funzione può richiamare un'altra funzione!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stampaFrase():\n",
    "    print('La gallina fa le uova')\n",
    "\n",
    "def ripeti2volteFrase():\n",
    "    stampaFrase()\n",
    "    stampaFrase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ripeti2volteFrase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ripeti2volte(f):\n",
    "    f()\n",
    "    f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ripeti2volte(stampaFrase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nel leggere un programma non è sempre opportuno farlo dall’alto in basso. Spesso è più logico seguire il flusso di esecuzione.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sviluppo incrementale:\n",
    "- Inizia con un programma funzionante e fai piccoli cambiamenti\n",
    "- Usa variabili temporanee per memorizzare i valori intermedi, per stamparli e controllarli\n",
    "- Alla fine rimuovi le istruzioni temporanee e componi le istruzioni se non complica troppo il programma"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### ESPRESSIONE BOOLEANA\n",
    "Il tipo booleano ha dominio {True, False}, è un dominio finito. \n",
    "###### Operatori: and, or, not.\n",
    "NB: in python un'espressione vera ha valore 1, la falsa ha valore zero, in più ogni valore diverso da zero viene considerato vero. Questo può generare errori. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(True), int(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3 or True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!  Evitate di usare i numeri nelle espressioni logiche"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and x == 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not False   # diffidate dei not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not not False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Operatori di confronto: \n",
    "operatori che ritornano un valore booleanio: >,<,>=,<=, ==,!="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5>3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3>=4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 == 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5!=7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "soluz = 5==7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "soluz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "soluz == False"
   ]
  },
  {
   "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": "markdown",
   "metadata": {},
   "source": [
    "Ragionate a basso livello! Pezzetto per pezzetto!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IF ELSE ELIF\n",
    "Esecuzione condizionale. Primo costrutto di programmazione.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=5 \n",
    "y=-5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if x>0:\n",
    "    print(x, 'è maggiore di zero')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if y>0:\n",
    "    print(y, 'è maggiore di zero')\n",
    "else:\n",
    "    print(y, 'è minore o uguale a zero')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#programma che controlla ingresso input\n",
    "nUtente=input(\"Inserisci un numero intero: \")\n",
    "\n",
    "#  verifico che la stringa contenga un numero con o senza segno\n",
    "if nUtente.isdecimal():\n",
    "    n=int(nUtente)\n",
    "    print(\"Intero inserito=\",n )\n",
    "else:\n",
    "    print(\"Il valore inserito non è un intero\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#funzione che controlla ingresso input\n",
    "def controlloInput(stringa):\n",
    "    if stringa.isdecimal() or ((stringa[0] == '-' or stringa[0] == '+')and stringa[1:].isdecimal()):\n",
    "        n=int(stringa)\n",
    "        print(\"Intero inserito=\",n )\n",
    "    else:\n",
    "        print(\"Il valore inserito non è un intero\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "controlloInput(input(\"Inserisci un numero intero: \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stringa = '-566'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stringa[1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Potrebbe servirvi in concetto di sottostringa che vi manca"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'Aciao io mi chiamo gigi'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0:3]  \n",
    "# sottostringa con i caratteri di s \n",
    "# da quello in posizione uno (indice 0) a quello in posizione 3 (indice 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sottostringhe:  s[j:k] include l'indice j ed esclude indice k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s =' 5'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.isdecimal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=' cia'\n",
    "s.count('')     # python conta spazi vuoti prima in mezzo ed alla fine di una stringa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=' cia      '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sbis= s.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sbis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sbis.isdecimal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(s.strip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = ' ciao io mi chiamo gigi            '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solo in python si può usare insieme <,<, eg 0≤x≤5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 7\n",
    "if 0<z<=5:\n",
    "    print(z, 'è compreso tra ]0,5]')\n",
    "else: \n",
    "    print(z, 'non è compreso tra ]0,5]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# vedere se z è tr ]0,5] o ]5,10] o è maggiore di 10 \n",
    "#o è minore o uguale a zero\n",
    "\n",
    "if 0<z<=5:\n",
    "    print(z, 'è compreso tra ]0,5]')\n",
    "else:\n",
    "    if  5<z<=10:\n",
    "        print(z, 'è compreso tra ]5,10]')\n",
    "    else: \n",
    "        if z>10:\n",
    "            print(z, 'è maggiore di 10')\n",
    "        else:\n",
    "            print(z, 'è minore o uguale a zero')\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 0<z<=5:\n",
    "    print(z, 'è compreso tra ]0,5]')\n",
    "elif 5<z<=10:\n",
    "    print(z, 'è compreso tra ]5,10]')\n",
    "elif z>10:\n",
    "    print(z, 'è maggiore di 10')\n",
    "else:\n",
    "    print(z, 'è minore o uguale a zero')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if z>5 and z <= 10:\n",
    "    print(z, 'è compreso tra ]5,10]')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Confronto fra reali\n",
    "il numero di bit dedicato ai reali è finito, c'è un approssizmazione\n",
    "e spesso == non va bene"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from math import *\n",
    "sqrt(2)**2==2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2.0 == 's'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "epsilon = 1e-15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(sqrt(2)**2-2) < epsilon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1e308 +1e308"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Esercizio\n",
    "L’ultimo teorema di Fermat afferma che non esistono interi positivi a, b, e c tali che \n",
    "a^n + b^n = c^n per qualsiasi valore di n maggiore di 2.\n",
    "\n",
    "1. Scrivete una funzione di nome verifica_fermat che richieda quattro parametri—a, b, c e n e controlli se il teorema regge. Se n è maggiore di 2 e fosse a^n + b^n = c^n il programma dovrebbe visualizzare: “Santi Numi, Fermat si è sbagliato!”, altrimenti: “No, questo non è vero.”\n",
    "\n",
    "2. Scrivete una funzione che chieda all’utente di inserire valori di a,b,c e n, li converta in interi e usi verifica_fermat per controllare se violano il teorema di Fermat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}