Questo file contiene le soluzioni di molti degli esercizi proposti, divise per lezione. Per eseguire i programmi basterà copiare ed incollare la parte che ci interessa nell'editor di Python. Per gli esempi in IDLE bisognerà digitare solo quello che è scritto dopo il prompt >>>

LEZIONE 1

ESERCIZIO 1.2 Riduciamo ad un angolo < 360° usando l'operatore modulo


>>> 5132 % 360
92

ESERCIZIO 1.3 Prima sommiamo le 549 ore e poi riduciamo ad un numero < 24


>>> (16 + 549) % 24
13

ESERCIZIO 1.4


>>> (5 + 3) / (6 - 2)
2.0
>>> 25 ** (1 / 2)
5.0
>>> 3 * (2 + 5) - 10 / (4 - 2)
16.0
>>> (3 * (5 - 3)) ** 2
36

LEZIONE 2

ESERCIZIO 2.1 Conviene usare gli operatori sulle stringhe


>>> 5 * "m "

'm m m m m '

>>> 3 * "Mamma" + 5 * "Ma"

'MammaMammaMammaMaMaMaMaMa'

>>> 3 * "cane " + 3 * "cane"

'cane cane cane canecanecane'

(va bene anche "m " * 5 etc.)

LEZIONE 3

ESERCIZIO 3.1 Ecco degli esempi. L'importante è usare la divisione intera nel primo caso e la divisione comune nel secondo


>>> 10 // 2

5

>>> 10 / 2

5.0

ESERCIZIO 3.2 Usiamo delle variabili per le stringhe. Nel secondo esempio ho cercato di dare alle variabili dei nomi che mi ricordassero il loro contenuto


>>> a = "Sa"
>>> b = "So"
>>> a + 2 * b + 4 * a + 2 * b

'SaSoSoSaSaSaSaSoSo'

>>> z = "Zio "
>>> n = "Nonna "
>>> 3 * z + 2 * n + z

'Zio Zio Zio Nonna Nonna Zio'

ESERCIZIO 3.3 e 3.4 Ecco un esempio. Abituatevi a ripetere le istruzioni quasi uguali in IDLE usando i tasti freccia su e freccia giù ed Invio


>>> media = 8.5
>>> reddito = 35000
>>> media > 8 and reddito < 30000

False

>>> media = 8.1
>>> reddito = 27000
>>> media > 8 and reddito < 30000

True

>>> (media > 8 and reddito < 30000) or (media > 7.5 and reddito < 20000)

True

>>> media = 7.6
>>> reddito = 19000
>>> (media > 8 and reddito < 30000) or (media > 7.5 and reddito < 20000)

True

LEZIONE 4

ESERCIZIO 4.1 e 4.2 Le due ultime espressioni per risolvere il 4.2 sono equivalenti


>>> pw = "12345"
>>> len(pw) == 8

False

>>> pw = "12345678"
>>> len(pw) == 8

True

>>> pw2 = "90"
>>> len(pw + pw2) == 10

True

>>> len(pw) + len(pw2) == 10

True

ESERCIZIO 4.3 e 4.4


>>> t1 = 29.5
>>> t2 = 28
>>> t3 = 28.5
>>> max(t1, t2, t3)

29.5

>>> max(t1, t2, t3) > 35

False

LEZIONE 5

ESERCIZIO 5.1 e 5.2 Ecco il programma prova_print.py completo


print ("mamma", "ti", "amo")
a = 4
b = 6
print (a, "+",  b, "=", a + b)
c = 5
print ("Il quadrato di", c, "e'", c ** 2)

ESERCIZIO 5.3 e 5.5 Ecco le versioni finali di hello.py e prova_print.py con i commenti proposti


# Questo e' il mio primo programma
print("Hello world!")
print ("Ciao mondo!")
print ("HAHAHAHA")

# Questo programma dimostra l'uso della funzione print()
print ("mamma", "ti", "amo")
a = 11345
b = 23469
print (a, "+",  b, "=", a + b)
c = 843
print ("Il quadrato di", c, "e'", c ** 2)

LEZIONE 6

ESERCIZIO 6.1


nome = input("Come ti chiami? ")
mamma = input("Come si chiama la tua mamma? ")
print(mamma, "e' la mamma di", nome)

ESERCIZIO 6.2 Ecco la versione definitiva di doppio_quadrato.py


a = float(input("Scrivi un numero "))
print("Il doppio di", a, "e'", 2 * a)
print("Il quadrato di", a, "e'", a ** 2)
print("Il cubo di", a, "e'", a ** 3)

ESERCIZIO 6.3 Programma operazioni.py: abituatevi a distinguere i caratteri all'interno delle stringhe (che servono solo per la stampa) dagli operatori (analizzate bene le righe 3 e 4)


