Esercizi Python

Esercizi di Python
Per studenti di
Sperimentazioni di Fisica I Modulo A
Corso di Laurea in Astronomia
A. Baruffolo
INAF Osservatorio Astronomico di Padova &
Università di Padova Dipartimento di Fisica e Astronomia
10 febbraio 2016
Indice degli esercizi
1 Introduzione 4
2 Uso diretto dellinterprete Python 5

Esercizio 1 Aree e volumi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Esercizio 2 Calcolo del montante . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Esercizio 3 Conversione da pollici a centimetri . . . . . . . . . . . . . . . . . . . 5
Esercizio 4 Conversione da centimetri a pollici . . . . . . . . . . . . . . . . . . . 5
Esercizio 5 Approssimare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Esercizio 6 Pressione atmosferica . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3 Liste 9
Esercizio 7 Generare liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Esercizio 8 Liste a fette . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Esercizio 9 Estrazione da lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Esercizio 10 Conteggio di cifre . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Esercizio 11 Lorem ipsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4 Cicli 13
Esercizio 12 Somma di numeri naturali con for . . . . . . . . . . . . . . . . . . 13
Esercizio 13 Somma di numeri naturali con while . . . . . . . . . . . . . . . . . 13
Esercizio 14 Iterare su slice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Esercizio 15 Le tabelline fino al 10 . . . . . . . . . . . . . . . . . . . . . . . . . 13
Esercizio 16 Successione di Fibonacci . . . . . . . . . . . . . . . . . . . . . . . . 14
Esercizio 17 Successione di Tribonacci . . . . . . . . . . . . . . . . . . . . . . . 14
Esercizio 18 Calcolo del montante . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Esercizio 19 Algoritmo di GaussLegendre . . . . . . . . . . . . . . . . . . . . . 15
Esercizio 20 Triangolo di numeri . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Esercizio 21 Triangolo inverso di numeri . . . . . . . . . . . . . . . . . . . . . . 15
Esercizio 22 Triangolo di Floyd . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Esercizio 23 Diagonale di * . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Esercizio 24 Diagonale inversa di * . . . . . . . . . . . . . . . . . . . . . . . 16
Esercizio 25 Quadrato di * . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Esercizio 26 Rettangolo di * . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Esercizio 27 Triangolo rettangolo sinistro di * . . . . . . . . . . . . . . . . . 17
Esercizio 28 Triangolo rettangolo sinistro e inverso di * . . . . . . . . . . . . 17
Esercizio 29 Triangolo rettangolo destro di * . . . . . . . . . . . . . . . . . . 18
Esercizio 30 Triangolo rettangolo destro e inverso di * . . . . . . . . . . . . . 18
Esercizio 31 Piramide di * in piedi . . . . . . . . . . . . . . . . . . . . . . . . 18
Esercizio 32 Triangolo isoscele di * . . . . . . . . . . . . . . . . . . . . . . . 18
Esercizio 33 Triangolo isoscele capovolto di * . . . . . . . . . . . . . . . . . 19
Esercizio 34 Rombo di * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5 Selezione if 26
Esercizio 35 Freddo o caldo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Esercizio 36 Numeri interi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Esercizio 37 Verifica angolo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Esercizio 38 Anno bisestile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Esercizio 39 sessagesimal2decimal . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1
6 Cicli e selezioni 31
Esercizio 40 Iterazioni con if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Esercizio 41 Ciclo di comandi . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Esercizio 42 Da unità imperiali a metriche . . . . . . . . . . . . . . . . . . . . . 31
Esercizio 43 Computer indovina numero . . . . . . . . . . . . . . . . . . . . . . 32
Esercizio 44 Computer indovina numero senza imbrogli . . . . . . . . . . . . . . 32
7 Funzioni e moduli 37
Esercizio 45 Formula di Erone . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Esercizio 46 Radici di equazione di secondo grado . . . . . . . . . . . . . . . . . 37
Esercizio 47 Anno bisestile, funzione . . . . . . . . . . . . . . . . . . . . . . . . 38
Esercizio 48 Giorno dellanno . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Esercizio 49 Da giorno dellanno a data . . . . . . . . . . . . . . . . . . . . . . 38
Esercizio 50 Pasqua Gregoriana . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Esercizio 51 Da decimale a binario . . . . . . . . . . . . . . . . . . . . . . . . . 39
Esercizio 52 Da decimale a binario, ricorsivamente . . . . . . . . . . . . . . . . 40
Esercizio 53 Un clone di bin() . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Esercizio 54 Da decimale a ottale . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Esercizio 55 Da decimale a ottale, ricorsivamente . . . . . . . . . . . . . . . . . 41
Esercizio 56 Un clone di oct() . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Esercizio 57 Numeri di Thabit . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Esercizio 58 Teorema di Pitagora . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Esercizio 59 Grafici di funzioni . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Esercizio 60 Somma delle cifre di un intero . . . . . . . . . . . . . . . . . . . . 42
Esercizio 61 Somma delle cifre di un intero bis . . . . . . . . . . . . . . . . . . 42
Esercizio 62 Algoritmo di Horner . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Esercizio 63 Algoritmo di Horner ricorsivo . . . . . . . . . . . . . . . . . . . . . 43
Esercizio 64 Giorno Giuliano . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Esercizio 65 Giorno Giuliano modificato . . . . . . . . . . . . . . . . . . . . . . 44
Esercizio 66 Numeri perfetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Esercizio 67 Crivello di Eratostene . . . . . . . . . . . . . . . . . . . . . . . . . 44
8 Serie numeriche 53
Esercizio 68 Serie per e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Esercizio 69 Serie per e, ricorsiva . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Esercizio 70 Serie di Nilakantha . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Esercizio 71 Serie di Nilakantha ricorsiva . . . . . . . . . . . . . . . . . . . . . . 53
9 Numeri casuali 55
Esercizio 72 Lotto (shuffle) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Esercizio 73 Lotto (choice) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Esercizio 74 Lotto (random index) . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Esercizio 75 Indovina numero . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
10 Numpy 59
Esercizio 76 Somma di interi, versione numpy . . . . . . . . . . . . . . . . . . . 59
Esercizio 77 Tabellina, versione numpy . . . . . . . . . . . . . . . . . . . . . . . 59
Esercizio 78 Thabit, versione numpy . . . . . . . . . . . . . . . . . . . . . . . . 59
Esercizio 79 Montante, versione numpy . . . . . . . . . . . . . . . . . . . . . . . 59
Esercizio 80 Seno e coseno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Esercizio 81 Grafici di funzioni, numpy . . . . . . . . . . . . . . . . . . . . . . . 59
Esercizio 82 Grafico di CelsiusFarenheit . . . . . . . . . . . . . . . . . . . . . . 60
2
Esercizio 83 Grafico di polinomio . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Esercizio 84 Riproduci grafico . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Esercizio 85 Crivello di Eratostene, versione numpy . . . . . . . . . . . . . . . . 61
Esercizio 86 Somma cumulativa . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Esercizio 87 Verifica somma cumulativa . . . . . . . . . . . . . . . . . . . . . . 61
11 Simulazioni e Metodi Monte-Carlo 66

Esercizio 88 Gioco delloca semplificato . . . . . . . . . . . . . . . . . . . . . . . 66
Esercizio 89 Area di Macchia Nera . . . . . . . . . . . . . . . . . . . . . . . . . 66
Esercizio 90 Rappresentazione stocastica di e . . . . . . . . . . . . . . . . . . . . 67
3
Capitolo 1
Introduzione
Gli esercizi riportati in questa raccolta assumono che lo studente sia familiare con i concetti di
Python illustrati durante il laboratorio. In particolare lo studente deve sapere:
come scrivere ed eseguire brevi programmi nella finestra di editor di IDLE;
come importare moduli ed utilizzare le relative funzioni (limitatamente a quelle usa-

te durante il laboratorio). I moduli utilizzati pi`
u di frequente sono: math, random,
matplotlib.pyplot, numpy, numpy.random;
come scrivere brevi funzioni con parametri opzionali e che ritornino dei valori al chiamante;
Alcuni costrutti utilizzati di frequente in questi esercizi sono:
Input di una stringa da parte dellutente, tramite la funzione cmd = raw input("Stringa
di prompt: ");
Conversione del contenuto di una variable in intero, tramite funzione int(), in floating
point, funzione float(), o in stringa, funzione str().
...;
` probabile che nel testo o nelle soluzioni proposte vi siano degli errori. E
E ` molto probabile
che ci siano ampi margini di miglioramento, per esempio riguardo alla chiarezza. I lettori sono
cortesemente invitati a segnalate errori e/o possibili miglioramenti via email.
4
Capitolo 2
Uso diretto dellinterprete Python
I seguenti esercizi servono a prendere dimestichezza con il modo in cui numeri e formule vengono
scritti in modo da poter essere interpretati correttamente da un computer e in particolare da
Python. Bisogna ricordare che:
scrivendo una espressione e premendo il tasto Enter , lespressione viene valutata da Python
e il risultato scritto a schermo;
i decimali sono preceduti dal punto ., e non dalla virgola.
Esercizio 1 Aree e volumi: Approssimando = 3.14159265 calcolare:

1. la circonferenza del cerchio di raggio 3.0 m;
2. larea dello stesso cerchio;
3. il volume della sfera avente lo stesso raggio.
Esercizio 2 Calcolo del montante: Sapendo che il montante è dato dalla somma
di capitali e interessi, ovvero Montante = Capitale (1 + i), dove i è espresso in percentuale,
verificare che il montante di un capitale di 1000 e, investito al tasso i = 4% per un anno
ammonta a 1040 e.
Esercizio 3 Conversione da pollici a centimetri: Sapendo che un pollice equivale

a 2.54 centimetri, convertire in centimetri le seguenti misure:
1. Diametro dello specchio primario del Celestron C-14 (14 pollici);
2. Diametro dello specchio primario del telescopio Hale di Monte Palomar (200 pollici).
Esercizio 4 Conversione da centimetri a pollici: Sapendo che un pollice equivale

a 2.54 centimetri, convertire in pollici le seguenti misure:
1. Diametro dello specchio primario del Telescopio Nazionale Galileo (3.58 m);
2. Diametro dello specchio primario di ciascuno degli Unit Telescopes del VLT (8.20 m).
Esercizio 5 Approssimare : Sapendo che = 3.14159265358 . . . verificare le

seguenti approssimazioni:
1. 22/7 è unapprossimazione di con accuratezza 4 104
Hint: calcolate prima la frazione indicata e poi calcolate il rapporto tra la differenza tra la
frazione e il valore di dato sopra diviso .
5
Esercizio 6 Pressione atmosferica: Landamento della pressione atmosferica P ,
misurata in atmosfere, in funzione dellaltezza h (in metri) può essere approssimato con la
formula:
h
P = 0.9877 100.0 . (2.1)
Calcolare la pressione a 1000, 2000 e 4000 metri
6
Soluzione dellesercizio 1
>>> pi = 3.14159265
>>> r = 3.0
>>> 2.0*pi*r
18.849555900000002
>>> pi*r*r
28.274333850000005
>>> 4./3.*pi*r*r*r
113.09733539999999
Il volume si pu`
o anche calcolare usando lelevamento a potenza:
>>> 4./3.*pi*r**3
113.09733539999999
>>> 1000.*(1+4./100.)
1040.0
>>> in2cm = 2.54 # inches to centimeters

>>> 14.0*in2cm # diametro M1 C14 in cm
35.56
>>> 200.0*in2cm # diametro M1 Hale in cm
508.0
>>> in2cm = 2.54 # inches to centimeters

>>> 3.58 * 100.0 / in2cm # M1 TNG da m a cm e poi in pollici
140.94488188976376
>>> 8.20 * 100.0 / in2cm # M1 UT da m a cm e poi in pollici
322.83464566929126
>>> pi=3.14159265358
>>> 22./7.
3.142857142857143
>>> (22/7.-pi)/pi
0.00040249943788918174
>>> 333./106.
3.141509433962264
>>> (333./106.-pi)/pi
-2.648962704990393e-05
>>> 355./113.
3.1415929203539825
>>> (355/113.-pi)/pi
8.491679599397461e-08
7
>>> h = 1000.0
>>> 0.9877**(h/100.0)
0.8835894823558638
>>> h = 2000.0
>>> 0.9877**(h/100.0)
0.7807303733299034
>>> h = 4000.0
>>> 0.9877**(h/100.0)
0.6095399158398502
8
Capitolo 3
Liste
Esercizio 7 Generare liste: Usando la funzione range()generare una lista conte-

