In questa lezione realizzemo un gioco con gli indovinelli con Scratch. Proporremo 4 semplici indovinelli: 1) Giro curioso nel bosco fitto e frondoso. Mi arrotolo in palla, sono piccolo e gioioso. 2) Mi nutro di insetti nell’oscurità, Un piccolo mammifero nella mia verità. 3) Nella notte mi senti cantare, Con occhi grandi posso guardare. 4) Faccio il sonnellino durante la lunga stagione. Amo miele e pesce, sono un buon pescatore!
Per individuare la risposta corretta, occorre trascinare ciascun animale sulla macchina. Se la macchina parte con l’animale vuol dire che la risposta è corretta, altrimenti la macchina cambia colore e l’animale ritorna in posizione.
Ecco una possibile implementazione del gioco indovinelli con Scratch:
In questa lezione, propongo altri esercizi sul ciclo for in Python.
Primo esercizio ciclo for in Python
Progettate un algoritmo che scriva tutte le coppie di numeri che danno per prodotto 60.
La soluzione consiste nell’utilizzare un ciclo for per trovare i divisori di 60, quindi per ogni divisore troviamo anche il quoziente.
Ricordiamo infatti come si chiamano i termini della divisone facendo un esempio:
60 : 3 = 20
Quindi 60 si chiama dividendo, 3 si chiama divisore e 20 si chiama quoziente. Questo vuol dire che se moltiplico il quoziente ottenuto per il divisore ottengo il dividendo. Infatti in questo caso specifico si ha: 20 *3=60.
Dopo impostiamo il range con l’indice i deve partire da 1 in quanto altrimenti si avrebbe una divisione per zero e ciò non è possibile e si ferma ad n+1 perché dobbiamo dividere per 60 se vogliamo trovare tutte le coppie.
Poi, facendo questa operazione n % i == 0 si controlla se il resto della divisone è zero. Se è vero significa che i è il divisore, dunque troviamo il quoziente.
Infine stampiamo le coppie.
Algoritmo ciclo for in Python per trovare le coppie che danno come prodotto 60
Ecco dunque l’algoritmo che utilizza il ciclo for in Python per trovare le coppie che danno come prodotto 60:
n = 60
for i in range(1, n+1):
if n % i == 0:
q = n // i
print('Coppia ', i, ' e ', q)
Svolgiamo alcuni passi dell’algoritmo per spiegarlo meglio.
n = 60
Primo passo:
for i in range(1, n+1): # i = 1
if n % i == 0: #60 % 1 == 0 è vera
q = n // i #troviamo il quoziente cioè q = 60 // 1 = 60 print(‘Coppia ‘, i,’ e ‘, q) #Stampiamo la prima coppia cioè i = 1 e q = 60
Secondo passo:
for i in range(1, n+1): # i = 2
if n % i == 0: #60 % 2 == 0 è vera
q = n // i #troviamo il quoziente cioè q = 60 // 2 = 30 print(‘Coppia ‘, i,’ e ‘, q) #Stampiamo la prima coppia cioè i = 2 e q = 30
Terzo passo:
for i in range(1, n+1): # i = 3
if n % i == 0: # 60 % 3 == 0 è vera
q = n // i #troviamo il quoziente cioè q = 60 // 3 = 20 print(‘Coppia ‘, i,’ e ‘, q) #Stampiamo la prima coppia cioè i = 3 e q =20
e così via fino all’ultimo passaggio dove divideremo il numero per se stesso.
Secondo esercizio ciclo for in Python
Stampa i primi N numeri dispari successivi al numero A.
Prendiamo in input il numero da cui partire, cioè A e la quantità di numeri dispari da visualizzare successivi ad A.
ES: Inseriamo N = 5 ed A = 6.
Quindi i 5 successivi numeri dispari di A che dobbiamo visualizzare sono: 7, 9, 11, 13, 15.
Allora l’indice i del for deve partire da 7 e terminare a 15. Da 7 a 15 ci sono 2* N -1 (9) numeri di cui 5 sono dispari e 4 pari.
Altro esempio: Inseriamo N = 3 ed A = 7.
Quindi i 3 successivi numeri dispari di A che dobbiamo visualizzare sono: 9, 11, 13.
Allora l’indice i del for deve partire da 9 e terminare a 13. Da 9 a 13 ci sono 2* N -1 (5) numeri di cui 3 sono dispari e 2 pari.
Migliora le tue capacità di programmazione Python seguendo i nostri corsi in diretta!
Osservando gli esempi sopra, onde evitare di creare due cicli for, eseguiamo un if e se A è pari lo facciamo diventare dispari, se A è dispari lo incrementiamo di 2.
Poi realizziamo un ciclo for che inizializza l’indice i ad A, in quanto rappresenta il numero di partenza ed incrementa il valore di A di 2 fino ad arrivare alla somma di A più il doppio dei numeri richiesti .
Dunque basta stampare semplicemente l’indice per ottenere quello che l’algoritmo richiede.
Ecco il codice completo che utilizza il ciclo for in Python:
N = int(input('Quanti numeri visualizzare? '))
A = int(input('Inserisci il valore da cui partire: '))
if A % 2 == 0:
A += 1
else:
A += 2
for i in range(A, A + N * 2, 2):
print(i)
Conclusioni
In questo articolo sono stati presentati due esercizi che utilizzano il ciclo for in Python per risolvere problemi specifici.
Il primo esercizio riguarda la ricerca delle coppie di numeri che danno come prodotto 60. Abbiamo illustrato un algoritmo che utilizza un ciclo for per trovare i divisori di 60 e quindi determinare le coppie corrispondenti. Abbiamo anche fornito un’analisi passo dopo passo dell’algoritmo per chiarire il suo funzionamento.
Il secondo esercizio consiste nella stampa dei primi N numeri dispari successivi a un numero dato A. Abbiamo fornito un algoritmo che, mediante un controllo condizionale, assicura che il numero di partenza A sia dispari. Successivamente, utilizzando un ciclo for, vengono stampati i numeri dispari successivi ad A, con un calcolo accurato dell’intervallo da considerare.
Entrambi gli esercizi mostrano come il ciclo for può essere utilizzato in combinazione con altre strutture e operazioni per risolvere problemi specifici. Questi esempi forniscono una buona base per comprendere e utilizzare il ciclo for in Python in contesti pratici.
Realizziamo in questa lezione una piramide di asterischi in Python, come quella mostrata nella figura sotto, avente come altezza 6 asterischi.
*
***
*****
*******
*********
***********
Per realizzare il nostro programma, prendiamo innanzitutto in input l’altezza della piramide.
La piramide dell’esempio ha altezza 6 e base 11, immaginiamo dunque che l’utente inserisca 6 alla domanda ‘qual è l’altezza della piramide che vuoi creare?’
Adesso, per risolvere il problema, facciamo le nostre considerazioni.
Innanzitutto notiamo che la prima riga ha un solo asterisco, mentre le altre si incrementano di due asterischi rispetto alla riga precedente.
Gli spazi non sono altro che caratteri vuoti e quelli che ci interessano sono solo quelli prima degli asterischi.
Migliora le tue capacità di programmazione Python seguendo i nostri corsi in diretta!
Dunque nella prima riga i primi 5 caratteri sono vuoti, mentre il successivo avrà l’asterisco.
Nella seconda riga invece saranno vuoti i primi 4 caratteri mentre i 3 caratteri successivi avranno l’asterisco. E così via.
In generale vale allora questa regola:
Per il carattere vuoto: (h – i – 1) infatti nel primo caso saranno 6 – 0 – 1 = 5 caratteri vuoti, mentre nel secondo caso 6 – 1 – 1 = 4 caratteri vuoti e così via.
Per gli asterischi: (2 * i + 1) infatti nel primo caso si avrà 2 * 0 + 1 = 1 asterisco, mentre nel secondo caso 2 * 1 + 1 = 3 asterischi e così via.
Ecco allora il nostro algoritmo per costruire una piramide di asterischi in python con un solo ciclo for:
h = int(input(‘Inserisci l\’altezza della piramide: ‘))
for i in range(h):
print(‘ ‘ *(h-i-1) + ‘*’ *(2*i+1))
Oltre a questa soluzione, ne presento un’altra che fa uso di due cicli for annidati:
for i in range(h):
for j in range(h + i):
if (h – j – 1 > i):
print(‘ ‘, end=”)
else:
print(‘*’, end=”)
print()
In questa lezione abbiamo creato una piramide di asterischi in Python utilizzando uno o due cicli for, nelle prossime lezioni faremo ancora degli esempi sui cicli annidati.
Ecco dunque il codice completo del rettangolo di asterischi:
b = int(input('Base: '))
h = int(input('Altezza: '))
for i in range(h):
for j in range(b):
print('*', end=' ')
print()
Oppure posso utilizzare anche un solo ciclo for, sempre dopo aver preso in input base e altezza:
for i in range(h):
print(‘* ‘*b)
Cioè moltiplico il carattere asterisco (*) per la base!
Rettangolo di asterischi – cornice
Proviamo adesso a rappresentare un rettangolo di asterischi solo con la cornice esterna.
Anche qui chiediamo di inserire la base e l’altezza all’utente.
Quindi consideriamo che solo la prima e l’ultima riga avranno tutti gli asterischi, cioè se i == 0 oppure i == h – 1.
Per quanto riguarda le altre righe avranno solo l’asterisco nella prima e nell’ultima colonna, cioè se j == 0 oppure j == b – 1.
Ecco dunque il codice completo del rettangolo di asterischi realizzato con la sola cornice esterna:
b = int(input('Base: '))
h = int(input('Altezza: '))
for i in range(h):
for j in range(b):
if i == 0 or i == h - 1:
print('* ', end='')
elif j == 0 or j == b - 1:
print('* ', end='')
else:
print(' ', end='') # due spazi vuoti all'interno degli apici
print()
Allo stesso modo:
b = int(input('Base: '))
h = int(input('Altezza: '))
for i in range(h):
for j in range(b):
if i == 0 or i == h - 1 or j == 0 or j == b - 1:
print('* ', end=' ')
else:
print(' ', end=' ') # due spazi vuoti all'interno degli apici
print()
Quadrato e diagonali
Realizziamo adesso un programma che generi un quadrato di asterischi con le sue diagonali.
Innanzitutto prendiamo in input il lato del quadrato.
Dopo, come nell’esercizio precedente pensiamo di realizzare la cornice inserendo due cicli for annidati.
Calcoliamo adesso le due diagonali.
Partiamo prima dalla diagonale principale.
Per capire come ricavarla facciamo un esempio.
Consideriamo ad esempio un quadrato di lato 6. Allora la diagonale principale sarà data dagli elementi (0,0), (1,1), (2, 2), (3,3), (4,4), (5,5).
Quindi la diagonale principale sarà caratterizzata dal fatto che i e j sono uguali.
Adesso calcoliamo la diagonale secondaria.
La diagonale secondaria è data dagli elementi: (0, 5), (1, 4), (2,3), (3, 2), (4, 1), (5,0).
Migliora le tue capacità di programmazione Python seguendo i nostri corsi in diretta!
Facciamo attenzione all’elemento j, noteremo che osserva questa regola:
j = n – i – 1
Infatti, nel primo caso i = 0 e j = 6 – 0 – 1 = 5 quindi (0,5)
Secondo caso i = 1 e j = 6 – 1 – 1 = 4 quindi (1,4)
Terzo caso i = 2 e j = 6 – 1 – 2 = 3 quindi (2,3)
Quarto caso i = 3 e j = 6 – 1 – 3 = 2 quindi (3,2)
Quinto caso i = 4 e j = 6 – 1 – 4 = 1 quindi (4,1)
Infine nel sesto caso i = 5 e j = 6 – 1 – 5 = 0 quindi (5,0)
Approfondiremo questo discorso delle diagonali quando parleremo delle matrici.
A questo punto diventa semplice costruire il nostro algoritmo utilizzando due cicli for annidati.
Ecco dunque il codice completo:
lato = int(input('Lato: '))
for i in range(lato):
for j in range(lato):
if i == 0 or i == lato - 1:
print('* ', end='')
elif j == 0 or j == lato - 1:
print('* ', end='')
elif j == i or j == lato - 1 - i: # elementi diagonali
print('* ', end='')
else:
print(' ', end='')
print()
Possiamo anche scrivere:
lato = int(input('Lato: '))
for i in range(lato):
for j in range(lato):
if i == 0 or i == lato - 1 or j == 0 or j == lato - 1 or j == i or j == lato - 1 - i:
print('*', end='')
else:
print(' ', end='')
print()
In questa lezione abbiamo disegnato un rettangolo di asterischi e un quadrato con la sua diagonale, questi sono solo alcuni esempi d’uso dei cicli for in Python, presto ne farò degli altri.
Proviamo a scrivere il codice nell’editor sotto:
Conclusioni
In questa lezione abbiamo esplorato diversi esempi di utilizzo del ciclo for in Python per creare figure geometriche utilizzando asterischi. Abbiamo iniziato con la creazione di un rettangolo di asterischi, prendendo in input la base e l’altezza, e abbiamo visto due approcci per realizzarlo: uno utilizzando due cicli for annidati e uno utilizzando un singolo ciclo for. Successivamente, abbiamo modificato il codice per creare un rettangolo di asterischi con una cornice esterna. Infine, abbiamo implementato un algoritmo per creare un quadrato con le sue diagonali, illustrando il calcolo delle diagonali principali e secondarie.
Questi esempi dimostrano l’ampiezza delle applicazioni del ciclo for in Python e la sua versatilità nel risolvere una vasta gamma di problemi. L’utilizzo di cicli for annidati ci consente di esplorare modelli più complessi e di manipolare i dati in modi creativi. Continuando a praticare e sperimentare con il ciclo for, saremo in grado di acquisire una maggiore padronanza della programmazione Python e affrontare sfide più avanzate.
Ricordiamoci sempre di mantenere il codice pulito e leggibile, utilizzando la formattazione adeguata e i commenti appropriati per facilitare la comprensione del nostro lavoro da parte di noi stessi e degli altri programmatori.
Continuate a sperimentare e se volete una guida pratica e innovativa leggete il libro “50 algoritmi per imparare Python”, disponibile su Amazon.
Utilizziamo la keyword end all’interno del print per inserire gli asterischi sulla stessa riga e dunque evitare di andare a capo.
Mentre l’ultimo print() serve semplicemente per andare a capo, dopo aver stampato ciascuna riga.
Spieghiamo dunque passo passo cosa succede:
Prima iterazione del ciclo esterno: i=0
Prima iterazione del ciclo interno: j=0 stampa l’asterisco seguito dallo spazio vuoto.
Seconda iterazione del ciclo interno: j=1 stampa un altro asterisco seguito dallo spazio vuoto.
Terza iterazione del ciclo interno: j=2 stampa un asterisco seguito dallo spazio vuoto.
Quarta iterazione del ciclo interno: j=3 stampa un asterisco seguito dallo spazio vuoto.
Seconda iterazione del ciclo esterno: i=1
Si procede analogamente a quanto detto prima.
Per provare quanto spiegato provate a sostituire gli asterischi ai valori di i e j, inserendo al posto di print(‘*’, end=’ ‘) il codice indicato sotto:
print(‘i:’,i,‘j:’,j, end=‘ ‘)
Ma attenzione! Lo stesso rettangolo si poteva realizzare con un solo ciclo for, semplicemente moltiplicando il carattere asterisco (*) 4 volte per ogni riga.
for i inrange(3):
print(‘* ‘*4)
Migliora le tue capacità di programmazione Python seguendo i nostri corsi in diretta!
Secondo esempio sui cicli for
Variamo l’esercizio precedente producendo adesso un rettangolo con i numeri da 1 a 4.
Cioè l’output deve essere questo:
1 2 3 4
1 2 3 4
1 2 3 4
Dobbiamo cambiare solo il ciclo interno, impostando nel range i valori (1, 5).
Dopo, ad ogni iterazione del ciclo interno stampiamo l’indice j.
Ecco dunque il codice:
for i in range(3):
for j in range(1, 5):
print(j, end=‘ ‘)
print()
Terzo esempio
Adesso stampiamo i numeri in ordine decrescente, dunque variamo l’esempio precedente in modo da avere il seguente output:
4 3 2 1
4 3 2 1
4 3 2 1
Per stampare i numeri in ordine decrescente possiamo cambiare il range in modo tale che j varia da 4 a 1 con step di -1.
Ecco dunque il codice completo:
for i in range(3):
for j in range(4, 0, -1):
print(j, end=‘ ‘)
print()
Quarto esempio cicli for
Vogliamo adesso realizzare un altro esempio utilizzando due cicli for annidati, come l’esempio sotto:
1234567
123456
12345
1234
123
12
1
Basta stampare j e di volta in volta diminuire di 1 il numero di righe:
n = 7
for i in range(n):
for j in range(1, n+1-i):
print(j, end='')
print()
Migliora le tue capacità di programmazione Python seguendo i nostri corsi in diretta!
Quinto esempio
Realizziamo un altro esempio:
7654321
654321
54321
4321
321
21
1
n = 7
for i in range(n):
for j in range(n-i, 0, -1):
print(j, end='')
print()
Sesto esempio
Realizziamo adesso un esempio come questo:
1
21
321
4321
54321
654321
7654321
n = 7
for i in range(1, n+1):
for j in range(i, 0, -1):
print(j, end='')
print()
Settimo esempio
Realizziamo una figura come questa:
*
**
***
****
*****
****
***
**
*
Prima soluzione:
n = 5
for i in range(1, n * 2):
if i <= n:
for j in range(i, 0, -1):
print('*', end='')
print()
else:
for j in range(1, n * 2 + 1 - i):
print('*', end='')
print()
Il ciclo esterno stamperà le nove righe. Infatti i varia da 1 a 9.
All’interno del ciclo se i <= 5 realizziamo un altro ciclo for che stamperà la prima volta 1 asterisco, poi 2, ecc…fino ad arrivare a 5.
Infatti alla prima iterazione i vale 1, alla successiva 2 e così via fino a i=5.
for j in range(i, 0, -1):
print(‘*’, end=”)
Quando i sarà uguale a 5 si farà quanto scritto nell’else e quindi l’altro ciclo for che stamperà n*2-i asterischi. La prima volta n*2-i=10-6 cioè 4 asterischi, la seconda n*2-i=10-7 cioè 3 e così via.
Seconda soluzione semplificata con due cicli for:
n = 5
for i in range(1, n*2):
for j in range(1, n+1):
if i <= n and j <= i:
print('*', end='')
elif i > n and j < n * 2 + 1 - i:
print('*', end='')
else:
print(' ', end='')
print()
Terza soluzione con gli operatori logici
n = 5
for i in range(1, n*2):
for j in range(1, n+1):
if i <= n and j <= i or i > n and j < n*2 + 1 - i:
print('*', end='')
else:
print(' ', end='')
print()
Commenti recenti