a = float(input("Scrivi un numero "))
b = float(input("Scrivi un altro numero "))
print(a, "+", b, "=", a + b)
print(a, "x", b, "=", a * b)

ESERCIZIO 6.4 Programma per l'area del rettangolo


# AREA DEL RETTANGOLO
print("Calcolo dell'area di un rettangolo")
b = float(input("base = "))
h = float(input("altezza = "))
area = b * h
print("L'area del rettangolo e'", area)

da notare che i programmatori preferiscono non usare troppe variabili intermedie: se l'espressione da calcolare non è molto complessa è preferibile scriverla direttamente all'interno della print() (in ogni caso è solo questione di gusti personali, entrambe le versioni vanno bene)


# AREA DEL RETTANGOLO
print("Calcolo dell'area di un rettangolo")
b = float(input("base = "))
h = float(input("altezza = "))
print("L'area del rettangolo e'", b * h)

ESERCIZI 6.5 e 6.6 simili al 6.4


# AREA DEL CERCHIO
print("Calcolo dell'area di un cerchio")
r = float(input("raggio = "))
print("L'area del cerchio e'", 3.1415 * r ** 2)

# CONVERSIONE CELSIUS - FAHRENEIT - KELVIN
print("Conversione temperature")
c = float(input("gradi C = "))
print(c, "gradi Celsius corrispondono a", c * 1.8 + 32, "gradi Fahreneit")
print(c, "gradi Celsius corrispondono a", c + 273.15, "gradi Kelvin")

LEZIONE 7

ESERCIZIO 7.1 Ecco il programma prova_if.py completo


a = int(input("Scrivi un numero > 10 "))
if a > 10:
    print("Bravo!")
    print("Bravissimo!")
    print("Sei proprio intelligente!")
print("Ciao")

ESERCIZIO 7.2 e 7.3 I programmi pari_dispari.py e scrivi_parola.py. Notate che, dato che la input() non va a capo dopo aver stampato il prompt, è consigliabile terminarlo con uno spazio, in modo che la domanda sia separata dalla risposta dell'utente (provate ad eliminare l'ultimo spazio della stringa "Scrivi un numero ")


a = int(input("Scrivi un numero "))
if a % 2 == 0:
    print("Il numero e' pari")
else:
    print("Il numero e' dispari")

s = input("Scrivi una parola di cinque lettere ")
if len(s) == 5:
    print("Bravo!")
else:
    print("Hai sbagliato!")

ESERCIZIO 7.4 Il programma ordinazioni.py nella versione più semplice: gli if lo suddividono in 4 "rami" diversi: cercate di analizzarlo per capire quale di essi viene eseguito a seconda delle risposte. Al posto della variabile t avrei potuto anche riusare la s, perchè dopo l'entrata nel primo if non ne ho più bisogno (almeno in questo esempio)


s = input("Vuoi la pasta o la pizza? ")
if s == "pizza":
    t = input("margherita o funghi? ")
    if t == "margherita":
        print("Costo: 5 euro")
    else:
        print("Costo: 6 euro")
elif s == "pasta":
    t = input("carbonara o amatriciana? ")
    if t == "carbonara":
        print("Costo: 7 euro")
    else t == "amatriciana":
        print("Costo: 7.50 euro")

ESERCIZIO 7.5 La versione più complessa di ordinazioni.py: questa volta esso è suddiviso in 7 "rami" diversi.


s = input("Vuoi la pasta o la pizza? ")
if s == "pizza":
    t = input("margherita o funghi? ")
    if t == "margherita":
        print("Costo: 5 euro")
    elif t == "funghi":
        print("Costo: 6 euro")
    else:
        print("Input scorretto")
elif s == "pasta":
    t = input("carbonara o amatriciana? ")
    if t == "carbonara":
        print("Costo: 7 euro")
    elif t == "amatriciana":
        print("Costo: 7.50 euro")
    else:
        print("Input scorretto")
else:
    print("Input scorretto")

ESERCIZIO 7.6 Ed ecco infine il programma per l'equazione di secondo grado. Notate che questa volta nelle righe 9, 13, 14 ho preferito creare delle variabili intermedie, per evitare di scrivere nelle print() delle espressioni molto complicate, che avrebbero reso il programma poco leggibile


from math import *
a = float(input("Immettere il coefficiente a "))
b = float(input("Immettere il coefficiente b "))
c = float(input("Immettere il coefficiente c "))
delta = b ** 2 - 4 * a * c
if delta < 0:
    print("L'equazione non ha soluzioni")