nente:
1. tutti i numeri interi da 1 a 30;
2. tutti i numeri dispari tra 1 e 30;
3. tutti i numeri pari tra 1 e 30;
4. titti i numeri tra 1 e 30 divisibili per tre;
5. titti i numeri tra 1 e 30 divisibili per cinque;
6. tutti i numeri interi da 30 a 1 (ordine decrescente);
7. tutti i numeri pari da 30 a 1 (ordine decrescente);
8. tutti i numeri da 30 a 1 (ordine decrescente) che sono divisibili per 5.
Esercizio 8 Liste a fette: Al prompt di IDLE, generare una lista coi numeri da 1 a 30
usando la funzione range(). Da questa lista generare, usando le slices, altre liste contenenti:
1. i numeri tra 11 e 20 (entrambi inclusi)
2. i numeri della lista di partenza che sono dispari
3. i numeri della lista di partenza che sono pari
4. i numeri della lista di partenza che sono divisibili per tre
5. i numeri della lista di partenza che sono divisibili per cinque
6. la lista di partenza invertita (= i numeri da 30 a 1)
7. i numeri della lista di partenza che sono pari in ordine decrescente
8. i numeri della lista di partenza che sono divisibili per cinque in ordine decrescente
Esercizio 9 Estrazione da lista: Scrivere un programma che crea una lista n con i
numeri da 1 a 30 e inizializza una lista vuota p. Quindi:
1. usando un ciclo for estrarre, tramite pop(), i numeri pari dalla lista n e aggiungerli
alla fine della lista p;
2. usando un ciclo for estrarre, tramite pop(), i numeri dispari dalla lista n e aggiungerli
alla fine della lista p;
Attenzione al pitfall : il metodo pop() modifica la lista su cui agisce...
Esercizio 10 Conteggio di cifre: Scrivere un programma che definisca la seguente

