opzionale<\/em> e per default \u00e8 1<\/li>\n<\/ul>\nIndipendentemente dall'intervallo che rappresenta, la funzione range() memorizza solo i valori di inizio, fine ed incremento, per cui consuma molto meno memoria di quella che occuperebbe una lista.<\/pre>\nEsempi<\/strong>o<\/strong><\/p>\na= range(3,6)
for x in a:
print(x, end=’\\t’)<\/p>\n
Risultato
3 4 5<\/strong><\/p>\nEsempi<\/strong>o<\/strong><\/p>\na= range(6)
for x in a:
print(x, end='\\t')<\/pre>\nRisultato
0 1 2 3 4 5<\/strong><\/p>\nEsempi<\/strong>o<\/strong><\/p>\na= range(3,9,2)
for x in a:
print(x, end='\\t')<\/pre>\nRisultato
3 5 7 <\/strong><\/p>\n <\/p>\n
\ufffd Esercizio
Scrivere un programma che determini i divisori di un numero naturale digitato dall’utente.<\/em><\/strong><\/p>\nUna possibile soluzione<\/strong><\/p>\nn = int(input(\"Digita il numero naturale del quale determinare i divisori: \"))
print(f\"I divisori di {n} sono:\")
for i in range(1, n+1): #range(1,n+1) crea una sequenza di numeri da 1a n+1 escluso
if n % i == 0:
print(i, end=' ')<\/pre>\n\ufffd Esercizio
<\/strong>Visualizzare la tabellina di un numero naturale da 1 a 10 digitato dall’utente<\/em><\/p>\nUna possibile soluzione<\/strong><\/p>\nn = int(input(\"Digita un numero intero <\/strong>da 1 a 10<\/strong> del quale visualizzare la tabellina: \"))
for i in range(1,11):
print(n * i, end=\" <\/strong> \")<\/strong><\/pre>\n\ufffd Esercizio
<\/strong>Verificare se il numero naturale digitato dall’utente \u00e8 un numero primo.<\/em><\/p>\nUna possibile soluzione<\/strong><\/p>\nn = int(input(\"Digita il numero naturale del quale verificare <\/strong> se \u00e8 un numero primo: \"))
primo = True
for i in range(2, <\/strong>n<\/strong>, 1):
if n%i == 0:
primo = False
if primo:
print(f\"Il numero {n} \u00e8 primo!\")
else:
print(f\"Il numero {n} non \u00e8 primo!\")<\/strong><\/pre>\n <\/p>\n
Il 2 non viene preso in considerazione dal ciclo, per cui non altera il contenuto della variabile primo che permane col valore <\/strong>True.
Tale soluzione \u00e8 volutamente elementare, vedremo nella fase dedicata a<\/strong><\/strong>lla<\/strong><\/strong> Matematica come ottimizzarla.<\/strong><\/strong><\/p>\nTuple<\/h2>\n
La tuple<\/strong><\/em> \u00e8 un insieme ordinato di pi\u00f9 elementi<\/strong><\/em> in un’unica variabile, e fin qui la definizione coincide con quella della lista, ma allora per cosa sono simili e per cosa differiscono?<\/p>\nLe differenze<\/h3>\n\n- Innanzitutto denotiamo la differenza nella loro creazione:
a=[a,b,c,d,e] \u00e8 una lista
b=(a,b,c,d,e) \u00e8 una tupla
Una tupla \u00e8 definita con gli elementi posti fra una parentesi tonda di apertura ed una di chiusura o semplicemente, senza parentesi, scrivendo i suoi elementi separati da virgole (sconsigliato).1<\/sup><\/li>\n<\/ul>\n\n- La differenza fondamentale tra le tuple e le liste \u00e8 che mentre le prime non possono essere modificate, le seconde s\u00ec: cio\u00e8 le tuple sono oggetti immutabili<\/strong>.<\/strong><\/li>\n
- Fra una tupl<\/strong>a<\/strong> ed una lista contenenti gli stessi elementi, la<\/strong> tupla \u00e8 pi\u00f9 efficient<\/strong><\/strong>e<\/strong><\/strong> in termini di memoria<\/strong><\/strong>.
Poich\u00e9 le liste sono mutabili, Python deve riservare memoria aggiuntiva per consentire, dopo la sua creazione, una eventuale estensione della sua dimensione con l’aggiunta o modifica dei suoi elementi. Differentemente accade per le tuple che hanno dimensione fissa, poich\u00e9 immutabili, e per le quali Python riserva il minimo della memoria richiesta dai dati.<\/li>\n- Per lo stesso motivo anzidetto, le tuple hanno una migliore efficienza temporale, soprattutto nella fase di ricerca<\/li>\n<\/ul>\n
Le similitudini<\/h3>\n\n- Sia nelle tuple che nelle liste \u00e8 possibile archiviare qualsiasi tipo di dati.<\/li>\n
- Sia le tuple che le liste sono ordinate.<\/li>\n
- \u00c8 possibile scorrere gli elementi contenuti sia nelle tuple che nelle liste, poich\u00e9 sono entrambi tipi di dati sequenziali.<\/li>\n
- Si possono effettuare sulle tuple tutte quelle operazioni previste con le liste che non ne prevedano modifiche; in particolare si pu\u00f2 accedere sia agli elementi delle tuple che delle liste usando le parentesi quadre e un indice ([indice]<\/em>).<\/li>\n<\/ul>\n
P<\/strong>er motivi di <\/strong>efficienza<\/strong><\/strong>,<\/strong> s<\/strong><\/strong>e <\/strong>si hanno <\/strong>dati che non dovrebbero cambiare,<\/strong> \u00e8 opportuna la <\/strong>sce<\/strong>lta del<\/strong> tipo di dati tupla <\/strong>piuttosto che lista<\/strong>.<\/strong><\/p>\nOggetti e valori<\/h2>\n
Se vengono create due diverse<\/strong> variabili alle quali viene assegnato lo stesso valore di tipo lista<\/p>\n var1=['a','b','c','d','e']
var2=['a','b','c','d','e']<\/pre>\ne si ricavano i loro identificatori<\/p>\n
print(id(var1))
print(id(var2))<\/pre>\n140307786079040
140307782128512<\/strong><\/p>\nsi scopre che le liste hanno un comportamento diverso dai dati numerici e le stringhe, due liste diverse fanno SEMPRE riferimento ad oggetti diversi.<\/p>\n
Occorre per\u00f2 fare una precisazione; si analizzi il seguente programma:<\/p>\n
var1=['a','b','c','d','e']
var2=var1<\/pre>\ne si ricavano i loro identificatori<\/p>\n
print(id(var1))
print(id(var2))<\/pre>\n140091535792960
140091535792960<\/strong><\/p>\nvar1 e var2 si riferiscono allo stesso oggetto (si pu\u00f2 dire che sono due alias dello stesso oggetto). Se modifico var1 viene modificato il valore di var2, poich\u00e9 fanno riferimento allo stesso oggetto; dunque conviene evitare la creazione di un alias ed effettuare una copia che assume un id diverso.<\/p>\n
Le matrici (*)<\/h2>\n
La matrice \u00e8 una lista annidata i cui elementi sono le liste costituite dagli elementi di una riga. Chiariamo con un esempio. La matrice pu\u00f2 essere rappresentata dalla lista annidata di tre elementi<\/p>\n
M = [ [1, 2, 3, 4], [5, 6, 7, 8],[9, 10, 11, 12]]<\/pre>\nper cui M[0] seleziona la prima riga, M[1] la seconda, M[2] la terza. Per individuare un singolo elemento della matrice si deve usare un doppio indice: il primo per la riga ed il secondo per la colonna; ad esempio<\/p>\n
M [2] [2]<\/pre>\nindividua l’elemento all’incrocio fra la terza riga e la terza colonna, cio\u00e8 11.<\/p>\n
Va sottolineato che questo \u00e8 uno dei vari modi di rappresentare le matrici; un’alternativa, ad esempio, \u00e8 quella di rappresentare la matrice come una lista di colonne invece che di righe.<\/p>\n
Attivit\u00e0 ludica e di c<\/strong>onsolidamento con <\/strong>la<\/strong> turtle<\/strong><\/em> graphics<\/strong><\/em> 2<\/sup><\/h1>\nLe procedure grafiche ben si prestano al consolidamento dei costrutti fin qui appresi, poich\u00e8 ne consentono un riscontro visivo immediato ed inoltre aprono la strada alla progettazione delle funzioni.
Un aiuto viene dal modulo grafico turtle<\/strong> che consente la creazione di immagini grazie alla turtle graphics<\/strong><\/em>3<\/sup>, modulo gi\u00e0 integrato in quasi tutte le installazioni di Python.
Il modulo turtle crea una tartaruga, rappresentata simbolicamente nel nostro caso dalla punta di una freccia; durante il movimento, ottenuto con comandi esplicativi e molto semplici, trasporta una penna con la quale pu\u00f2 lasciare traccia del suo movimento. Al momento della sua creazione la tartaruga \u00e8 orientata a destra ed \u00e8 posta al centro dello schermo che viene individuato come un sistema di assi cartesiani ortogonali il cui punto di origine \u00e8 proprio il suo centro.<\/p>\nLa tartaruga nasce con coordinate (0,0) ed orientata a destra.<\/strong><\/p>\nPer iniziare a disegnare \u00e8 ovviamente necessario importare il modulo:<\/p>\n
import turtle<\/pre>\nche mette a disposizione moltissimi metodi4<\/sup>, i pi\u00f9 popolari dei quali vengono riportati nelle seguenti tabelle, raggruppati per omogeneit\u00e0.<\/p>\n\n\n\n| \n Movimento<\/strong><\/p>\n<\/td>\n| \n Descrizione<\/strong><\/p>\n<\/td>\n<\/tr>\n\n| \n forward(pixel<\/em>)<\/p>\nfd(pixel<\/em>)<\/p>\n<\/td>\n| \n Sposta la tartaruga in avanti, nell’orientamento contestuale, di una distanza pari al numero di pixel specificato come parametro.<\/p>\n<\/td>\n<\/tr>\n | \n| \n backward(pixel<\/em>)<\/p>\nbk(pixel<\/em>)<\/p>\n<\/td>\n| \n Sposta la tartaruga indietro, nel verso contestuale, di una distanza pari al numero di pixel fornito come parametro.<\/p>\n<\/td>\n<\/tr>\n | \n| \n left(angolo<\/em>)<\/p>\nlt(angolo<\/em>)<\/p>\n<\/td>\n| \n Ruota in senso antiorario dell’angolo sessagesimale specificato.<\/p>\n<\/td>\n<\/tr>\n | \n| \n right(angolo<\/em>)<\/p>\nrt(angolo<\/em>)<\/p>\n<\/td>\n| \n Ruota in senso orario dell’angolo sessagesimale indicato.<\/p>\n<\/td>\n<\/tr>\n | \n| \n goto(x,y<\/em>)<\/p>\n<\/td>\n| \n Sposta la tartaruga nel punto di coordinate (x,y); home (la tana) ha coordinate (0,0).<\/p>\n<\/td>\n<\/tr>\n | \n| \n home()<\/p>\n<\/td>\n | \n Sposta la tartaruga nel punto di coordinate (0,0) cio\u00e8 al centro dello schermo e la orienta a destra.<\/p>\n<\/td>\n<\/tr>\n | \n| \n reset()<\/p>\n<\/td>\n | \n Dopo aver pulito lo schermo, colloca la tartaruga nel punto di coordinate (0,0) cio\u00e8 al centro dello schermo e la orienta a destra.<\/p>\n Se si vuol pulire lo schermo, lasciando inalterata la posizione della tartaruga \u00e8 messo a disposizione il metodo clear()<\/strong>.<\/p>\n<\/td>\n<\/tr>\n\n| \n speed(velocit\u00e0<\/em>)<\/p>\n<\/td>\n| \n Imposta la velocit\u00e0 della tartaruga con un argomento intero compreso tra 0 e 10: da 1 a 10 con un’animazione sempre pi\u00f9 rapida sia nel disegno delle linee che nella rotazione della tartaruga, mentre con la velocit\u00e0<\/em> impostata su 0 tutto avviene con una velocit\u00e0 ancora pi\u00f9 alta delle precedenti.<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n <\/p>\n I primi quattro metodi impartiscono spostamenti relativi, i restanti imprimono spostamenti assoluti.<\/p>\n Va notato che un parametro negativo per forward produce un movimento indietro e non in avanti, cio\u00e8 opposto alla traduzione letterale del metodo; in maniera analoga si comportano backward, left e right.<\/p>\n Esempio<\/strong><\/p>\nDisegniamo un quadrato di lato 200 pixel.<\/p>\n ![\"Quadrato.png\"](\"\/images\/Quadrato.png\") <\/p>\n
\n- importare il modulo turtle: import turtle<\/li>\n
- mettere gi\u00f9 la penna in modo da lasciare traccia del movimento: turtle.pd()<\/li>\n
- muovere la penna in avanti di 200 px: turtle.fd(200)<\/li>\n
- ruotare la tartaruga di 90\u00b0 verso destra (angolo esterno!): turtle.rt(90)<\/li>\n
- ripetere l’azione del punto 3<\/li>\n
- ripetere l’azione del punto 4<\/li>\n
- ripetere l’azione del punto 3<\/li>\n
- ripetere l’azione del punto 4<\/li>\n
- ripetere l’azione del punto 3<\/li>\n
- ripetere l’azione del punto 4 (per portare la tartaruga all’orientamento iniziale)<\/li>\n<\/ol>\n
In definitiva il programma diventa:<\/p>\n import turtle
turtle.fd(200)
turtle.rt(90)
turtle.fd(200)
turtle.rt(90)
turtle.fd(200)
turtle.rt(90)
turtle.fd(200)
turtle.rt(90)<\/pre>\nturtle.mainloop()<\/pre>\nL’angolo di rotazione della tartaruga \u00e8 pari all’angolo esterno del lato; poich\u00e9, qualunque sia il numero dei suoi lati, la somma degli angoli esterni di un poligono \u00e8 di 360\u00b0, l’angolo di cui la tartaruga deve ruotare \u00e8 pari a (360\/4)\u00b0<\/p>\n Mandando in esecuzione il programma si apre la finestra:<\/p>\n ![\"Finestra.png\"](\"\/images\/Finestra.png\") <\/p>\n Con il metodo mainloop() il programma attender\u00e0 che la finestra grafica della tartaruga venga chiusa.<\/p>\n \n\n\n| \n Controllo della penna<\/strong><\/p>\n<\/td>\n| \n Descrizione<\/strong><\/p>\n<\/td>\n<\/tr>\n\n| \n penup()<\/p>\n pu()<\/p>\n up()<\/p>\n<\/td>\n | \n Solleva la penna; la tartaruga non lascia traccia durante il movimento.<\/p>\n<\/td>\n<\/tr>\n | \n| pendown() pd() down()<\/td>\n | \n Abbassa la penna; la tartaruga lascia traccia durante il movimento.<\/p>\n<\/td>\n<\/tr>\n | \n| \n pensize(larghezza<\/em>)<\/p>\nwidth(larghezza<\/em>)<\/p>\n<\/td>\n| \n Imposta la larghezza della punta della penna.<\/p>\n<\/td>\n<\/tr>\n | \n| \n pencolor(nomeColore<\/em>)<\/p>\n<\/td>\n| \n Imposta il colore della penna indicato come stringa: “red”, “green”, “yellow”, “blue”, “orange”, “gray”, “purple”, “black”, …<\/p>\n<\/td>\n<\/tr>\n | \n| \n pencolor(r, g, b<\/em>)<\/p>\n<\/td>\n| \n Imposta il colore della penna sul colore RGB specificando i valori del rosso, verde e blu, con valori fra 0 e 255.<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n <\/p>\n Esempio<\/strong><\/p>\nDisegniamo il triangolo avente i vertici nei punti di coordinate A(-50,-70), B(150,20) e C(200,200)![\"Triangolo.png\"](\"\/images\/Triangolo.png\") <\/p>\n import turtle <\/pre>\nturtle.width(4)
turtle.pencolor(\"blue\")
turtle.penup()
turtle.goto(-50,-70)
turtle.pendown()
turtle.goto(150,20)
turtle.goto(200,200)
turtle.goto(-50,-70) <\/pre>\nturtle.mainloop()<\/pre>\n <\/p>\n \n\n\n| \n Stato della tartaruga<\/strong><\/p>\n<\/td>\n| \n Descrizione<\/strong><\/p>\n<\/td>\n<\/tr>\n\n| hideturtle() ht()<\/td>\n | \n Nasconde la tartaruga. Pu\u00f2 <\/em>ess<\/em>ere utile per i disegni complessi, poich<\/em>\u00e9<\/em> velocizza notevolmente il disegno.<\/em><\/p>\n<\/td>\n<\/tr>\n\n| showturtle() st()<\/td>\n | \n Rende visibile la tartaruga.<\/p>\n<\/td>\n<\/tr>\n | \n| isdown()<\/td>\n | \n Ritorna
True se la penna \u00e8 abbassata,
False se la penna \u00e8 alzata.<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n <\/p>\n <\/p>\n \n\n\n| \n Altri metodi di nostro interesse<\/strong><\/p>\n<\/td>\n| \n Descrizione<\/strong><\/p>\n<\/td>\n<\/tr>\n\nbgcolor(“<\/em>colore<\/em>“<\/em>)<\/td>\n| \n Personalizza il colore di sfondo della finestra grafica<\/p>\n<\/td>\n<\/tr>\n | \n| delay( | | | | | | | | | | | | | | | | | | | | | | | |