elif delta == 0:
    x1 = - b / (2 * a)                # riga 9
    print("L'equazione ha una sola soluzione:")
    print("x12 =", x1)
else:
    x1 = (-b - sqrt(delta)) / (2 * a) # riga 13
    x2 = (-b + sqrt(delta)) / (2 * a) # riga 14
    print("L'equazione ha due soluzioni")
    print("x1 =", x1, "x2 =", x2)

LEZIONE 8

ESERCIZIO 8.1 Il programma risposta.py


risp = "s"
while risp == "s":
    risp = input("Vuoi giocare ancora (s/n)? ")
print("Ciao!")

ESERCIZI 8.2 - 8.4 Ed ecco il programma indovina_numero.py con tutte le modifiche proposte: ho inserito numerosi commenti per spiegare il significato di ogni riga


from random import *                  # verra' spiegata in seguito
record = 1000000000                   # inizializza il record in modo che sia battuto la prima
                                      # volta che si gioca
risp = "s"                            # inizializza il while piu' esterno
while risp == "s":
    num = randrange(1, 21)            # genera un numero casuale da 1 a 20
    tentativi = 0                     # inizializza il numero di tentativi all'inizio del gioco
    print ("Ho pensato un numero da 1 a 20. Prova ad indovinarlo!")
    mio_num = -1                      # inizializza mio_num ad un valore sicuramente diverso da num ...
    while mio_num != num:             # ... quindi la prima volta entra sicuramente nel while
        tentativi += 1                # incrementa i tentativi
        mio_num = int(input("??? "))  # mio_num e' il nostro tentativo
        if mio_num < num:
            print("Troppo basso")
        elif mio_num > num:
            print("Troppo alto")
    print("Hai indovinato! Hai impiegato", tentativi, "tentativi")
    if tentativi < record:           # sicuramente vero la prima volta (record e' 1000000000)
        print("Hai battuto il tuo record!")
        record = tentativi           # assegna il nuovo record
    risp = input("Vuoi giocare ancora (s/n)? ")
print("Ciao!")

ESERCIZI 8.5 e 8.6 Il programma tabelline.py


n = int(input("Quale tabellina vuoi stampare? ")) # n dovrebbe essere un intero
i = 1                                             # inizializza il contatore
while i < 11:                                     # o while i <= 10
    print(n, "x", i, "=", n * i)
    i += 1

ESERCIZIO 8.7 Tavola dei quadrati e cubi


i = 1                                            # inizializza il contatore
while i < 101:                                   # o while i <= 100
    print(i, "\t", i ** 2, "\t", i ** 3)
    i += 1

LEZIONE 9

ESERCIZIO 9.1 Ecco il programma divisibilita.py modificato


n = int (input("Scrivi un numero "))    # controlliamo se questo numero è primo
k = 2                                   # contatore (parte da 2 ...)
while k <= n // 2:                      # ... e arriva a n//2 (non c'e' bisogno di
                                        # farlo arrivare a n)
    if n % k == 0:                      # se questo e' vero, n e' divisibile per k
        print(n, "e' divisibile per", k)
        break                           # trovato un divisore, usciamo dal ciclo
    k += 1                              # altrimenti incrementiamo il contatore
else:
    print (n, "e' un numero primo")     # viene eseguita solo se non si e' usciti con il break

ESERCIZIO 9.2 Il programma risposte.py modificato. Notate nella riga 8 la concatenazione degli operatori booleani <= (quasi tutti gli altri linguaggi obbligano a scrivere, in una situazione come questa, if 3 <= n and n <= 15).


while True:
    risp = input("Vuoi una tazzina di caffe'? (s/n) ")
    if risp == "s" or risp == "n":
        break
    print("Input non valido")
while True:
    n = int(input("Scrivi un numero da 3 a 15 "))
    if 3 <= n <= 15:           # riga 8
        break
    print("Input non valido")

LEZIONE 10

ESERCIZI 10.2 - 10.4 Ecco il programma banco.py con tutte le modifiche proposte. Anche qui ho usato (due volte) la concatenazione degli operatori booleani < (in ogni caso essa si può comunque sostituire con un and tra le due espressioni booleane).


from random import *

punti = 100
while 0 < punti < 200:                # riga 5: ciclo principale
    while True:                       # controlla la puntata
        puntata = int(input("Quanto vuoi puntare? "))
        if 0 <= puntata <= punti:
            break                     # controlla la validita' della puntata
        print("Input non valido") 
    carta = randrange(1, 11)          # estrae la carta    
    print("E' uscito", carta)
    if carta < 6:                  # il giocatore ha perso
        punti -= puntata              # sottrae la puntata dai punti
        print("Hai perso!")
    else:                             # il giocatore ha vinto
        punti += puntata              # somma la puntata ai punti
        print("Hai vinto!")
    print("Il tuo nuovo punteggio e'", punti)	