lista:
l = [3, 0, 2, 6, 3, 3, 8, 3, 2, 1, 0, 7, 8, 3, 6,
6, 1, 4, 8, 5, 6, 7, 8, 2, 7, 7, 6, 5, 3, 5]
9
(si può fare copia-e-incolla) e una lista vuota n. Dopodichè, usando il metodo count() contare
quante volte le cifre da 0 a 9 appaiono in l e mettere tali numeri, in ordine, nella lista n. In
altre parole, alla fine dellesecuzione liesimo elemento di n dovrà corrispondere al numero di
volte che la cifra i appare in l. Risultato atteso:
[2, 2, 3, 6, 1, 3, 5, 4, 4, 0]
Esercizio 11 Lorem ipsum: Scrivere un programma che conti quante volte ciascuna
lettera minuscola dellalfabeto (compresa la x) compare nel testo Lorem ipsum:
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud
exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute
irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla
pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia
deserunt mollit anim id est laborum.
Procedimento:
Facendo copia e incolla, definire una variabile che contenga il testo Lorem ipsum (ricordate
che si pu`
o definire una stringa su più righe mettendo un backslash \ a fine riga, prima
di andare a capo);
convertire la stringa in una lista usando la funzione list();
definire una variabile alphabet che contenga la stringa abcdefghilmnopqrstuvxz;
inizializzare una lista n_letter vuota che conterr`

a il numero di occorrenze per ciascuna
lettera dellalfabeto;
iterare su tutte le lettere dellalfabeto contenute nella variabile alphabet, con variabile
di iterazione l:
usando il metodo count() contare quante volte l appare in Lorem ipsum;

aggiungere tale numero in coda alla lista n_letter.
in un secondo ciclo, separato, su tutte le lettere in alphabet, stampare a schermo la

lettera e il numero di volte che compare in Lorem ipsum.
Output atteso (abbreviato):

a : 29
b : 3
c : 16
d : 18
e : 37
...
u : 28
v : 3
x : 3
z : 0
10
1. range(1,31)
2. range(30,0,-1)
3. range(2,31,2)
4. range(3,31,3)
5. range(5,31,5)
6. range(30,0,-1)
7. range(30,0,-2)
8. range(30,1,-5)
Posto a = range(1,31):
1. a[10:20]
2. a[::2]
3. a[1::2]
4. a[2::3]
5. a[4::5]
6. a[::-1] o a[-1::-1] o a[29::-1] NOTA: la slice [::-1] è da preferire perchè fun-

ziona per ogni lista, indipendentemente dalla sua lunghezza. La slice [29::-1] risponde
alla richiesta dellesercizio solo per una lista di lunghezza minore o uguale a 30.
7. a[::-2]
8. a[::-5]
1. pop_append1.py:
n = range(1,31)
p = []
for i in range(1,16):
p.append(n.pop(i))
print p
2. pop_append2.py:
n = range(1,31)
p = []
p.append(n.pop(i))
print p
11
count_digits.py:
l = [3, 0, 2, 6, 3, 3, 8, 3, 2, 1, 0, 7, 8, 3, 6,
6, 1, 4, 8, 5, 6, 7, 8, 2, 7, 7, 6, 5, 3, 5]
n = []
for i in range(10):
n.append(l.count(i))
print n
count_lorem_ipsum.py:
text = Lorem ipsum dolor sit amet, consectetur adipiscing elit, \
sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. \
Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris \
nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in \
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla \
pariatur. Excepteur sint occaecat cupidatat non proident, sunt in \
culpa qui officia deserunt mollit anim id est laborum.
ltext = list(text)
alphabet = abcdefghilmnopqrstuvxz
n_letter = []
for l in alphabet:
n = ltext.count(l)
n_letter.append(n)
for i in range(len(alphabet)):
print alphabet[i],: ,n_letter[i]
12
Capitolo 4
Cicli
Esercizio 12 Somma di numeri naturali con for: Scrivere un programma Python

che, usando un ciclo for, calcoli e mostri a video la somma dei primi 100 numeri naturali.
Esercizio 13 Somma di numeri naturali con while: Scrivere un programma

Python che, usando un ciclo while, calcoli e mostri a video la somma dei primi 100 numeri
naturali.
Esercizio 14 Iterare su slice:

Scrivere un breve programma che generi una lista
contenente i numeri da 1 a 30 usando la funzione range(). Usando un ciclo for:
1. iterate sulla sotto-lista formata da tutti i numeri dispari (identificata usando le slice),
e stampateli su una sola riga;
2. iterate sulla sotto-lista formata da tutti i numeri pari (identificata usando le slice), e
stampateli su una sola riga;
3. iterate sulla sotto-lista formata da tutti i numeri divisibili per cinque (identificata
usando le slice), e stampateli su una sola riga.
Hint: Ricordate che mettendo una virgola alla fine dellistruzione print il testo non va a capo.
Esercizio 15 Le tabelline fino al 10: Calcolare e stampare a schermo le tabelline

di moltiplicazione da 1 a 10:
1. usando il ciclo for;
2. usando il ciclo while;
Tra una tabellina e laltra lasciate una riga vuota.
Output atteso:
1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
1 x 4 = 4
1 x 5 = 5
1 x 6 = 6
1 x 7 = 7
1 x 8 = 8
1 x 9 = 9
1 x 10 = 10
2 x 1 = 2
2 x 2 = 4
13
...
...
10 x 9 = 90
10 x 10 = 100
Esercizio 16 Successione di Fibonacci: Sapendo che la successione di Fibonacci è

definita cos`:
N0 = 0
N1 = 1
Nn = Nn1 + Nn2 per n > 1
e che, quindi, i primi sette elementi della successione sono 0, 1, 1, 2, 3, 5, 8, . . ., scrivere un
programma che calcola e stampa la successione fino a n = 15 (ovvero, siccome si parte da zero,
i primi sedici elementi della successione), usando:
1. un ciclo while;
2. un ciclo for;
Il risultato atteso è:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610
Esercizio 17 Successione di Tribonacci: Sapendo che la successione di Tribonacci

è definita in analogia alla successione di Fibonacci (vd esercizio precedente) come:
N0 = 0
N1 = 1
N2 = 1
Nn = Nn1 + Nn2 + Nn3 per n > 2
e che, quindi, i primi sette elementi della successione sono 0, 1, 1, 2, 4, 7, 13 . . ., scrivere un
programma che calcola e stampa la successione fino a n = 15 (ovvero, siccome si parte da zero,
i primi sedici elementi della successione), usando:
1. un ciclo while;
2. un ciclo for;
Il risultato atteso è:
0 1 1 2 4 7 13 24 44 81 149 274 504 927 1705 3136
Esercizio 18 Calcolo del montante: Sapendo che il montante M di un capitale C

investito al tasso di interesse i per n anni è dato da:
M = C (1 + i)n
calcolare e stampare a schermo il montante anno per anno di un capitale di 1000 e, investito
per 10 anni al tasso del 4%. Output atteso:
1 1040.0
2 1081.6
3 1124.864
4 1169.85856
5 1216.6529024
6 1265.3190185
7 1315.93177924
8 1368.56905041
9 1423.31181242
10 1480.24428492
14
Esercizio 19 Algoritmo di GaussLegendre: Lalgoritmo di GaussLegendre è
un algoritmo per il calcolo di noto per convergere molto rapidamente. E ` stato utilizzato
ripetutamente nella seconda met` a del secolo scorso per calcolare progressivamente da decine di
milioni fino a centinaia di miliardi di cifre di .
Scrivere un programma Python che calcoli usando tale metodo, come descritto in Wells (1986).
Procedimento:

definire le variabili A = 1, X = 1, B = 1/ 2 e C = 1/4 (attenzione alla matematica
intera e ricordarsi di importare le funzioni/moduli necessari);
definire una variabile intera niter = 5, numero di iterazioni da effettuare;
iterare per niter volte e ad ogni passo calcolare e stampare lapprossimazione di :
Y = A
A+B
A =
2
B = BY
C = C X (A Y )2
X = 2X
(A + B)2

4C
Verificare che lalgoritmo ha ordine di convergenza quadratico, ovvero che il numero di cifre
corrette raddoppia ad ogni passo delliterazione e in pratica alla terza iterazione si raggiunge la
precisione consentita dal formato di rappresentazione dei numeri floating point (in altre parole,
il numero stampato non cambia dopo il terzo passo).
Output atteso:
>>>
3.14057925052
3.14159264621
3.14159265359
3.14159265359
3.14159265359
>>>
Esercizio 20 Triangolo di numeri: Scrivere una funzione che accetti un parametro

n intero in input e stampi un triangolo di numeri, ovvero n righe di lunghezze crescenti da
uno a n, contenenti i numeri da uno al numero della riga. Esempio:
>>> num_triangle(5)
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
Esercizio 21 Triangolo inverso di numeri: Scrivere una funzione che accetti

un parametro n intero in input e stampi un triangolo inverso di numeri, ovvero n righe di
lunghezze decrescenti da n a uno, contenenti i numeri da uno alla lunghezza della riga. Esempio:
15
>>> num_triangle_inv(5)
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
Esercizio 22 Triangolo di Floyd: Scrivere una funzione che stampi il Triangolo di

Floyd con un numero di righe specificato dallutente, ovvero un triangolo rettangolo di numeri
naturali in cui ciascuna riga è riempita di numeri consecutivi, a partire da 1 per la prima riga.
Esempio:
>>> floyds_triangle(4)
1
2 3
4 5 6
7 8 9 10
Esercizio 23 Diagonale di *: Scrivere un programma che richieda allutente un

numero intero n in input. Il programma poi stampa n asterischi * in diagonale da sinistra
verso destra.
Esempio:
Numero: 5
*
*
*
*
*
Hint: Notare che, se n è il numero di * sulla diagonale, gli spazi da stampare per riga vanno
da zero fino a (n 1), nellesempio sopra (n 1) = 4.
Esercizio 24 Diagonale inversa di *: Scrivere un programma che richieda allu-

tente un numero intero n in input. Il programma poi stampa n asterischi * in diagonale da
destra verso sinistra.
Esempio:
Numero: 5
*
*
*
*
*
Hint: Notare che, se n è il numero di * sulla diagonale, gli spazi da stampare per riga vanno
da (n 1) fino a zero, nellesempio sopra (n 1) = 4.
Esercizio 25 Quadrato di *: Scrivere un programma che richieda allutente un

numero intero n in input. Il programma poi stampa un quadrato n n di asterischi *.
16
Esempio:
Numero: 5
*****
*****
*****
*****
*****
Notare che, siccome sullo schermo i caratteri non occupano lo stesso spazio in orizzontale e
verticale, il quadrato risultante non appare quadrato ai nostri occhi.
Esercizio 26 Rettangolo di *: Scrivere un programma che richieda allutente due

numero interi in input: numero di righe, r, e numero di colonne c. Il programma poi stampa
un rettangolo r c di asterischi *.
Esempio:
Numero righe: 2
Numero colonne: 9
*********
*********
Notare che, siccome sullo schermo i caratteri non occupano lo stesso spazio in orizzontale e
verticale, il quadrato risultante non appare quadrato ai nostri occhi.
Esercizio 27 Triangolo rettangolo sinistro di *: Scrivere un programma

che richieda allutente un numero intero n in input. Il programma poi stampa un triangolo
rettangolo di asterischi * con vertice in alto a sinistra, base e altezza di n *.
Esempio:
Numero: 5
*
**
***
****
*****
Hint: In pratica si tratta di iterare n volte, ad ogni passo stampando un numero crescente di
* partendo da uno.
Esercizio 28 Triangolo rettangolo sinistro e inverso di *: Scrivere un

programma che richieda allutente un numero intero n in input. Il programma poi stampa un
triangolo rettangolo di asterischi * con vertice in basso a sinistra, base e altezza di n *.
Esempio:
Numero: 5
*****
****
***
**
*
Hint: In pratica si tratta di iterare n volte, ad ogni passo stampando un numero decrescente
di * partendo da n.
17
Esercizio 29 Triangolo rettangolo destro di *: Scrivere un programma che
richieda allutente un numero intero n in input. Il programma poi stampa un triangolo rettangolo
di asterischi * con vertice in alto a destra, base e altezza di n *.
Esempio:
Numero: 5
*
**
***
****
*****
Hint: In pratica si tratta di iterare n volte, ad ogni passo stampando un numero decrescente
di spazi ( ), partendo da n 1, e un numero crescente di * partendo da uno.
Esercizio 30 Triangolo rettangolo destro e inverso di *: Scrivere un

programma che richieda allutente un numero intero n in input. Il programma poi stampa
un triangolo rettangolo di asterischi * con vertice in basso a destra, base e altezza di n *.
Esempio:
Numero: 5
*****
****
***
**
*
Hint: In pratica si tratta di iterare n volte, ad ogni passo stampando un numero crescente di
spazi ( ), partendo da 0, e un numero decrescente di * partendo da n.
Esercizio 31 Piramide di * in piedi : Scrivere un programma che richieda

allutente un numero intero n in input. Il programma poi stampa una piramide in piedi di
asterischi *, con base 2n 1 * e altezza n *.
Esempio:
Numero: 5
*
**
***
****
*****
****
***
**
*
Hint: Riutilizzare quanto fatto per gli esercizi 27 e 28.
Esercizio 32 Triangolo isoscele di *: Scrivere un programma che richieda allu-

tente un numero intero n in input. Il programma poi stampa un triangolo isoscele di asterischi
* con vertice in alto e altezza di n *.
18
Esempio:
Numero: 6
*
***
*****
*******
*********
***********
Hint: In pratica si tratta di iterare n volte, partendo da zero, ad ogni passo stampando un
numero decrescente di spazi e (2i + 1) *, dove i è la variabile di iterazione.
Esercizio 33 Triangolo isoscele capovolto di *: Scrivere un programma che

richieda allutente un numero intero n in input. Il programma poi stampa un triangolo isoscele
capovolto di asterischi * con base in alto e altezza di n *.
Esempio:
Numero: 5
*********
*******
*****
***
*
Hint: In pratica si tratta di iterare n volte, partendo da zero, ad ogni passo stampando un
numero crescente di spazi ( ), partendo da 0, e un numero decrescente di * pari a 2(ni)1,
dove i è la variabile di iterazione.
Esercizio 34 Rombo di *: Scrivere un programma che richieda allutente un

numero intero n in input. Il programma poi stampa un rombo di asterischi *, avente diagonale
maggiore uguale alla diagonale minore e pari a base 2n 1 *.
Esempio:
Numero: 5
*
***
*****
*******
*********
*******
*****
***
*
Hint: Riutilizzare quanto fatto per gli esercizi 32 e 33.
19
somma_100_for.py:
# Calcola la somma dei primi 100
# numeri naturali usando un ciclo for
somma = 0
somma += i
print somma
somma_100_while.py:
# Calcola la somma dei primi 100
# numeri naturali usando un ciclo while
somma = 0
i = 1
while i<=100:
somma += i
i += 1
print somma
1. for_dispari.py:
a = range(1,31)
for n in a[::2]:
print n,
print
Output in IDLE:
1 3 5 7 9 11 13 15 17 19 21 23 25 27 29
2. for_pari.py:
a = range(1,31)
for n in a[1::2]:
print n,
print
Output in IDLE:
2 4 6 8 10 12 14 16 18 20 22 24 26 28 30
3. for_multipli_5.py:
a = range(1,31)
for n in a[4::5]:
print n,
print
Output in IDLE:
5 10 15 20 25 30
20
1. tabelline_10_for.py:
for j in range(1,11):
print i, " x ", j, " = ", i*j
print
2. tabelline_10_while.py:
i = 1
while i <= 10:
j = 1
while j <= 10:
print i, " x ", j, " = ", i*j
j +=1
i += 1
print
1. fibonacci_while.py:
# Calcola la successione di Fibonacci
# tramite ciclo while
n0 = 0
n1 = 1
# Stampo a schermo i primi due
print n0, n1,
# due li ho gia stampati, calcolo i rimanenti
i = 2
while i < 16:
temp = n0
n0 = n1
n1 = n1 + temp
print n1,
i += 1
2. fibonacci_for.py:
# Calcola la successione di Fibonacci
# tramite ciclo for
n0 = 0
n1 = 1
# Stampo a schermo i primi due
print n0, n1,
# due li ho gia stampati, calcolo i rimanenti 14
for i in range(14):
temp = n0
n0 = n1
n1 = n1 + temp
print n1,
21
1. tribonacci_while.py:
# Calcola la successione di Tribonacci
# tramite ciclo while
n0 = 0
n1 = 1
n2 = 1
# Stampo a schermo i primi tre
print n0, n1, n2,
# tre li ho gia stampati, calcolo i rimanenti
i = 3
while i <= 15:
t0 = n0
t1 = n1
n0 = n1
n1 = n2
n2 = n2 + t0 + t1
print n2,
i += 1
2. tribonacci_for.py:
# Calcola la successione di Tribonacci
# tramite ciclo for
n0 = 0
n1 = 1
n2 = 1
# Stampo a schermo i primi tre
print n0, n1, n2,
# tre li ho gia stampati, calcolo i rimanenti 13
for i in range(13):
t0 = n0
t1 = n1
n0 = n1
n1 = n2
n2 = n2 + t0 + t1
print n2,
Diamo due possibili soluzioni, lo studente è incoraggiato a capire il funzionamento di entrambe.
1. montante1.py:
capitale = 1000
i = 0.04 # tasso di interesse
upi = 1.0+i # uno piu i
montante = capitale
montante *= upi
print j, montante
22
2. montante2.py:
capitale = 1000
i = 0.04 # tasso di interesse
upi = 1.0+i # uno piu i
montante = capitale
montante = capitale * upi**j
print j, montante
gauss_legendre_pi.py:
from math import sqrt
A = 1
X = 1
B = 1.0/sqrt(2)
C = 0.25
ApB = A + B
niter = 5
for i in range(niter):
Y = A
A = ApB/2.0
B = sqrt(B*Y)
C -= X*(A-Y)*(A-Y)
X = 2.0*X
ApB = (A+B)
pi_approx = ApB*ApB/(4.0*C)
print pi_approx
prog_num_triangle.py:
n = int(raw_input("Numero: "));
for i in range(1,n+1):
for j in range(1,i+1):
print j,
print
prog_num_triangle_inv.py:
for i in range(n):
for j in range(1,n-i+1):
print j,
print
floyds_triangle.py:
def floyds_triangle(n):
k = 1
for i in range(n):
23
for j in range(0,i+1):
print k,
k += 1
print
diag_pat.py:
for i in range(n):
print *i+*
inv_diag_pat.py:
for i in range(n-1,-1,-1):
print *i+*
square_pat.py:
for i in range(n):
print **n
rect_pat.py:
r = int(raw_input("Numero righe: "));
c = int(raw_input("Numero colonne: "));
for i in range(r):
print **c
ltriangle_pat.py:
print **i
inv_ltriangle_pat.py:
for i in range(n,0,-1):
print **i
rtriangle_pat.py:
print *(n-i)+**i
24
inv_rtriangle_pat.py:
for i in range(n,0,-1):
print *(n-i)+**i
di_ltriangle_pat.py:
print *(n-i)+**i
for i in range(n-1,0,-1):
print *(n-i)+**i
tree_pat.py:
for i in range(n):
na = 2*i+1 # numero asterischi
ns = n-i-1 # numero spazi
print *ns+**na
inv_tree_pat.py:
for i in range(n):
na = 2*(n-i)-1 # numero asterischi
ns = i # numero spazi
print *ns+**na
diamond_pat.py:
# Parte "sopra"
for i in range(n):
na = 2*i+1
ns = n-i-1
print *ns+**na+ *ns
# Parte "sotto", notare che
# il range parte da 1.
for i in range(1,n):
na = 2*(n-i)-1
ns = i
print *ns+**na+ *ns
25
Capitolo 5
Selezione if
Esercizio 35 Freddo o caldo: Scrivere un programma che chieda in input allutente

un numero. Siccome la funzione raw input() ritorna una stringa, convertire linput in numero
con la funzione float(). Supponendo di interpretare il numero come una temperatura in gradi
Celsius, verificare se il numero è:
minore di 15, in caso affermativo scrivere a schermo"freddo polare!";
maggiore o uguale a 15 e minore di 0, in caso affermativo scrivere "molto freddo";
maggiore o uguale a 0 e minore di 18, in caso affermativo scrivere "freddo";
maggiore o uguale a 18 e minore di 26, in caso affermativo scrivere "tiepido";
maggiore o uguale a 26 e minore di 32, in caso affermativo scrivere "caldo";
maggiore di 32, in caso affermativo scrivere "torrido!";
Esercizio 36 Numeri interi: Scrivere un programma che chieda in input allutente

un numero intero. Siccome la funzione raw input() ritorna una stringa, convertire linput in
numero intero con la funzione int(). Dopodichè verificare se il numero è:
divisibile per due, in caso affermativo scrivere "pari" in output, altrimenti scrivere
"dispari";
divisibile per tre, in caso affermativo scrivere "divisibile per tre";
divisibile per cinque, in caso affermativo scrivere "divisibile per cinque";
Notare che la funzione int() ritorna un errore se linput non è una stringa convertibile in
numero intero.
Esercizio 37 Verifica angolo: Scrivere un programma che chieda in input allutente

un numero. Siccome la funzione raw input() ritorna una stringa, convertire linput in numero
con la funzione float(). Supponendo di interpretare il numero come un angolo in gradi,
verificare se il numero è:
minore di zero o maggiore o uguale a 360, in caso affermativo scrivere a schermo "Angolo
fuori intervallo."
uguale a zero, in caso affermativo scrivere "Angolo nullo."
maggiore di zero e minore di 90, in caso affermativo scrivere "Primo quadrante."
26
uguale a 90, in caso affermativo scrivere "Angolo retto."
maggiore di 90 e minore di 180, in caso affermativo scrivere "Secondo quadrante."
uguale a 180, in caso affermativo scrivere "Angolo piatto."
maggiore di 180 e minore di 270, in caso affermativo scrivere "Terzo quadrante."
uguale a 270, in caso affermativo scrivere "Esplementare dellangolo retto".
maggiore di 270, in caso affermativo scrivere "Quarto quadrante."
Esercizio 38 Anno bisestile: Scrivere un programma che chieda in input allutente

un numero (intero positivo), che rappresenti un anno. Il programma, utilizzando la selezione
if, stabilisce se il numero corrisponde a un anno bisestile, nel qual caso scrive a schermo
"bisestile", altrimenti scrive "non bisestile". Per stabilire se un anno è bisestile o
meno (si veda lalgoritmo in Wikipedia):
se il numero non è divisibile per 4 non è bisestile;
altrimenti se non è divisibile per 100 è bisestile;
altrimenti se non è divisibile per 400 non è bisestile;
in tutti gli altri casi è bisestile.
Verificate il programma con i seguenti valori:
Anni bisestili: 2000, 2400, 1872, 1984, 1996, 2016;
Anni non bisestili: 1700, 1800, 1900, 1999, 2001, 2015.
Esercizio 39 sessagesimal2decimal: Scrivere un programma Python che converta

un angolo espresso in gradi in formato sessagesimale in formato decimale. Linput atteso è
una stringa del tipo "dd:pp:ss", dove dd rappresenta i gradi, numero intero nellintervallo
[0, 360), pp rappresenta i primi, numero intero nellintervallo [0, 59) e ss rappresemta i secondi,
numero intero nellintervallo [0, 59).
Lutente deve sempre specificare i primi e i secondi usando due cifre, la prima delle quali deve
essere 0 se i primi o i secondi sono minori di 10. Quindi la lunghezza della stringa in ingresso
può variare a seconda del numero di cifre utilizzate per i gradi. Ne consegue inoltre che le cifre
che compongono il numero dei secondi sono sempre le ultime due della stringa. Analogamente
le cifre dei primi e dei gradi si ottengono specificando delle opportune slice a partire dalla fine
della stringa.
Procedimento:
tramite la funzione raw_input() richiedere allutente una stringa contenente la rappre-

sentazione sessagesimale di una angolo;
se il carattere : non è presente nella stringa nelle posizioni attese (specificate a partire
dalla fine della stringa), scrivere un messaggio di errore;
altrimenti estrarre le sottostringhe (tramite slice come detto sopra) corrispondenti ai gradi,
primi e secondi e convertirle in numeri floating point tramite funzione float();
se il numero dei gradi è al di fuori dellintervallo [0, 360) scrivere un messaggio di errore;
27
altrimenti se il numero dei primi è al di fuori dellintervallo [0, 59) scrivere un messaggio
di errore;
altrimenti se il numero dei secondi è al di fuori dellintervallo [0, 59) scrivere un messaggio
di errore;
altrimenti convertire i gradi in decimali:
dec = dd + (pp + ss/60)/60
e stampare a schermo il valore ottenuto.
Esempio di esecuzione:
>>>
Angolo: 1:02:03
Angolo decimale: 1.03416666667
>>>
Angolo: 1:2:3
Errore di formato
>>>
Angolo: 1:99:00
Errore nei primi
28
freddo_o_caldo.py:
temp = float(raw_input("Temperatura: "))
if temp < -15:

print "freddo polare!"
elif temp < 0:
print "molto freddo"
elif temp < 18:
print "freddo"
elif temp < 26:
print "tiepido"
elif temp < 32:
print "caldo"
else:
print "torrido!"
numero_intero.py:
num = int(raw_input("Numero: "))
if num % 2:
print "dispari"
else:
print "pari"
if (num % 3) == 0:
print "divisibile per tre"
if (num % 5) == 0:
print "divisibile per cinque"
verifica_angolo.py:
ang = float(raw_input("Angolo: "))
if ang < 0 or ang >= 360:

print "Angolo fuori intervallo"
elif ang == 0:
print "Angolo nullo"
elif ang < 90:
print "Primo quadrante"
elif ang == 90:
print "Angolo retto"
elif ang < 180:
print "Secondo quadrante"
elif ang == 180:
print "Angolo piatto"
elif ang < 270:
print "Terzo quadrante"
elif ang == 270:
print "Esplementare dellangolo retto"
else:
print "Quarto quadrante"
29
anno_bisestile.py:
y = int(raw_input("Anno: "))
if y % 4:
print "non bisestile"
elif y % 100:
print "bisestile"
elif y % 400:
print "non bisestile"
else:
print "bisestile"
Soluzione dellesercizio ??
sessagesimal2decimal.py:
ang = raw_input("Angolo: ")
if ang[-3] != : or ang[-6] != ::
print "Errore di formato"
else:
dd = float(ang[:-6])
pp = float(ang[-5:-3])
ss = float(ang[-2:])
if dd < 0 or dd > 359:
print "Errore nei gradi"
elif pp < 0 or pp > 59:
print "Errore nei primi"
elif ss < 0 or ss > 59:
print "Errore nei secondi"
else:
dec = dd + (pp + ss/60.)/60.
print "Angolo decimale:",dec
30
Capitolo 6
Cicli e selezioni
Esercizio 40 Iterazioni con if: Scrivere un breve programma che generi una lista
contenente i numeri da 1 a 30 usando la funzione range(). Usando un ciclo for, iterate su
tutti gli elementi della lista, e stampate, su una sola riga:
1. i numeri della lista di partenza che sono dispari
2. i numeri della lista di partenza che sono pari
3. i numeri della lista di partenza che sono divisibili per cinque
usate listruzione if per verificare le condizioni richieste.
Esercizio 41 Ciclo di comandi: Scrivere un programma che, allinterno di un ciclo

while infinito:
stampi a schermo la scritta "Command: ";
memorizzi la stringa scritta dallutente in una variabile cmd;
se la stringa in cmd è uguale a "end" termini il ciclo (e lesecuzione del programma),
Hint: per i primi due punti usate listruzione cmd = raw_input("Command: ").
Esercizio 42 Da unit`
a imperiali a metriche: Scrivere un programma che converta
delle lunghezze da unit` a imperiali a metriche, interattivamente e limitatamente alla conversione
da yarde a metri, da piedi a decimetri e da pollici a centimetri. I fattori di conversione sono:
100 = 2.54cm, 10 = 1200 e 1y = 30 , dove 00 indica pollici, 0 piedi e y indica yarde.
Il programma deve iterare fintanto che lutente inserisce una stringa vuota (ovvero preme Enter
al prompt senza inserire alcun carattere). Lutente specifica la misura come un numero (reale)
seguito da apice doppio per indicare pollici, apice singolo per indicare piedi e il carattere y
per indicare le yarde. Se la stringa inserita dallutente non termina con uno dei caratteri che
indicano lunit` a di misure il programma scrive a schermo un messaggio di errore e prosegue con
le iterazioni. 1
>>>
Misura da convertire: 1"
1" = 2.54 cm
Misura da convertire: 2.1
2.1 = 6.4008 dm
Misura da convertire: 3.245y
1
Non si verifica che i caratteri prima dellunit`
a di misura rappresentino un numero reale valido perchè ci`
o
richiede nozioni che non abbiamo imparato a laboratorio.
31
3.245y = 2.967228 m
Misura da convertire: 12
non capisco...
Misura da convertire:
>>>
Esercizio 43 Computer indovina numero: Scrivere un programma che cerchi

di indovinare un numero tra 1 e 100 pensato dallutente. Il programma userà il metodo di
bisezione, ad ogni iterazione dividendo a metà lintervallo di numeri in cui si trova quello pensato
dallutente. Procedimento:
Scrivere a schermo le seguenti istruzioni
"Pensa un numero (intero) da 1 a 100."

"Scrivi + se il numero che hai pensato e piu grande, "
"scrivi - se e piu piccolo, o y se ho indovinato."
definire le variabili low = 1 e high = 101;
iterare allinfinito
porre la variabile guess pari a (low+high)/2;

usando raw_input() chiedere allutente se il numero che ha pensato è pari al valore
di guess (convertito in stringa con str()) e assegnare il testo digitato dallutente
alla variabile res;
se res è uguale a y, il programma ha indovinato, interrompere il ciclo;
se res è uguale a + porre low uguale a guess;
se res è uguale a - porre high uguale a guess;
altrimenti scrivere a schermo: "Non ho capito..."
scrivere a schermo "Ho indovinato!"
Esempio:
Pensa un numero (intero) da 1 a 100.
Scrivi + se il numero che hai pensato e piu grande,
scrivi - se e piu piccolo, o y se ho indovinato.
Il numero che hai pensato e 51? +
Il numero che hai pensato e 88? -
Il numero che hai pensato e 83? y
Ho indovinato!
Esercizio 44 Computer indovina numero senza imbrogli: Il programma scrit-

to allEsercizio 43 non è robusto, nel senso che non si accorge se lutente imbroglia (per es.
rispondendo sempre - o sempre + o alternando tali risposte).
` pi`
Sapreste modificare il programma affinchè identifichi limbroglio e termini lesecuzione? (E u
facile di quello che sembra.)
Hint: Notare che, se si imbroglia con le risposte, ad un certo punto il valore di guess...
Esempio:
32
Pensa un numero (intero) da 1 a 100.
Scrivi + se il numero che hai pensato e piu grande,
scrivi - se e piu piccolo, o y se ho indovinato.
Stai barando e io non gioco piu
33
1. for_and_if_dispari.py:
a = range(1,31)
for n in a:
if n % 2 == 1:
print n,
print
2. for_and_if_pari.py:
a = range(1,31)
for n in a:
if n % 2 == 0:
print n,
print
3. for_and_if_multipli_5.py:
a = range(1,31)
for n in a:
if n % 5 == 0:
print n,
print
cmd.py:
while True:
cmd = raw_input("Command: ")
print cmd
if cmd == "end":
break
imperial2metric.py:
in2cm = 2.54
ft2dm = in2cm * 1.2
y2m = ft2dm * 0.3
while True:
dat = raw_input("Misura da convertire: ")
if dat == "":
break
elif dat[-1] == ":
inches = float(dat[:-1])
cm = inches * in2cm
print dat,=,cm,cm
elif dat[-1] == "":
feet = float(dat[:-1])
dm = feet * ft2dm
34
print dat,=,dm,dm
elif dat[-1] == y:
yards = float(dat[:-1])
m = yards * y2m
print dat,=,m,m
else:
print "non capisco..."
computer_indovina_numero.py:
print "Pensa un numero (intero) da 1 a 100."
print "Scrivi + se il numero che hai pensato e piu grande, "
print "scrivi - se e piu piccolo, o y se ho indovinato."
low = 1
high = 101
while True:
guess = (high+low)/2
res = raw_input("Il numero che hai pensato e "+str(guess)+"? ")
if res == y:
break
elif res == +:
low = guess
elif res == -:
high = guess
else:
print "Non ho capito..."
print Ho indovinato!
computer_indovina_numero_robust.py:
print "Pensa un numero (intero) da 1 a 100."
print "Scrivi + se il numero che hai pensato e piu grande, "
print "scrivi - se e piu piccolo, o y se ho indovinato."
low = 1
high = 101
guess = 0
while True:
new_guess = (high+low)/2
if guess == new_guess:
print "Stai barando e io non gioco piu"
break
guess = new_guess
res = raw_input("Il numero che hai pensato e "+str(guess)+"? ")
if res == y:
print Ho indovinato!
break
elif res == +:
low = guess
elif res == -:
high = guess
else:
35
print "Non ho capito..."
36
Capitolo 7
Funzioni e moduli
Esercizio 45 Formula di Erone: Sapendo che la formula di Erone:

p
A = p (p a) (p b) (p c)
permette di calcolare larea di un triangolo note le lunghezze dei suoi tre lati (a, b, c) e
a+b+c
p=
2
è il semiperimetro, scrivere una funzione che accetti tre parametri (lunghezze dei lati) e che
ritorni larea del corrispondente triangolo calcolata usando la formula di Erone.
Hint: per calcolare la radice quadrata usate la funzione sqrt() del modulo math.
Esercizio 46 Radici di equazione di secondo grado: Scrivere una funzione che

calcoli le radici di una equazione di secondo grado, ovvero:
ax2 + bx + c = 0.
Procedimento:
definire una funzione che accetti tre parametri (corrispondenti ad a, b e c);
se a = 0, scrivere un messaggio di errore ed eseguire return senza parametri;
calcolare il discriminante = b2 4ac;
se < 0, lequazione non ha radici reali, eseguire return senza parametri;
se = 0, lequazione ha due soluzioni coincidenti, ritornare b/2a;
altrimenti, ritornare le due soluzioni:

b b +
x1 = ; x2 = .
2a 2a
Usare la funzione per trovare le radici di:
x2 5x + 6 = 0 [2; 3]
2
2x 3x 5 = 0 [1; 2.5]
37
Esercizio 47 Anno bisestile, funzione: Trasformare il programma dellEsercizio 38
in una funzione che accetti un intero come parametro di input e che ritorni True se il numero
corrisponde ad un anno bisestile o False in caso contrario.
Esercizio 48 Giorno dellanno: Scrivere una funzione che accetti tre parametri interi
che rappresentino giorno, mese e anno di una certa data e che calcoli i giorni trascorsi dallinizio
dellanno in quella data. Per esempio, per il primo gennaio (di qualsiasi anno) il risultato sar` a
1, il giorno successivo sar`
a 2, eccetera. Per le date successive al 28 febbraio il risultato cambia a
seconda che lanno sia bisestile o meno. A tal fine, utilizzare la funzione scritta come soluzione
dellEsercizio 47. Procedimento:
definire una funzione che accetti tre parametri: giorno, mese e anno;
definire una lista contenente i giorni di ciascun mese dellanno (in ordine da gennaio a
dicembre);
se lanno passato in input è bisestile, porre il secondo elemento della lista uguale a 29;
verificare che il numero del mese sia compreso tra 1 e 12, in caso contrario scrivere a
schermo un messaggio di errore e ritornare zero;
verificare che il giorno specificato sia compreso tra 1 e il numero di giorni del mese (que-
stultimo preso dalla lista preparata in precedenza) in caso contrario scrivere a schermo
un messaggio di errore e ritornare zero;
inizializzare a zero una variabile (ad es. day of year) che conterr`
a il risultato;
per tutti i mesi da gennaio fino a quello precedente alla data specificata, iterare sulla lista
dei giorni di ciascun mese e sommarli alla variabile day of year;
aggiungere i giorni della data considerata (parametro giorno, in input);
ritornare il risultato al chiamante.
Provate la funzione con le seguenti date:
data doy
1 gennaio 1
31 gennaio 31
1 marzo 2015 60
1 marzo 2016 61
28 ottobre 2015 301
28 ottobre 2016 302
31 dicembre 1900 365
31 dicembre 2000 366
Esercizio 49 Da giorno dellanno a data: Scrivere una funzione inversa rispetto a

quella descritta nellEsercizio 48. La funzione accetta in input due parametri, giorno dellanno
e anno, e calcola la corrispondente data.
Verificate la funzione con le date dellEsercizio 48.
Hint: iterare sulla lista dei giorni del mese, costruita come nellEsercizio 48. Finchè il giorno
dellanno è maggiore dei giorni nel mese considerato, sottrarre questi ultimi dal primo. Al
termine delliterazione, la variabile giorno dellanno conterrà il giorno della data cercata. . .
38
Esercizio 50 Pasqua Gregoriana: Scrivere una funzione Python che calcoli il giorno
in cui cade la Pasqua nel calendario Gregoriano, quindi per gli anni successivi al 1582, secondo
il metodo illustrato al Capitolo 8 di Meeus (1991).
Procedimento:
definire una funzione che accetti un solo parametro anno;
forzare, tramite funzione int() la variabile anno a contenere un valore intero;
effettuare i seguenti calcoli, memorizzando i valori in variabili con lo stesso nome delle
quantità indicate:
Dividere per quoziente resto
anno 19 - a
anno 100 b c
b 4 d e
b+8 25 f -
bf +1 3 g -
19a + b d g + 15 30 - h
c 4 i k
32 + 2e + 2i h k 7 - l
a + 11h + 22l 451 m -
h + l 7m + 114 31 n p
dove per quoziente e resto si intendono quelli ottenuti tramite divisione intera1
a questo punto il numero del mese in cui cade la Pasqua (3 o 4, marzo o aprile) è contenuto
nella variabile n, mentre il numero del giorno è dato da p+1.
ritornare la data di Pasqua come una unica stringa del tipo anno-mese-giorno
(ad esempio 2015-4-5), utilizzando la funzione str() per convertire le variabili
numeriche in stringa e loperatore di concatenazione di stringhe +.
Verificare la funzione scritta con le seguenti date:
anno mese giorno

1950 4 9
1999 4 4
2000 4 23
2016 3 27
2022 4 17
Esercizio 51 Da decimale a binario: Scrivere una funzione che converta un

numero intero positivo in una stringa contenente la rappresentazione del numero in binario.
Procedimento:
definire una funzione che accetta un solo parametro: n;
inizializzare una variabile b a stringa vuota;
se n non è intero o se è negativo:
stampare un messaggio di erroe e ritornare la stringa vuota b;
forzare n ad essere variabile di tipo intero n = int(n)

1
Per esempio il quoziente e resto della divisione intera 2015/15 sono rispettivamente 134 e 5.
39
iterare fintanto che n è diverso da zero;
se il resto della divisione intera di n per due è diverso da zero, porre b = 1+b
altrimenti porre b = 0+b
assegnare a n il risultato della sua divisione intera per 2
ritornare 0b+b
Verificare la funzione comparandone il risultato con la funzione bin(), per esempio:
>>> dec2bin(7)
0b111
>>> bin(7)
0b111
>>> dec2bin(1234)
0b10011010010
>>> bin(1234)
0 b 1 0 0 1 1 0 1 0 0 1 0
>>> dec2bin(7) == bin(7)
True
>>> dec2bin(1234) == bin(1234)
True
Esercizio 52 Da decimale a binario, ricorsivamente: Scrivere una funzione

ricorsiva che converta un numero intero positivo in una stringa contenente la rappresentazione
del numero in binario. Procedimento:
se n non è intero o se è negativo: ritornare un messaggio di errore;
altrimenti se il numero è zero, ritornare la stringa vuota ;
altrimenti ritorna il risultato della chiamata ricorsiva con parametro il numero diviso due;
pi`
u la rappresentazione in stringa del resto della divisione intera per due;
Confrontare il risultato della funzione scritta con il risultato di bin(). Esempio:
>>> dec2bin_rec(1234)
10011010010
>>> bin(1234)
0b10011010010
Esercizio 53 Un clone di bin(): Scrivere una funzione che, usando quella scritta
come soluzione dellEsercizio 52, ritorni la rappresentazione binaria del numero intero in input
come stringa che inizia con 0b, analogamente a quanto fatto dalla funzione bin(). Esempio:
>>> bin_clone(4321)
0b1000011100001
>>> bin(4321)
0b1000011100001
Esercizio 54 Da decimale a ottale: Scrivere una funzione che converta un numero

intero positivo in una stringa contenente la rappresentazione del numero in ottale. Procedimen-
to:
40
inizializzare una variabile o a stringa vuota;
se n non è intero o se è negativo:
stampare un messaggio di erroe e ritornare la stringa vuota o;
forzare n ad essere variabile di tipo intero n = int(n)
iterare fintanto che n è diverso da zero;
porre o uguale alla rappresentazione in stringa del resto della divisione intera di n
per 8 pi`
u o;
assegnare a n il risultato della sua divisione intera per 8.
ritornare 0+o
Verificare la funzione comparandone il risultato con la funzione oct(), per esempio:
Esercizio 55 Da decimale a ottale, ricorsivamente: Scrivere una funzione ricor-

siva che converta un numero intero positivo in una stringa contenente la rappresentazione del
numero in ottale. Procedimento:
definire una funzione che accetta un solo parametro;
controllare se il numero in ingresso è minore di zero, se lo è ritornare un messaggio di

errore;
altrimenti se il numero è zero, ritornare la stringa vuota ;
altrimenti ritorna il risultato della chiamata ricorsiva con parametro il numero diviso otto;
pi`
u la rappresentazione in stringa del resto della divisione intera per otto;
Confrontare il risultato della funzione scritta con il risultato di oct(). Esempio:
>>> dec2oct_rec(1234)
2322
>>> oct(1234)
02322
>>> dec2oct_rec(4321)
10341
>>> oct(4321)
010341
Esercizio 56 Un clone di oct(): Scrivere una funzione che, usando quella scritta
come soluzione dellEsercizio 55, ritorni la rappresentazione binaria del numero intero in input
come stringa che inizia con 0, analogamente a quanto fatto dalla funzione oct(). Esempio:
>>> oct_clone(1234)
02322
>>> oct(1234)
02322
>>> oct_clone(4321)
010341
>>> oct(4321)
010341
41
Esercizio 57 Numeri di Thabit: Scrivere una funzione che, dato un intero positivo
n in input, calcoli il numero di Thabit: 3 2n 1. Verificare che il numero risultante, in
binario, è composto da 10 seguito da n 1 (sulla base di quanto visto a lezione riguardo la
rappresentazione dei numeri interi positivi, sapete spiegare il perchè?).
Esempio:
>>> thabit(5)
95
>>> bin(95)
0b1011111
Esercizio 58 Teorema di Pitagora: Scrivere una funzione che accetti due parametri
di input, interpretati come lunghezze dei cateti di un triangolo rettangolo, e che calcoli la
lunghezza dellipotenusa usando il Teorema di Pitagora: c = a + b2 (dove evidentemente a e
2
b sono le lunghezze dei cateti, c quella dellipotenusa e si assume la geometria Euclidea).
Esercizio 59 Grafici di funzioni: Scrivere delle funzioni che facciano il grafico di:
1. y = sin(x) in [, ]
2. y = cos(x) in [, ]
3. y = log(x) in [1, 100]
4. y = ex in [0, 5]
Definire le funzioni con tre parametri opzionali: xmin, xmax e npts numero di punti da
graficare. Scegliete i valori di default in modo opportuno a seconda della funzione. Ricordate
che le funzioni seno, coseno, logaritmo ed esponenziale, cos` come sono definite nel modulo
math.
Esercizio 60 Somma delle cifre di un intero: Scrivere una funzione che, dato
un intero come parametro di input, calcoli la somma delle cifre che lo compongono, secondo il
seguente procedimento:
verificare che il parametro di input n sia un intero, in caso contrario scrivere a schermo
assegnare a n il risultato della funzione int() applicato a n (per assicurarsi che la variabile
sia di tipo intero)
inizializzare a zero una variabile s che conterr`

a il risultato;
iterare finchè n è maggiore di zero:
sommare a n il resto della divisione intera di n per dieci;

assegnare a n il risultato della sua divisione intera per dieci;
ritornare il valore di s.
Esercizio 61 Somma delle cifre di un intero bis: Scrivere una funzione che, dato
un intero come parametro di input, calcoli la somma delle cifre che lo compongono, secondo il
seguente procedimento:
verificare che il parametro di input n sia un intero, in caso contrario scrivere a schermo
assegnare ad una variabile ns il valore di n convertito in stringa;
42
inizializzare a zero una variabile s che conterr`
a il risultato;
iterare su tutti i caratteri di ns e sommare a s il valore della variabile di iterazione

convertito ad intero;
ritornare il valore di s.
Esercizio 62 Algoritmo di Horner: Scrivere una funzione che valuti un polinomio

definito come:
PN (x) = aM xM + a(M 1) xM 1 . . . + a2 x2 + a1 x + a0
in un dato punto x0 , tramite lalgoritmo di Horner, secondo il seguente procedimento:
definire una funzione che accetti due parametri. Sia il primo, x0, il punto dove si vuole
valutare il polinomio e il secondo, coeffs, una lista di coefficenti, in ordine da quello del
termine di grado maggiore aM a quello del termine di grado zero, a0 .
assegnare a una variabile result il valore del primo coefficiente (primo elemento della
lista);
iterare sui rimanenti elementi della lista e assegnare a result la somma della variabile
di iterazione pi`
u il prodotto di x0 per result.
Provare la funzione con il polinomio:
PN (x) = (x 3)(x + 3)(x + 5)(x + 8)(x 2)(x 7) =

= x6 + 4x5 72x4 214x3 + 1127x2 + 1602x 5040.
Verificare che 8, 5, 3, 2, 3, 7 sono radici del polinomio (ovvero il polinomio calcolato in quel
punto vale zero). Verificare che PN (2.7) = 424.0695 . . . e PN (8.001) = 24.76958 . . .
Esercizio 63 Algoritmo di Horner ricorsivo: Implementare la funzione dellEser-

cizio 62 utilizzando la ricorsione al posto del ciclo.
Esercizio 64 Giorno Giuliano: Il giorno Giuliano (Julian Day), molto utilizzato

in Astronomia, conta i giorni (e frazioni) a partire dallanno 4712. Per tradizione, il giorno
Giuliano comincia al mezzogiorno medio di Greenwich. Scriviamo una funzione che dati in input
lanno, il mese e il giorno (frazionario), calcoli il corrispondente giorno Giuliano, seguendo il
metodo descritto nel Capitolo 7 di Meeus (1991).
Procedimento:
Siano y, m e dd rispettivamente lanno, il mese e il giorno della data considerata;
Se m 2, sottrarre 1 a y e aggiungere 12 a m;
Calcolare tst = y + (m + dd/100.0)/100.0, dopodichè:
se tst 1582.1015, allora calcolare A = INT (y/100) e B = 2 A + INT (A/4);

altrimenti porre B = 0.
Calcolare e ritornare:
JD = INT (365.25 (y + 4716)) + INT (30.6001 (m + 1)) + dd + B 1524.5
43
Esercizio 65 Giorno Giuliano modificato: Riutilizzando la funzione scritta per
lEsercizio 64, scrivere una funzione che ritorni il giorno Giuliano modificato (Modified Julian
Day, MJD), definito semplicemente come:
MJD = JD 2400000.5.
Esercizio 66 Numeri perfetti: In matematica, un numero naturale N si dice numero

perfetto quando la somma di tutti i suoi divisori propri è pari al numero stesso. Scrivere una
funzione che, dato un numero naturale N in ingresso, ritorni True se il numero è perfetto
secondo la definizione data prima, o False in caso contrario. Procedimento:
se il parametero di input n non è intero o è 0, ritornare False;
inizializzare una lista di divisori come lista vuota;
inizializzare una variabile maxn peri alla divisione intera di n per due pi`
u uno;
iterare da uno a maxn, con variabile di iterazione i:
se n è divisibile per i, aggiungere i alla lista dei divisori;
ritornare True se la somma dei divisori (funzione sum()) è uguale a n o False in caso
contrario.
Verificare che la funzione ritorna True per i numeri 6, 28, 496 e False per 10, 34, 500.
Esercizio 67 Crivello di Eratostene: Il crivello di Eratostene è un procedimento

per trovare tutti i numeri primi entro un numero prefissato. Implementare il crivello in una
funzione Python secondo il seguente procedimento:
definire una funzione che accetti un solo parametro di input maxn (il numero massimo
entro il quale cercare i numeri primi);
definire una lista lista con tutti i numeri interi da zero a maxn;
definire una variabile limite, pari alla parte intera della radice quadrata di maxn;
iterare da due a limite, con variabile di iterazione n:
se il valore di lista nella posizione di indice n è diverso da -1:
* a partire dallelemento di indice n*n porre a -1 tutti gli elementi i cui indici sono
un multiplo di n;
inizializzare un lista primi, vuota;
iterare su tutti gli elementi di lista a partire da quello di indice due e fino alla fine:
se lelemento corrente è diverso da -1, aggiungerlo alla fine della lista primi
ritornare al chiamante la lista primi.
>>> crivello_eratostene(20)
[2, 3, 5, 7, 11, 13, 17, 19]
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
44
erone.py:
import math as m
def erone(a, b, c):
p = (a+b+c)/2.0
return m.sqrt(p*(p-a)*(p-b)*(p-c))
eq2_roots.py:
def eq2_roots(a, b, c):
if a == 0:
print a deve essere diverso da zero
return
delta = b*b - 4*a*c
if delta < 0:
return
elif delta == 0:
return -b/(2*a)
else:
sd = sqrt(delta)
return (-b-sd)/(2*a), (-b+sd)/(2*a)
is_leap.py:
def is_leap(y):
y = int(y) # Ci assicuriamo che y sia intero
if y % 4: return False
if y % 100: return True
if y % 400: return False
return True
day_of_year.py:
# La funzione is_leap e contenuta in is_leap.py
# nella directory corrente.
from is_leap import *
def day_of_year(day, month, year):

# Lista dei giorni per ciascun mese
month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
# Se anno bisestile, Febbraio ha 29 giorni
if is_leap(year): month_days[1] = 29
# Verifichiamo mese e giorno in input

if month < 1 or month > 12:
print "Mese inesistente"
return 0
if day < 1 or day > month_days[month-1]:
print "Giorno inesistente"
45
return 0
# Il giorno dellanno e dato dalla somma dei

# giorni di tutti i mesi precedenti a quello specificato
# piu il giorno dato in input
day_of_year = 0
for i in range(month-1):
day_of_year += month_days[i]
day_of_year += day
return day_of_year
doy2date.py:
# La funzione is_leap e contenuta in is_leap.py
# nella directory corrente.
from is_leap import *
def doy2date(doy, year):

# Lista dei giorni per ciascun mese
month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
# Se anno bisestile, Febbraio ha 29 giorni
if is_leap(year): month_days[1] = 29
if doy < 1 or doy > sum(month_days):

print "Day of year out of range"
return
mm = 0
dd = month_days[mm]
while dd < doy:
doy -= dd
mm += 1
dd = month_days[mm]
return year, mm+1, doy
pasqua_gregoriana.py:
def pasqua_gregoriana(anno):
anno = int(anno)
a = anno % 19
b = anno / 100
c = anno % 100
d = b / 4
e = b % 4
f = (b + 8) / 25
g = (b - f + 1) / 3
h = (19*a + b - d - g + 15) % 30
i = c / 4
k = c % 4
46
l = (32 + 2*e + 2*i - h - k) % 7
m = (a + 11*h + 22*l) / 451
t = h + l - 7*m + 114
n = t / 31
p = t % 31
return str(anno)+-+str(n)+-+str(p+1)
dec2bin.py:
def dec2bin(n):
b = ""
if int(n) != n or n < 0:
print "n deve essere un numero intero positivo"
return b
n = int(n)
while n != 0:
if n % 2:
b = "1"+b
else:
b = "0"+b
n /= 2
return 0b+b
dec2bin_rec.py:
def dec2bin_rec(n):
if n < 0:
return Input must be a positive integer
elif n==0:
return
else:
return dec2bin_rec(n/2) + str(n%2)
bin_clone.py:
# La funzione dec2bin_rec si trova nel file
# dec2bin_rec.py nella directory corrente.
from dec2bin_rec import *
def bin_clone(n):
if n < 0:
else:
return 0b + dec2bin_rec(n)
dec2oct.py:
def dec2oct(n):
o =
if int(n) != n or n < 0:
47
print "n deve essere un numero intero positivo"
return
n = int(n)
while n != 0:
o = str(n % 8) + o
n /= 8
return 0 + o
dec2oct_rec.py:
def dec2oct_rec(n):
if n < 0:
elif n==0:
return
else:
return dec2oct_rec(n/8) + str(n%8)
oct_clone.py:
# La funzione dec2oct_rec si trova nel file
# dec2oct_rec.py nella directory corrente.
from dec2oct_rec import *
def oct_clone(n):
if n < 0:
else:
return 0 + dec2oct_rec(n)
thabit.py:
# https://en.wikipedia.org/wiki/Thabit_number
def thabit(n):
return 3*2**n-1
pitagora.py:
import math as m
def pitagora(a, b):
return m.sqrt(a*a + b*b)
1. plotsin.py:
import math
import matplotlib.pyplot as plt
def plotsin(xmin = -math.pi, xmax = math.pi, npts = 201):
xdif = (xmax-xmin)/(npts-1.)
lx = []
48
ly = []
for i in range(npts):
x = xmin+i*xdif
y = math.sin(x)
lx.append(x)
ly.append(y)
plt.plot(lx,ly)
plt.show()
2. plotcos.py:
import math
def plotcos(xmin = -math.pi, xmax = math.pi, npts = 201):
lx = []
ly = []
x = xmin+i*xdif
y = math.cos(x)
lx.append(x)
ly.append(y)
plt.plot(lx,ly)
plt.show()
3. plotlog.py:
import math
def plotlog(xmin = 1., xmax = 100, npts = 201):
lx = []
ly = []
x = xmin+i*xdif
y = math.log(x)
lx.append(x)
ly.append(y)
plt.plot(lx,ly)
plt.show()
4. plotexp.py:
import math
def plotexp(xmin = 0., xmax = 5, npts = 201):
lx = []
ly = []
x = xmin+i*xdif
y = math.exp(x)
lx.append(x)
49
ly.append(y)
plt.plot(lx,ly)
plt.show()
sum_digits.py:
def sum_digits(n):
if int(n) != n:
print "Il numero in ingresso deve essere un intero."
return 0
n = int(n)
s = 0
while n > 0:
s += n % 10
n /= 10
return s
sum_digits_str.py:
def sum_digits_str(n):
if int(n) != n:
print "In numero in ingresso deve essere un intero."
return 0
ns = str(int(n))
s = 0
for d in ns:
s += int(d)
return s
horner.py:
def horner(x0, coeffs):
result = float(coeffs[0])
for c in coeffs[1:]:
result = c + result*x0
return result
horner_rec.py:
def horner_rec(x0, coeffs):
if len(coeffs) == 1:
return float(coeffs[0])
else:
return coeffs[-1] + x0 * horner_rec(x0, coeffs[:-1])
50
jd.py:
def jd(y, m, dd):
if m <= 2:
y -= 1
m += 12
tst = y + (m + dd/100.0)/100.0
if tst >= 1582.1015:
A = int(y/100.)
B = 2-A+int(A/4.)
else:
B = 0
JD = int(365.25*(y+4716))+int(30.6001*(m+1))+dd+B-1524.5
return JD
mjd.py:
from jd import *
def mjd(y, m, dd):

return jd(y, m, dd)-2400000.5
is_perfect.py:
def is_perfect(n):
if int(n) != n or n <= 0:
return False
divisors = []
maxn = int(n/2)+1
for i in range(1,maxn):
if n % i == 0: divisors.append(i)
return sum(divisors) == n
crivello_eratostene.py:
import math as m
def crivello_eratostene(maxn):
lista = list(range(maxn+1))
limite = int(m.sqrt(maxn))
for n in range(2,limite+1):
if lista[n] != -1:
idx = n*n
while idx < len(lista):
lista[idx] = -1
idx += n
primi = []
for n in lista[2:]:
if n != -1:
51
primi.append(n)
return primi
52
Capitolo 8
Serie numeriche
Esercizio 68 Serie per e: La base del logaritmo naturale e = 2.7182818284590 . . . può

essere calcolata usando la seguente serie:

X 1
e=
n!
n=0
Scrivere una funzione Python che, dato un numero intero m in ingresso, calcoli tramite ciclo
for la serie fino a al termine m-esimo.
Esercizio 69 Serie per e, ricorsiva: Riscrivere la funzione dellEsercizio 68 in modo

da usare la ricorsione anzichè un ciclo.
Esercizio 70 Serie di Nilakantha: Una serie infinita per il calcolo di è stata

pubblicata nel quindicesimo secolo dallastronomo indiano Nilakantha Somayaji:
4 4 4 4
=3+ + ...
2 3 4 4 5 6 6 7 8 8 9 10
che si può anche scrivere come:

X 1n
=3+4 .
(2n + 2) (2n + 3) (2n + 4)
n=0
Scrivere una funziona Python che, usando un ciclo for, calcoli la serie fino al termine N -esimo
(con N intero e 0), ovvero:
N
X 1n
3+4 .
(2n + 2) (2n + 3) (2n + 4)
n=0
Hint: Siccome nei termini a denominatore appare solo 2n, conviene iterare usando la funzione
range() a passi di 2. Osservare anche che il segno di ciascun termine è inizialmente positivo
e poi è lopposto di quello del termine precedente.
Esercizio 71 Serie di Nilakantha ricorsiva: Riscrivere la funzione dellEsercizio 70

in modo da usare la ricorsione anzichè un ciclo.
53
natural_e.py:
import math
def natural_e(n):
e = 0.0
for i in range(n+1):
e += 1.0/math.factorial(i)
return e
natural_e_rec.py:
import math
def natural_e_rec(n):
if n == 0:
return 1.0
return 1.0/math.factorial(n)+natural_e_rec(n-1)
nilakantha_pi.py:
# Nilakantha
# see https://en.wikipedia.org/wiki/Pi (Rate of convergence)
def nilakantha_pi(n):
acc = 0.0
sign = +1.0 # segno inizialmente positivo
for i in range(0,2*n+1,2):
acc += sign/((i+2.0)*(i+3.0)*(i+4.0))
sign *= -1.0 # segno alterno
return 3.0+4.0*acc
nilakantha_pi_rec.py:
def nilakantha_pi_rec(n):
sign = 1.0-2.0*(n % 2)
if n == -1:
return 3.0
else:
i = 2.0*n
return sign*4.0/((i+2.0)*(i+3.0)*(i+4.0)) + nilakantha_pi_rec(n-1)
54
Capitolo 9
Numeri casuali
Esercizio 72 Lotto (shuffle): Scrivere una funzione che simuli una estrazione di
cinque numeri del lotto. I cinque numeri estratti dovranno quindi essere compresi tra 1 e 90
e non devono ripetersi. Procedimento:
generare una lista l con i numeri interi da 1 a 90;
mescolare la lista l usando la funzione shuffle() del modulo random;
ritornare i primi cinque elementi della lista l.
Esercizio 73 Lotto (choice): Implementare una funzione che simuli una estrazione
di cinque numeri del lotto, con le caratteristiche descritte allEsercizio 72, ma che utilizzi la
funzione choice() del modulo random. Procedimento:
generare una lista l con i numeri interi da 1 a 90 e una lista r inizialmente vuota;
iterare per 5 volte e a ciascun passo:
scegliere un elemento a caso di l;

aggiungerlo alla fine della lista r;
rimuovere lelemento da l.
ritornare la lista r.
Esercizio 74 Lotto (random index): Implementare una funzione che simuli una
estrazione di cinque numeri del lotto, con le caratteristiche descritte allEsercizio 73, ma che
utilizzi la funzione randint() del modulo random per generare lindice dellelemento da
selezionare nella lista l. Rimuovere lelemento cos` selezionato usando pop().
Esercizio 75 Indovina numero: Scrivere un programma Python che generi un nu-

mero casuale tra 1000 e 9999 e chieda allutente di indovinarlo, iterando fino ad ottenere la
risposta giusta e fornendo dei suggerimenti.
Procedimento:
generare un numero intero casuale tra 1000 e 9999 e convertirlo in stringa usando la
funzione str();
ripetere finchè lutente non indovina il numero:
usando la funzione raw_input() chiedere allutente di indovinare il numero;
55
se la stringa inserita dallutente non è composta da quattro caratteri, si saltano i
passi successivi e si ritorna a richiedere input;
se la stringa inserita è uguale al numero da indovinare, stampare "Indovinato!"
e interrompere le iterazioni;
altrimenti iterare su ciascun carattere dellinput e:
* se la cifra corrispondente del numero da indovinare coincide, stampare tale cifra
(senza andare a capo)
* se la cifra corrispondente del numero da indovinare è pi`
u piccola, stampare -
(senza andare a capo)
* altrimenti stampare + (senza andare a capo)
stampare una riga vuota per andare a capo.
Esempio:
Numero ? 5555
+ - - +
Numero ? 6446
+ - - 6
Numero ? 7336
+ - - 6
Numero ? 8226
+ - 2 6
Numero ? 9126
Indovinato!
56
lotto_shuffle.py:
from random import shuffle
def lotto_shuffle():
lst = range(1,91) # tutti i numeri da 1 a 90
shuffle(lst) # mescoliamo la lista
return lst[0:5] # e ritorniamo i primi 5 numeri
lotto_choice.py:
from random import choice
def lotto_choice():
l = range(1,91,1) # tutti i numeri da 1 a 90
r = [] # lista risultato inizialmente vuota
for i in range(5): # estraiamo 5 numeri
el = choice(l) # scegliamo un elemento a caso
r.append(el) # lo aggiungiamo alla lista risultato
l.remove(el) # e lo rimuoviamo dalla lista dei numeri
# per evitare che appaia di nuovo
return r
lotto_randint.py:
from random import randint
def lotto_randint():
lst = range(1,91) # tutti i numeri da 1 a 90
res = [] # lista risultato inizialmente vuota
for i in range(5): # estraiamo 5 numeri
# indice tra 0 e len(lst)-1
idx = randint(0, len(lst)-1)
# aggiungiamo ai risultati il numero alla
# posizione (causale) idx
res.append(lst[idx])
# rimuoviamo lelemento dalla lista per
# evitare che appaia di nuovo
lst.pop(idx)
return res
indovina_numero.py:
from random import randint
num = str(randint(1000, 9999))

while True:
guess = raw_input("Numero ? ")
if len(guess) == 4:
if guess == num:
57
print "Indovinato!"
break
for i in range(len(guess)):
if num[i] == guess[i]:
print num[i],
elif int(num[i]) < int(guess[i]):
print -,
else:
print +,
print
58
Capitolo 10
Numpy
Esercizio 76 Somma di interi, versione numpy: Scrivere un programma Python

che, usando array numpy e senza impiegare dei cicli, calcoli e mostri a video la somma dei primi
100 numeri naturali.
Esercizio 77 Tabellina, versione numpy: Scrivere un breve programma Python

che, usando un array numpy, calcoli e stampi la tabellina di moltiplicazione dei numeri da uno
a dieci.
Output atteso:
[ 1 2 3 4 5 6 7 8 9 10]
[ 2 4 6 8 10 12 14 16 18 20]
[ 3 6 9 12 15 18 21 24 27 30]
[ 4 8 12 16 20 24 28 32 36 40]
[ 5 10 15 20 25 30 35 40 45 50]
[ 6 12 18 24 30 36 42 48 54 60]
[ 7 14 21 28 35 42 49 56 63 70]
[ 8 16 24 32 40 48 56 64 72 80]
[ 9 18 27 36 45 54 63 72 81 90]
[ 10 20 30 40 50 60 70 80 90 100]
Esercizio 78 Thabit, versione numpy: Scrivere una funzione Python che accetti
in ingresso un solo parametro, maxn che si assume essere un numero intero, e ritorni un array
numpy contenente tutti i numeri di Thabit 3 2n 1, con n che va da zero a maxn.
Esercizio 79 Montante, versione numpy: Usando i dati dellEsercizio 18, scrivere

un breve programma che calcoli la tabella anni, montante usando numpy. Calcolare prima un
array con gli anni da 1 a 10 e poi un array con i corrispondenti montanti. Quindi iterare su
tutti gli anni e stampare la tabella anno, montante (loutput atteso è lo stesso di Esercizio 18)
Esercizio 80 Seno e coseno: Usando la funzione linspace() del modulo numpy,

scrivere un breve programma che generi un array con i numeri da 0 a 2, entrambi inclusi, ed
equispaziati di /4. Calcolare le funzioni seno e coseno su tali punti e verificare che il risultato
sia quello atteso, ovvero:
p p p p
(2), 0, 1/ (2),
[0, 1/p (2), 1, 1/ p p 1, 1/p (2), 0]
[1, 1/ (2), 0, 1/ (2), 1, 1/ (2), 0, 1/ (2), 1].
Esercizio 81 Grafici di funzioni, numpy: Scrivere delle funzioni Python che,

utilizzando il modulo numpy, facciano il grafico di:
59
1. y = sin(x) in [, ]
2. y = cos(x) in [, ]
3. y = log(x) in [1, 100]
4. y = ex in [0, 5]
Definire le funzioni con tre parametri opzionali: xmin, xmax e npts numero di punti da
graficare. Scegliete i valori di default in modo opportuno a seconda della funzione. Definire x
come vettore numpy e calcolarne i valori con la funzione linspace(). Ricordate di utilizzare
le funzioni seno, coseno, logaritmo ed esponenziale, cos` come definite nel modulo numpy.
Esercizio 82 Grafico di CelsiusFarenheit: Scrivere una funzione Python che

faccia un grafico della relazione (lineare) tra gradi Celsius e Farenheit. La funzione dovrà avere
tre parametri opzionali: limiti per il calcolo e il grafico (Tmin, Tmax) numero di punti (N), con
valori di default rispettivamente 10, 120 e 130. Calcolare i gradi Celsius usando la funzione
linspace(), dopodichè convertirli in Farenheit usando la nota relazione:
9
F = C + 32.
5
Fare il grafico mettendo i gradi Celsius in ascissa e i corrispondenti Farenheit in ordinata.
Esercizio 83 Grafico di polinomio: Utilizzando la funzione per il calcolo di polinomi

tramite algoritmo di Horner, descritta allEsercizio 62, calcolare il polinomio:
x3 30x2 + 2552
in 201 punti nellintervallo [10, 30] e farne il grafico.
Output atteso:
Esercizio 84 Riproduci grafico: Sapendo che, per effettuare il grafico mostrato nella
figura seguente:
60
sono state utilizzare le funzioni linspace(), fabs() e sin() del modulo numpy, plot(),
xlim(), ylim(), show() del modulo matplotlib.pyplot e che sono stati graficati 201
punti, scrivere un breve programma Python che riproduca il grafico sopra riportato.
Esercizio 85 Crivello di Eratostene, versione numpy: Scrivere una funzione

che implementi il Crivello di Eratostene, come descritto allEsercizio 67, ma utizzando array
numpy al posto delle liste. Utilizzare le funzionalità di numpy in particolare per ridurre i cicli
da tre a uno solo.
Esercizio 86 Somma cumulativa: Scrivere una funzione Python che accetti in input
un array monodimensionale numerico e ne calcoli la somma cumulativa, definita come larray:
n
X
s[n] = v[i] n = 0, . . . , N 1.
i=0
dove s è larray somma cumulativa, v larray di input, di dimensione N .

Provare la funzione passando come input un array numpy contenente i numeri interi da 1 a 10.
Output atteso:
>>> somma_cumulativa(a)
array([ 1., 3., 6., 10., 15., 21., 28., 36., 45., 55.])
Esercizio 87 Verifica somma cumulativa: Scrivere una funzione Python che ac-
cetti in input un array monodimensionale numerico e verifichi che la somma cumulativa calco-
lata con la funzione descritta nellEsercizio 86 coincida con quella calcolata usando la funzione
cumsum() di numpy.
Procedimento:
calcolare la somma cumulativa con la funzione scritta come soluzione dellEsercizio 86 e

con cumsum(), assegnare i risultati a due variabili a1 e a2, rispettivamente;
calcolare, usando la funzione fabs() di numpy, il valore assoluto della differenza tra a1
e a2 elemento per elemento;
usando la funzione where() determinare per quanti elementi il valore assoluto della
differenza è maggiore di 1012 ;
se vi è anche un solo elemento del valore assoluto della differenza che è maggiore di 1012 ,
ritornare False;
in caso contrario ritornare True;
Esempio di output:
>>> verifica_somma_cumulativa(np.linspace(-10.*np.pi, 33*np.e, 200))
True
61
somma_100_numpy.py:
import numpy as np
arr = np.arange(1,101)
print np.sum(arr)
tabellina_numpy.py:
import numpy as np
n = np.arange(1,11)
print i*n
thabit_np.py:
import numpy as np
def thabit_np(maxn):
n = np.arange(int(maxn)+1)
return 3*2**n-1
montante_numpy.py:
import numpy as np
upi = 1.04 # (1+i)

anni = 10
n = np.arange(1,anni+1)
M = 1000.*(upi*np.ones(10))**n
for i in range(anni):
print n[i], M[i]
numpy_sin_cos.py:
import numpy as np
theta = np.linspace(0, 2.*np.pi, 9)

print np.sin(theta)
print np.cos(theta)
1. plotsin_numpy.py:
import numpy as np
def plotsin_numpy(xmin = -np.pi, xmax = np.pi, npts = 201):

x = np.linspace(xmin, xmax, npts)
62
y = np.sin(x)
plt.plot(x,y)
plt.plot(x,y)
plt.show()
2. plotcos_numpy.py:
import numpy as np
def plotcos_numpy(xmin = -np.pi, xmax = np.pi, npts = 201):

y = np.cos(x)
plt.plot(x,y)
plt.plot(x,y)
plt.show()
3. plotlog_numpy.py:
import numpy as np
def plotlog_numpy(xmin = 1., xmax = 100, npts = 201):

y = np.log(x)
plt.plot(x,y)
plt.show()
4. plotexp_numpy.py:
import numpy as np
def plotexp_numpy(xmin = 0., xmax = 5, npts = 201):

y = np.exp(x)
plt.plot(x,y)
plt.show()
c2f_graph_numpy.py:
import numpy as np
def c2f_graph_numpy(Tmin=-10, Tmax=120, N=130):

C = np.linspace(Tmin, Tmax, N)
F = 9./5.*C+32
plt.plot(C, F)
plt.show()
return
63
plot_poly.py:
import numpy as np
from horner import *
def plot_poly():
x = np.linspace(-10.,30.,201)
c = np.array([1., -30., 0., 2552.])
y = horner(x, c)
plt.plot(x, y)
plt.show()
return
plot_fabs_sin_np.py:
import numpy as np
x=np.linspace(-2*np.pi,2*np.pi,201)
y=np.fabs(np.sin(x))
plt.plot(x,y)
plt.xlim(-2*np.pi,2*np.pi)
plt.ylim([-1,2])
plt.show()
crivello_eratostene_numpy.py:
import numpy as np
def crivello_eratostene_numpy(maxn):
numbers = np.arange(maxn+1)
limit = int(np.sqrt(maxn))
for n in range(2, limit+1):
if numbers[n] != -1:
idx = np.arange(n*n, maxn+1, n)
numbers[idx] = -1
qp = (np.where(numbers[2:] != -1))[0]
return numbers[2+qp]
somma_cumulativa.py:
import numpy as np
def somma_cumulativa(arr):
npts = len(arr)
sc = np.zeros(npts)
sc[0] = arr[0]
for i in range(1,npts):
sc[i] = sc[i-1]+arr[i]
return sc
64
verifica_somma_cumulativa.py:
import numpy as np
from somma_cumulativa import *
def verifica_somma_cumulativa(arr):
a1 = somma_cumulativa(arr)
a2 = np.cumsum(arr)
ad = np.fabs(a1 - a2)
q = np.where(ad > 1e-12)
nq = len(q[0])
if nq != 0:
return False
return True
65
Capitolo 11
Simulazioni e Metodi Monte-Carlo
Esercizio 88 Gioco delloca semplificato: Scrivere una funzione Python che simuli
un gioco delloca semplificato. Vi sono quattro giocatori, identificati con i numeri da 1 a 4 (ma
internamente identificati con gli indici di un array da 0 a 3). Ad ogni turno ciascun giocatore
tira un dado, il risultato si somma ai precedenti e rappresenta il numero della casella in cui si
troverà il giocatore. Vince il giocatore che arriva nella casella 63 o la supera. Se in un turno
più giocatori arrivano o superano la casella 63, vince il giocatore con il punteggio maggiore. In
caso di pareggio vince il giocatore con il numero pi` u basso (circa equivalente al giocatore che
tira i dati per primo).
Procedimento:
Creare un array numpy di quattro elementi che rappresenti il punteggio, inizialmente

posto tutto a zero;
Iterare fino alla vittoria di uno dei giocatori:
simulare il lancio del dado da parte di ciascun giocatore generando un array con
quattro numeri interi casuali uniformemente distribuiti tra 1 e 6;
aggiungere il risultato al punteggio totale di ciascun giocatore;
stampare a schermo il punteggio per ciascun giocatore;
se almeno un punteggio è maggiore o uguale a 63 (in caso affermativo cè almeno un
vincitore):
* cercare il valore massimo del punteggio;
* trovare gli indici dei valori nellarray del punteggio che sono uguali a tale massimo
(ce ne possono essere pi` u duno);
* prendere il primo elemento dellarray degli indici, aggiungervi uno e si ottiene il
numero del giocatore che ha vinto;
* terminare le iterazioni;
scrivere a schermo i punteggi finali;
scrivere a schermo il numero del giocatore vincente.
Esercizio 89 Area di Macchia Nera: Scaricare larchivio zip macchianera.zip

