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 >>>
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
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.)
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
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
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)
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")
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)
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
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")
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!")
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])
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
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)
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
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
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)
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)
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
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")