if punti <= 0:                        # esce dal ciclo principale
    print("Ti ho battuto! Hai perso tutto!")
else:
    print("Bravo! Hai raggiunto 200 punti!")

LEZIONE 11

ESERCIZIO 11.2 Ecco la sequenza dei comandi che dovete dare in IDLE. Se volete controllare tra un comando e l'altro gli elementi della lista capitali, basta digitare il suo nome e premere Invio


>>> capitali = []
>>> capitali.append("Roma")
>>> capitali.append("Parigi")
>>> capitali.append("Londra")
>>> capitali.insert(1, "Madrid")
>>> len(capitali)

4

>>> capitali.reverse()
>>> capitali.remove("Roma")
>>> capitali.append("Parigi")
>>> capitali.append("Parigi")
>>> capitali.append("Parigi")
>>> capitali.append("Parigi")
>>> capitali.count("Parigi")

5

>>> len(capitali)

7

>>> capitali.sort()
>>> capitali.clear()

ESERCIZIO 11.4


>>> numeri = [2, 4, 6, 8, 10]
>>> numeri[0] = 2 * numeri[1]
>>> numeri[4] = 3 * numeri[2]
>>> numeri[2] = 2 * numeri[2]   # oppure numeri[2] *= 2
>>> numeri

[8, 4, 12, 8, 18]

ESERCIZIO 11.5 - 11.7 Ecco il programma statistiche_voti.py con tutte le modifiche proposte. Notate come ho risolto il problema della input(): scrivere input("Inserisci il tuo voto in", i) provocherebbe un errore, perchè la funzione prende un solo argomento, quindi è necessario usare gli operatori sulle stringhe. Leggete con attenzione i commenti.


materie = ("Italiano", "Matematica", "Storia", "Geografia", "Inglese")
voti = []
i = 0
while i < len(materie):   # meglio di i < 5, se aggiungo altre materie non devo modificarlo
    v = int(input("Inserisci il tuo voto in " + materie[i] + " "))
                          # la input prende come argomento UNA SOLA STRINGA
    voti.append(v)        # e' possibile anche una sola istruzione: voti.append(int(input(...
    i += 1                # prossimo voto
i = 0                     # il contatore deve essere reinizializzato
while i < len(materie):
    print("Il tuo voto in", materie[i], "e'", voti[i])
    i += 1
print("La tua media e'", sum(voti) / len(voti))
m = min(voti)
ind = voti.index(m)
print("Il tuo voto piu' basso e'", m, "in", materie[ind])
m = max(voti)             # possiamo riutilizzare le stesse variabili
ind = voti.index(m)       # evitando di crearne di nuove
print("Il tuo voto piu' alto e'", m, "in", materie[ind])

LEZIONE 12

ESERCIZIO 12.1 Ecco i comandi in IDLE. Ho convertito direttamente i range in liste per poter verificare l'esattezza ed ho omesso l'output di IDLE


>>> list(range(1, 101))
>>> list(range(2, 201, 2))
>>> list(range(1, 1002, 4))
>>> list(range(10, -1, -2))
>>> list(range(-1, -11, -1))