ed estrarre il file macchianera.npy nella directory da dove è stato fatto partire IDLE.
Il file contiene un array numpy bidimensionale che rappresenta la seguente immagine:
66
Scrivere una funzione che calcoli larea della parte in nero nella figura tramite metodo hit-or-
miss.
Procedimento:
scrivere una funzione che accetti due parametri di input, img_name nome del file da cui
leggere i dati e npts numero di punti casuali da generare;
caricare limmagine contenuta nel file in un array numpy bidimensionale tramite listru-
zione ima = np.load("macchianera.npy")
assegnare a due variabili nr e nc il numero di righe e di colonned dellimmagine (come

dedotti da ima.shape)
generare gli indici di npts punti casuali uniformemente distribuiti allinterno dellimma-
gine:
un array r contenente numeri interi pseudo-casuali uniformemente distribuiti tra zero

e nr-1
un array c contenente numeri interi pseudo-casuali uniformemente distribuiti tra zero
e nc-1
tramite funzione where() trovare i punti in cui ima[r,c] > 0 (hit, ovvero il punto
cade nellarea nera);
assegnare a una variabile n_in il numero di tali punti;
ritornare la stima dellarea data da n_in/npts*nr*nc
Esercizio 90 Rappresentazione stocastica di e: Si può dimostrare che se:
V = min{n | X1 + X2 + . . . + Xn > 1}
ovvero se V è il numero n minimo tale che la somma di n variabili casuali indipendenti Xi

uniformemente distribuite in [0, 1] sia maggiore di 1, allora il valore atteso di V è il numero e,
ovvero la base del logaritmo naturale (Gnedenko (1978)).
Scrivere una funzione Python implementi un metodo stocastico per calcolare e.
Procedimento:
definire una funzione che accetta un solo parametero n, numero di stime da generare;
inizializzare una lista ln vuota;
iterare n volte:
67
inizializzare a zero due variabili: j, intera, che conterr`
a il numero di dati casuali generati
e r che conterr` a la somma di tali numeri;
iterare fintanto che r < 1.0:
incrementare j di uno;
aggiungere a r un nuovo numero casuale uniformemente distribuito tra zero e uno;
aggiungere j alla fine della lista ln
ritornare la media dei valori memorizzati nella lista ln (usare la funzione sum() per
sommare tutti i valori e poi dividere per la lunghezza della lista).
>>> natural_e_sim(1000)
2.702
2.7215
2.71853
68
simple_goose.py:
import numpy as np
import numpy.random as npr
def simul_oca():
num_players = 4
finished = False
score = np.zeros(num_players)
while not finished:
dice = npr.random_integers(1, 6, num_players)
score += dice
print "Punteggio:", score
wins = np.where(score >= 63)
n_wins = len(score[wins])
if n_wins > 0:
max_score = np.max(score)
winner_idx = (np.where(score == max_score))[0]
winner = winner_idx[0]+1
finished = True
print "Punteggio finale: ", score
print "Vince il giocatore:", winner
area_macchianera.py:
import numpy as np
import numpy.random as npr
def area_macchianera(img_name, npts):