il secondo parametro potrebbe essere diverso se lo step è maggiore di 1 (ad esempio range(1, 1002, 4) e range(1, 1003, 4 producono lo stesso risultato): ricordate comunque che non è mai compreso nel range che si ottiene

LEZIONE 13

ESERCIZIO 13.1 Ecco i programmi divisibilita.py, prova_continue.py e statistiche_voti.py modificati con i cicli for. Notate che nel primo ho dovuto adattare la condizione di controllo: per essere sicuro che il numero n // 2 sia incluso nel range devo scrivere come secondo parametro n // 2 + 1


n = int (input("Scrivi un numero "))    # controlliamo se questo numero è primo
for k in range(2, n // 2 + 1):          # per essere sicuro che n // 2 sia incluso
    if n % k == 0:                      # se questo e' vero, n e' divisibile per k
        print(n, "e' divisibile per", k)
        break                           # trovato un divisore, usciamo dal ciclo
else:
    print (n, "e' un numero primo")     # viene eseguita solo se non si e' usciti con il break

salta = int(input("Che numero devo saltare? "))
for i in range(1, 101):                 # numeri da 1 a 100
    if i == salta:
        continue
    print("i =", i)
    print("Il quadrato di i e'", i ** 2)
    print("Il cubo di i e'", i ** 3)
print ("Fine")

materie = ("Italiano", "Matematica", "Storia", "Geografia", "Inglese")
voti = []
for i in materie:         # qui possiamo iterare sugli elementi
    v = int(input("Inserisci il tuo voto in " + i + ": "))
                          # la input prende come argomento UNA SOLA STRINGA
    voti.append(v)        # e' possibile anche una sola istruzione: voti.append(int(input(...
for i in range(len(materie)):    # qui dobbiamo iterare sugli indici
    print("Il tuo voto in", materie[i], "e'", voti[i])
print("La tua media e'", sum(voti) / len(voti))
m = min(voti)
ind = voti.index(m)
print("Il tuo voto piu' basso e'", m, "in", materie[ind])
m = max(voti)             # possiamo riutilizzare le stesse variabili
ind = voti.index(m)       # evitando di crearne di nuove
print("Il tuo voto piu' alto e'", m, "in", materie[ind])

ESERCIZIO 13.2 Ecco l'ulteriore modifica di statistiche_voti.py


materie = ("Italiano", "Matematica", "Storia", "Geografia", "Inglese")
voti = []
for i in materie:         # qui possiamo iterare sugli elementi
    v = int(input("Inserisci il tuo voto in " + i + " "))
                          # la input prende come argomento UNA SOLA STRINGA
    voti.append(v)        # e' possibile anche una sola istruzione: voti.append(int(input(...
for i in range(len(materie)):    # qui dobbiamo iterare sugli indici
    print("Il tuo voto in", materie[i], "e'", voti[i])
print("La tua media e'", sum(voti) / len(voti))
m = min(voti)
ind = voti.index(m)
print("Il tuo voto piu' basso e'", m, "in", materie[ind])
m = max(voti)             # possiamo riutilizzare le stesse variabili
ind = voti.index(m)       # evitando di crearne di nuove
print("Il tuo voto piu' alto e'", m, "in", materie[ind])
insuff = 0
for i in range(len(materie)): # va bene anche: for i in voti:
    if voti[i] < 6:           # if i < 6: 
        insuff += 1
if insuff > 0:
    print("Hai", insuff, "insufficienze")
else:
    print("Bravo! Non hai nessuna insufficienza!")

ESERCIZIO 13.3 Il programma temperature.py. Anche qui notate come ho costruito il prompt della input().


citta = ["Torino", "Milano", "Venezia", "Bologna", "Firenze", "Roma", "Napoli", "Bari"]
temp = []
for i in citta:              # iteriamo sugli elementi della lista
    t = int(input("Immetti la temperatura di " + i + " "))
    temp.append(t)
for i in range(len(citta)):  # iteriamo sugli indici
    print(citta[i], ":\t", temp[i])

anche nel primo ciclo avremmo potuto iterare sugli indici, con una sintassi un po' più complicata. E' possibile usare una sola istruzione anche nel primo ciclo (provate).

Notate anche che il tab "\t" non funziona bene quando scriviamo la temperatura di Roma e Bari, perchè questi nomi sono troppo corti. Per il momento potremmo ovviare a questo con un trucchetto: scrivere "Roma   " e "Bari   " con degli spazi finali (ci sono comunque delle istruzioni Python per ottenere un output corretto)

LEZIONE 15

ESERCIZIO 15.1 - 15.2 Per ottenere la prima cifra di un numero n di due cifre basta eseguire la divisione intera n // 10 (la divisione normale non va bene perchè ci restituirebbe un numero con la virgola). Invece per ottenere la seconda cifra basta scrivere n %10 (è il resto della divisione per 10).


from random import *

semi = ["denari", "coppe", "spade", "bastoni"]
valori = ["asso", "due", "tre", "quattro", "cinque", "sei", "sette", "fante", "cavallo", "re"]
carte = []
while True:
    risp = input("Premi q per uscire, Invio per estrarre una carta ")
    if risp == "q":
        break
    if len(carte) == 0:
        carte = list(range(40))
        shuffle(carte)
        print("Attendi! Sto mescolando il mazzo ...")
    c = carte.pop()             # la nostra carta (numero da 0 a 39)
    s = c // 10                 # seme della carta (vedi sopra)
    val = c % 10                # valore della carta (non e' necessario aggiungere 1 perche' anche gli
                                # indici della lista vanno da 0 a 9)
    print(valori[val], "di", semi[s])
print("Fine del programma")

ESERCIZIO 15.5 Come nell'esercizio sul mazzo di carte, per stampare solo l'ultima cifra di un numero basta scrivere i % 10


for i in range(1, 11):    # 1 da 1 a 10
    print(i * str(i % 10))

ESERCIZIO 15.6 I programmi per i disegni con i cicli for (ognuno con il suo output a destra)


for i in range(10):
    print( i * " " + (10 - i) * "*")









**********
 *********
  ********
   *******
    ******
     *****
      ****
       ***
        **
         *

for i in range(10):
    print(i * " " + "A")









A
 A
  A
   A
    A
     A
      A
       A
        A
         A

for i in range(10):
    s = i * " "
    if i == 0 or i == 9:
        s += "OOOOOOOOOO"
    else:
        s += "O        O"
    print(s)




OOOOOOOOOO
 O        O
  O        O
   O        O
    O        O
     O        O
      O        O
       O        O
        O        O
         OOOOOOOOOO

for i in range(10):    # i e' pari
    if i % 2 == 0:
        s = ""
    else:
        s = " "
    print(s + 5 * "X ")





X X X X X
 X X X X X
X X X X X
 X X X X X
X X X X X
 X X X X X
X X X X X
 X X X X X
X X X X X
 X X X X X

for i in range(1, 6):
    s = (5 - i) * " " + 2 * i * "M" 
    print(s)


    MM
   MMMM
  MMMMMM
 MMMMMMMM
MMMMMMMMMM
Qui la variabile intermedia s non è necessaria, ma l'ho usata per maggiore chiarezza. Facendo variare i da 1 a 5 la formula per costruire s è più facile che con i da 0 a 4

for i in range(5):
    s = (4 - i) * " " + (2 * i + 1) * "D" 
    print(s)
    D
   DDD
  DDDDD
 DDDDDDD
DDDDDDDDD

for i in range(1, 6):
    s = (i - 1) * "0" + 3 * str(i) + (5 - i) * "0"
    print(s)



1110000
0222000
0033300
0004440
0000555
Qui ho dovuto usare la funzione str().

ESERCIZIO 15.7 Programma radice.pyper la radice quadrata


epsilon = 0.000001                  # oppure eps = 1e-6
n = float(input("Inserisci il numero "))
b = 1
h = n
i = 0
# si possono riunire queste tre righe in un'assegnazione multipla
while abs (b - h) > epsilon:
    b = (b + h) / 2
    h = n / b
    i += 1
    print("Passo", i, ": valore", b)
print("La radice trovata e'", b)

ESERCIZIO 15.8 Ed ecco l'ultima versione del programma, che controlla se il numero immesso è negativo. Notate che ho riunito le prime tre assegnazioni in una sola assegnazione multipla.


epsilon = 0.000001                  # oppure eps = 1e-6
n = float(input("Inserisci il numero "))
if n < 0:
    print("La radice quadrata di un numero negativo non esiste!")
else:
    b, h, i = 1, n, 0
    while abs (b - h) > epsilon:
        b = (b + h) / 2
        h = n / b
        i += 1
		print("Passo", i, ": valore", b)
    print("La radice trovata e'", b)

ESERCIZIO 15.9 - 15.10 Il gioco delle 10 porte gioco_porte.py


from random import *                # importazione dei moduli
from time import *

stringa_inizio = """

Sei imprigionato in un labirinto.
Per 10 volte dovrai aprire una porta a sinistra o una a destra. Se sbaglierai scelta MORIRAI!
Premi INVIO quando sei pronto

"""

stringa_morte = """

AAAARRRRGGGGHHHH!      SEI MORTO!

  ##
######
  ##
  ##
  ##

Ma per fortuna puoi ricominciare!

"""                                  # definizione di stringa_morte

porte = ""                           # stringa vuota
for i in range(10):
    if random() >= 0.5:              # avremmo potuto usare anche: if randrange(2) == 0:
        porte += "s"
    else:
        porte += "d"
input(stringa_inizio)                # qui il programma si ferma ed aspetta che premiamo Invio

t1 = time()                          # tempo iniziale
i = 0
while i < 10:
    risp = input("Porta n. " + str(i + 1) + "(s/d)? ")
    if risp == porte[i]:             # la risposta e' esatta
        print("Esatto!")
        i += 1                       # va alla prossima porta
    else:                            # la risposta e' sbagliata
        print(stringa_morte)
        i = 0                        # ricomincia da capo
t2 = time()                          # uscita dal ciclo: tempo finale
print("Complimenti! Sei uscito dal labirinto! Hai impiegato", t2 - t1, "secondi")

ESERCIZIO 15.11 - 15.13 Ecco il programma scrutinio_finale.py con tutte le modifiche proposte


materie = ["Italiano", "Matematica"]
classe = []                                        # la nostra classe, inizialmente vuota

risp = "s"
while risp == "s":                                 # ciclo per inserire gli alunni
    alunno = []
    print("Alunno", len(classe) + 1)               # stampa il numero dell'alunno corrente
    alunno.append(input("Inserisci il cognome "))  # piu' compatto, senza usare variabili intermedie
    alunno.append(input("Inserisci il nome "))
    insuff = 0                                     # conta il numero delle insufficienze
    for i in range(len(materie)):                  # al solito, non scriviamo range(2)
        voto = int(input("Inserisci il voto in " + materie[i] + " "))
        alunno.append(voto)
        if voto < 6:
            insuff += 1
    if insuff == 0:                                # promosso
        alunno.append("p")
    elif insuff == 1:                              # rimandato
        alunno.append("r")
    else:                                          # bocciato
        alunno.append("b")
    classe.append(alunno)                          # aggiungiamo l'alunno alla classe
    risp = input("Vuoi inserire un altro alunno?(s/n) ")

for i in range(len(classe)):                       # ciclo per stampare i risultati
    print(i + 1, classe[i][0], "\t", classe[i][1], "\t", materie[0], classe[i][2], "\t",
          materie[1], classe[i][3], "\t", classe[i][4])  

Qui sotto c'è un'implementazione alternativa dell'ultimo ciclo che stampa i risultati, usando una stringa ausiliaria s che viene "scritta" un'istruzione per volta e poi stampata con print(s). Potreste trovarla più complicata, ma ha un grosso vantaggio: se aumentassi il numero di materie il ciclo interno (con il contatore j) si adatterebbe automaticamente, mentre con la prima soluzione dovrei riscrivere tutta l'istruzione che stampa la stringa.


for i in range(len(classe)):                       # ciclo per stampare i risultati
    s = str(i + 1) + classe[i][0] + " \t" + classe[i][1] + " \t"
    for j in range(len(materie)):
        s += (materie[j] + " " + str(classe[i][j + 2]) + " \t")
    s += classe[i][4]
    print(s)  

LEZIONE 16

ESERCIZIO 16.1 La funzione stampa_quadrato


def stampa_quadrato(x):
    print("Il quadrato di", x, "e'", x ** 2)
	
stampa_quadrato(2)
stampa_quadrato(10)
stampa_quadrato(1234567890)

ESERCIZIO 16.2 Il programma saluti.py modificato


def saluta(nome, s):
    print("Ciao", nome + "!")
    if s == "m":
        print("Sei il mio migliore amico")
    else:
        print("Sei la mia migliore amica")
        
saluta("Peppe", "m")
saluta("Rosina", "f")

ESERCIZIO 16.3 Il programma borse_studio.py


def borsa(media, reddito):
    if media > 8 and reddito < 30000:
        return True
    else:                      
        return False

studenti = [ ["Alberti", 8.5, 29500], ["Bongini", 7.9, 28000], ["Castroni", 8.6, 36500],
["De Lallis", 8.2, 27500], ["Esterini", 8.5, 31000], ["Folletti", 7.7, 27000],
["Giuliani", 9.1, 28000], ["Lulli", 8.0, 30500], ["Milanesi", 8.2, 25500], ["Nonnini", 8.6, 34000],
["Pampanato", 7.9, 26000], ["Rossi", 8.2, 31000], ["Santi", 8.1, 28000], ["Tontini", 7.8, 25000] ]

for i in studenti:             # iteriamo sugli elementi (i e' uno studente)
    if borsa(i[1], i[2]):      # i[1] e' la media e i[2] il reddito dello studente i    
        print(i[0])            # i[0] e' il suo cognome

Se avessimo iterato sugli indici sarebbe stato necessario usare la sintassi per le liste di liste, con una sintassi più complicata. Ecco una versione alternativa del programma


def borsa(media, reddito):
    if media > 8 and reddito < 30000:
        return True                      
    return False

studenti = [ ["Alberti", 8.5, 29500], ["Bongini", 7.9, 28000], ["Castroni", 8.6, 36500],
["De Lallis", 8.2, 27500], ["Esterini", 8.5, 31000], ["Folletti", 7.7, 27000],
["Giuliani", 9.1, 28000], ["Lulli", 8.0, 30500], ["Milanesi", 8.2, 25500], ["Nonnini", 8.6, 34000],
["Pampanato", 7.9, 26000], ["Rossi", 8.2, 31000], ["Santi", 8.1, 28000], ["Tontini", 7.8, 25000] ]

for i in range(len(studenti)): # iteriamo sugli indici (studenti[i] e' uno studente)
    if borsa(studenti[i][1], studenti[i][2]):    
        print(studenti[i][0])

Notate un piccolo trucco, comunemente usato quando una funzione deve restituire un valore scelto tra due: ho omesso la riga con l'else nella definizione di borsa(): se l'if è vero si esce alla seconda riga, altrimenti si continua e si esce alla terza. Così "risparmiamo" una riga di codice (ai programmatori queste cose piacciono moltissimo!)

ESERCIZIO 16.4 Lista dei numeri primi con il programma numeri_primi.py: un numero n è primo se divisibilita(n) == n


def divisibilita(n): 
    for k in range(2, n // 2 + 1):
        if n % k == 0:      # se n e' divisibilr per k ...
            return k        # restituisce k (< n)
    return n                # altrimenti restituisce n ( n e' primo)

print("NUMERI PRIMI TRA 1 E 1000")
for i in range(1, 1001):
    if divisibilita(i) == i:
        print(i)

ESERCIZIO 16.5 Ecco il programma scomposizione.py


def divisibilita(n): 
    for k in range(2, n // 2 + 1):
        if n % k == 0:      # se n e' divisibilr per k ...
            return k        # restituisce k (< n)
    return n                # altrimenti restituisce n ( n e' primo)
	
fattori = []
num = int(input("Scrivi un numero intero ")
while num > 1:
    div = divisibilita(num)
    fattori.append(div)
    num //= div
print("I fattori sono", fattori)

LEZIONE 17

ESERCIZIO 17.1 Ecco la mia versione del gioco delle porte con un menu principale. Data la notevole lunghezza lo ho diviso in sezioni con dei commenti graficamente più evidenti (prassi abbastanza comune tra i programmatori. La vostra versione potrebbe differire anche sensibilmente: se trovate delle differenze cercate di capire se effettivamente i programmi fanno la stessa cosa e perchè.

             #########################################
             ### IMPORTAZIONE DEI MODULI NECESSARI ###
             #########################################

from random import *
from time import *
from myinput import *

             ##################################
             ### DEFINIZIONE DELLE FUNZIONI ###
             ##################################
	 
def mostra_istruzioni():
    print(stringa_inizio)
	
def mostra_record():
    print("Il tuo record e'", record, "secondi")
    
def mostra_credits():
    print(stringa_credits)
	
def partita():
    global record         # la funzione dovra' modificare questa variabile globale
    porte = ""
    for i in range(10):
        if random() >= 0.5:
            porte += "s"
        else:
            porte += "d"
    input("Premi Invio quando sei pronto")
    t1 = time()
    i = 0
    while i < 10:
        risp = input("Porta n. " + str(i + 1) + "(s/d)? ")
        if risp == porte[i]:
            print("Esatto!")
            i += 1
        else:
            print(stringa_morte)
            i = 0
    t = time() - t1
    print("Complimenti! Sei uscito dal labirinto! Hai impiegato", t, "secondi")
    if t < record:
        print("Hai battuto il tuo record!")
        record = t   

             ################################################
             ### INIZIALIZZAZIONE DELLE VARIABILI GLOBALI ###
             ################################################

stringa_inizio = """

Sei imprigionato in un labirinto.
Per 10 volte dovrai aprire una porta a sinistra o una a destra. Se sbaglierai scelta MORIRAI!
Premi INVIO quando sei pronto

"""

stringa_morte = """

AAAARRRRGGGGHHHH!      SEI MORTO!

  ##
######
  ##
  ##
  ##

Ma per fortuna puoi ricominciare!

"""                                 # definizione di stringa_morte

stringa_credits = """


     --- LE DIECI PORTE ---
     di Nicola Cassetta
     Copyright 2015


"""                                 # definizione di stringa_credits

lista_menu = [ "Istruzioni", "Gioca", "Record", "Credits", "Esci" ] # il nostro menu
record = 100000000000               # il record iniziale

             ############################
             ### PROGRAMMA PRINCIPALE ###
             ############################
			 
while True:
    opz = input_menu(lista_menu)
    if opz == 1:
        mostra_istruzioni()
    elif opz == 2:
        partita() 
    elif opz == 3:
        mostra_record()
    elif opz == 4:
        mostra_credits()
    else:
        break

LEZIONE 19

ESERCIZIO 19.1 Ecco la funzione mysqrt(), che genera un errore se si tenta di chiamarla con un numero negativo come argomento


def mysqrt(n):
    if n < 0:
        raise ValueError("Negative argument for square root")
    b, h = 1, n
    while abs (b - old_b) > 1e-6:
        b = (b + n / b) / 2
        h = n / b 
    return b

print(mysqrt(25))
print(mysqrt(-1))

ESERCIZIO 19.2 La funzione input_menu() con le modifiche proposte


def input_menu(opzioni):
    for i in range(len(opzioni)):
        print(i + 1, " ", opzioni[i])  # per scrivere i numeri tra 1 e len(opzioni)
    while True:
        try:
            risp = int(input("? "))
            if risp < 1 or risp > len(opzioni):
                raise ValueError
            return risp
        except ValueError:
            print("Input scorretto")