ima = np.load(img_name)
nr, nc = ima.shape
r = npr.random_integers(0, nr-1, npts)
c = npr.random_integers(0, nc-1, npts)
q = (np.where(ima[r,c] > 0))[0]
n = len(q)
area = float(n)/npts*nr*nc
return area
natural_e_sim.py:
from random import random
def natural_e_sim(n):
ln = []
for i in range(n):
j = 0
r = 0.0
while r < 1.0:
j += 1
r += random()
ln.append(j)
return float(sum(ln))/len(ln)
69
Bibliografia
B. V. Gnedenko. The Theory of Probability. MIR Publishers, Moscow, 1978.
Jean Meeus. Astronomical Algorithms. Willman-Bell, Richmond, Virginia, 1991.
David Wells. The Penguin Dictionary of Curious and Interesting Numbers. Penguin Group,
London UK, 1st edition, 1986.
70
Questo lavoro è distribuito con licenza Creative Commons Attribuzione - Non commerciale -
Condividi allo stesso modo 4.0 Internazionale
(CC BY-NC-SA 4.0).
Per leggere la licenza, visitare http://creativecommons.org/licenses/by-nc-sa/4.0/ o mandare
una lettera a Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
71

Esercizi Python

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Esercizi Python

Caricato da

Copyright:

Formati disponibili

Esercizi di Python

2 Uso diretto dellinterprete Python 5

11 Simulazioni e Metodi Monte-Carlo 66

come scrivere ed eseguire brevi programmi nella finestra di editor di IDLE;

come importare moduli ed utilizzare le relative funzioni (limitatamente a quelle usa-

Alcuni costrutti utilizzati di frequente in questi esercizi sono:

Uso diretto dellinterprete Python

i decimali sono preceduti dal punto ., e non dalla virgola.

Esercizio 1 Aree e volumi: Approssimando = 3.14159265 calcolare:

Esercizio 3 Conversione da pollici a centimetri: Sapendo che un pollice equivale

Esercizio 4 Conversione da centimetri a pollici: Sapendo che un pollice equivale

Esercizio 5 Approssimare : Sapendo che = 3.14159265358 . . . verificare le

Calcolare la pressione a 1000, 2000 e 4000 metri

>>> in2cm = 2.54 # inches to centimeters

>>> in2cm = 2.54 # inches to centimeters

Esercizio 7 Generare liste: Usando la funzione range()generare una lista conte-

Esercizio 10 Conteggio di cifre: Scrivere un programma che definisca la seguente

convertire la stringa in una lista usando la funzione list();

definire una variabile alphabet che contenga la stringa abcdefghilmnopqrstuvxz;

inizializzare una lista n_letter vuota che conterr`

usando il metodo count() contare quante volte l appare in Lorem ipsum;

in un secondo ciclo, separato, su tutte le lettere in alphabet, stampare a schermo la

Output atteso (abbreviato):

6. a[::-1] o a[-1::-1] o a[29::-1] NOTA: la slice [::-1] `e da preferire perch`e fun-

Esercizio 12 Somma di numeri naturali con for: Scrivere un programma Python

Esercizio 13 Somma di numeri naturali con while: Scrivere un programma

Esercizio 14 Iterare su slice:

Esercizio 15 Le tabelline fino al 10: Calcolare e stampare a schermo le tabelline

Esercizio 16 Successione di Fibonacci: Sapendo che la successione di Fibonacci `e

Esercizio 17 Successione di Tribonacci: Sapendo che la successione di Tribonacci

Esercizio 18 Calcolo del montante: Sapendo che il montante M di un capitale C

definire una variabile intera niter = 5, numero di iterazioni da effettuare;

iterare per niter volte e ad ogni passo calcolare e stampare lapprossimazione di :

Esercizio 20 Triangolo di numeri: Scrivere una funzione che accetti un parametro

Esercizio 21 Triangolo inverso di numeri: Scrivere una funzione che accetti

Esercizio 22 Triangolo di Floyd: Scrivere una funzione che stampi il Triangolo di

Esercizio 23 Diagonale di *: Scrivere un programma che richieda allutente un

Esercizio 24 Diagonale inversa di *: Scrivere un programma che richieda allu-

Esercizio 25 Quadrato di *: Scrivere un programma che richieda allutente un

Esercizio 26 Rettangolo di *: Scrivere un programma che richieda allutente due

Esercizio 27 Triangolo rettangolo sinistro di *: Scrivere un programma

Esercizio 28 Triangolo rettangolo sinistro e inverso di *: Scrivere un

Esercizio 30 Triangolo rettangolo destro e inverso di *: Scrivere un

Esercizio 31 Piramide di * in piedi : Scrivere un programma che richieda

Hint: Riutilizzare quanto fatto per gli esercizi 27 e 28.

Esercizio 32 Triangolo isoscele di *: Scrivere un programma che richieda allu-

Esercizio 33 Triangolo isoscele capovolto di *: Scrivere un programma che

Esercizio 34 Rombo di *: Scrivere un programma che richieda allutente un

Hint: Riutilizzare quanto fatto per gli esercizi 32 e 33.

Esercizio 35 Freddo o caldo: Scrivere un programma che chieda in input allutente

minore di 15, in caso affermativo scrivere a schermo"freddo polare!";

maggiore o uguale a 15 e minore di 0, in caso affermativo scrivere "molto freddo";

maggiore o uguale a 0 e minore di 18, in caso affermativo scrivere "freddo";

maggiore o uguale a 18 e minore di 26, in caso affermativo scrivere "tiepido";

maggiore o uguale a 26 e minore di 32, in caso affermativo scrivere "caldo";

maggiore di 32, in caso affermativo scrivere "torrido!";

Esercizio 36 Numeri interi: Scrivere un programma che chieda in input allutente

divisibile per tre, in caso affermativo scrivere "divisibile per tre";

divisibile per cinque, in caso affermativo scrivere "divisibile per cinque";

Esercizio 37 Verifica angolo: Scrivere un programma che chieda in input allutente

uguale a zero, in caso affermativo scrivere "Angolo nullo."

maggiore di zero e minore di 90, in caso affermativo scrivere "Primo quadrante."

maggiore di 90 e minore di 180, in caso affermativo scrivere "Secondo quadrante."