Grafica con Python: Turtle

Il modulo turtle in Python è una specie di tartaruga nel mondo reale. Conosciamo una tartaruga come un rettile che si muove molto lentamente e porta la sua casa sul dorso. Nel mondo di Python, una tartaruga è una piccola freccia nera che si muove lentamente sullo schermo. In realtà, considerando che una tartaruga Python lascia una scia mentre si muove sullo schermo, in realtà è meno come una tartaruga e più come una lumaca.

Turtle è un bel modo per imparare alcune delle basi della computer grafica, quindi adesso proveremo ad usare il modulo Python turtle per disegnare alcune semplici forme e linee.

Utilizzo del modulo turtle di Python

Un modulo in Python è un modo per fornire un codice utile che deve essere utilizzato da un altro programma (tra le altre cose, il modulo può contenere funzioni che possiamo usare). Python ha un modulo speciale chiamato turtle che possiamo usare per imparare come i computer disegnano immagini su uno schermo. Il modulo turtle è un modo di programmare la grafica vettoriale, che fondamentalmente si limita a disegnare con semplici linee, punti e curve.

Vediamo come funziona il modulo turtle. Per prima cosa, avvia la shell Python facendo clic sull'icona sul desktop (o se stai usando Ubuntu, seleziona Applicazioni ▸ Programmazione ▸ IDLE). Quindi, dì a Python di usare la tartaruga importando il modulo turtle, come segue:

>>> import turtle

L'importazione di un modulo dice a Python che lo vuoi usare.

Creazione di un canvas

Ora che abbiamo importato il modulo tartaruga, dobbiamo creare un canvas, uno spazio vuoto su cui disegnare, come la tela di un artista. Per fare ciò, chiamiamo la funzione Pen dal modulo turtle, che crea automaticamente una tela. Inseriscilo nella shell Python:

>>> t = turtle.Pen()

Dovresti vedere una casella vuota (la tela), con una freccia al centro, qualcosa come questo:


Muovere la tartaruga

Si inviano istruzioni alla tartaruga utilizzando le funzioni disponibili sulla variabile t che abbiamo appena creato, in modo simile all'utilizzo della funzione Pen nel modulo tartaruga. Ad esempio, l'istruzione in forward dice alla tartaruga di andare avanti. Per dire alla tartaruga di avanzare di 50 pixel, inserisci il seguente comando:

>>> t. forward(50)

Dovresti vedere che la tartaruga si è spostata in avanti di 50 pixel. 



Un pixel è un singolo punto sullo schermo, l'elemento più piccolo che può essere rappresentato. Tutto ciò che vedi sul monitor del tuo computer è composto da pixel, che sono piccoli punti quadrati. Se potessi ingrandire la tela e la linea tracciata dalla tartaruga, potresti vedere che la freccia che rappresenta il percorso della tartaruga è solo un mucchio di pixel. Questa è semplice computer grafica.

Ora diremo alla tartaruga di girare a sinistra di 90 gradi con il seguente comando:

>>> t. left(90)

Se non hai ancora imparato a conoscere i gradi, ecco come pensarci.

Immagina di essere al centro di un cerchio.

La direzione verso cui sei rivolto è 0 gradi.

Se allunghi il braccio sinistro, sarà di 90 gradi a sinistra.

Se allunghi il braccio destro, è di 90 gradi a destra.

Puoi vedere questa svolta di 90 gradi a sinistra o a destra qui:

Se continui intorno al cerchio verso destra da dove punta il braccio destro, 180 gradi è direttamente dietro di te, 270 gradi è la direzione in cui punta il braccio sinistro e 360 gradi è indietro dove hai iniziato; i gradi vanno da 0 a 360. 

Quando la tartaruga di Python gira a sinistra, gira per guardare nella nuova direzione (proprio come se girassi il tuo corpo verso il punto in cui il tuo braccio punta di 90 gradi a sinistra).

Dunque comando t.left(90) che abbiamo utilizzato prima punta la freccia verso l'alto (poiché inizia sempre puntando a destra)

Ora proviamo a disegnare un semplice quadrato con il lato di 50px. Aggiungi il seguente codice alle righe che hai già inserito:

>>> t. forward(50)
>>> t. left (90)
>>> t. forward(50)
>>> t. left (90)
>>> t. forward(50)
>>> t. left(90)

La tua tartaruga dovrebbe aver disegnato un quadrato e ora dovrebbe essere rivolta nella stessa direzione in cui è iniziata:

Per cancellare la tela, utilizza il comando reset. Questo cancella la tela e riporta la tartaruga nella sua posizione di partenza.

>>> t.reset ()

Puoi anche usare Clear, che cancella semplicemente lo schermo e lascia la tartaruga dov'è.
Possiamo anche girare la nostra tartaruga a destra o spostarla all'indietro. Possiamo usare up per sollevare la penna dalla pagina (in altre parole, dire alla tartaruga di smettere di disegnare) e down per iniziare a disegnare. Queste funzioni sono scritte nello stesso modo delle altre che abbiamo usato.
Proviamo un altro disegno utilizzando alcuni di questi comandi. Questa volta, faremo disegnare alla tartaruga due linee parallele. Inserisci il codice seguente:

>>> t.reset()
>>> t.backward(100) 
>>> t.up()
>>> t.right(90)
>>> t.forward(20) 
>>> t.left(90)
>>> t.down()
>>> t. forward(100)
>>> t.clear()

Per prima cosa, resettiamo la tela e riportiamo la tartaruga nella sua posizione iniziale con t.reset(). Successivamente, spostiamo la tartaruga indietro di 100 pixel con t.backward(100), quindi usiamo t.up() per prendere la penna e smettere di disegnare.
Quindi, con il comando t.right(90), ruotiamo la tartaruga a destra di 90 gradi per puntare verso il basso, verso il fondo dello schermo, e con t.forward(20), ci spostiamo in avanti di 20 pixel. Non viene disegnato niente in questo caso perché abbiamo utilizzato il comando up sulla terza riga. Ruotiamo la tartaruga a sinistra di 90 gradi verso destra con t.left(90), quindi con il comando down, diciamo alla tartaruga di rimettere la penna verso il basso e ricominciare a disegnare. Infine, tracciamo una linea in avanti, parallela alla prima linea che abbiamo disegnato, con t.forward(100). Le due linee parallele che abbiamo disegnato finiscono per assomigliare a questa:

Prova di programma con turtle (caleidoscopio)

Adesso che abbiamo imparato le basi per utilizzare la grafica e il modulo turtle proviamo a fare un piccolo e semplice programma per fare un pò di pratica.

1. Prima di tutto creiamo un nuovo file python con DLE e salviamolo con il nome caleidoscopio.py.

2. Importiamo il modulo con il comando import turtle

3. Diamo alcune impostazioni a turtle (colore sfondo, velocità e dimensioni della penna)

>>>>turtle.bgcolor('black')
>>>>turtle.speed('fast')
>>>>turtle.pensize(4)

4. Proviamo a disegnare un cerchio di colore rosso con i seguenti comandi

>>>>turtle.pencolor('red')
>>>>turtle.circle(30)

5. Proviamo a disegnare più cerchi utilizzando una funzione.
Definiamo la funzione disegna_cerchio con il parametro raggio come segue:

def disegna_cerchio(raggio):
        turtle.pencolor('red')
        turtle.circle(raggio)
        disegna_cerchio(raggio)

l'ultima riga della funzione richiama se stessa per fare in modo che venga ripetuta all'infinito (è un modo alternativo per fare un ciclo ed è chiamato ricursione).

Una volta definita la funzione (prima che venga chiamata) la chiameremo utilizzando disegna_cerchio(30) al posto di quanto abbiamo scritto al punto 4

6. Cambiamo i colori e le dimensioni dei cerchi
Per creare modelli più eccitanti, apporta queste modifiche al codice per aumentare la dimensione del cerchio e cambiarne il colore. Questo codice utilizza la funzione cycle(), che accetta un elenco di valori come parametro e restituisce un tipo speciale di elenco che è possibile scorrere all'infinito utilizzando la funzione next()
Dopo import turtle inseriamo le seguenti righe:

from itertools import cycle
colori = cycle(['red', 'orange', 'yellow', 'green', 'blue', 'purple'])

e modifichiamo la funzione come segue:

def disegna_cerchio(raggio):
        turtle.pencolor(next(colori))
        turtle.circle(raggio)
        disegna_cerchio(raggio + 5)

7. Aggiungiamo più effetti modificando l'angolo e la posizione
Per aggiungere più effetti al nostro caleidoscopio aggiungiamo due parametri: angolo e posizione
La nostra funzione diventerà come segue:

def disegna_cerchio(raggio, angolo, posizione):
        turtle.pencolor(next(colori))
        turtle.circle(raggio)
        turtle.right(angolo)
        turtle.forward(posizione)
        disegna_cerchio(raggio + 5, angolo + 1, posizione + 1)

In questo modo ogni volta che la nostra funzione richiamerà se stessa il cerchio (freccia di turtle) si sposterà di 1 andando in direzione di angolo +1 ruotato a destra. 

Il programma finale sarà come segue:

Adesso potete provare a divertirvi a vedere cosa succede cambiando la dimensione della penna o i valori dei parametri passati alla funzione ...

Potete anche provare ad alternare ai cerchi altre figure geometriche come quadrati, triangoli, rettangoli ...

Esempio:



Python: 3 - Aggiungere struttura al codice

Strutture di controllo 

Piuttosto che passare semplicemente attraverso un programma ed eseguire ogni riga di codice quando si incontra, probabilmente si desidera un maggiore controllo. Queste strutture di controllo consentono di eseguire codice solo quando esiste una condizione specifica e di eseguire blocchi di codice più volte. Nella maggior parte dei casi, sarà più facile guidarti attraverso questi concetti che cercare di descriverli. 

Istruzione if 

L'istruzione if consente di verificare una condizione prima di eseguire un blocco di codice. La condizione può essere qualsiasi valore o equazione che restituisce true o false. 
Il prossimo pezzo di codice scorre l'elenco dei robot e determina se il robot è Uno. 

>>> for robot in robots: 
            if robot == "Uno": 
                print ("Questo è Uno") 
            else: 
                print (robot + "non è Uno") 
Questo è Uno 
Due non è Uno 
Tre non è Uno 

Ancora una volta, nota il rientro durante la digitazione. IDLE fa rientrare un altro livello dopo ogni riga che termina con due punti, che dovrebbe essere ogni riga che denota un nuovo blocco, come istruzioni di ciclo e condizionali. 
È importante anche notare come testiamo l'uguaglianza
Un singolo segno di uguale significa assegnazione
I segni di doppio uguale dicono all'interprete di confrontare per l'uguaglianza

>>> myRobot = "Uno"
>>> myRobot == "Due"
False 
>>> myRobot == "Uno"
True 

Ecco un elenco di comparatori
è uguale a             == 
non uguale             != 
Minore di              <
Maggiore di           
Minore o uguale a      <= 
Maggiore o uguale a    > = 

È inoltre possibile utilizzare and e or per verificare più condizioni. 

>>> for robot in robots: 
           if robot == "Due" or robot == "Tre": 
               print("Questi non sono i droidi che sto cercando.") 
Questi non sono i droidi che sto cercando. 
Questi non sono i droidi che sto cercando. 

I confronti vengono spesso utilizzati anche per determinare se un oggetto esiste o contiene un valore. In sostanza, una condizione restituisce true se non restituisce false, 0 o nessuno. Ciò è molto utile quando si desidera eseguire una porzione di codice solo se esiste un oggetto, ad esempio quando si inizializzano sensori o connessioni tramite una porta seriale o una rete.

I Cicli 

Quando lavori con la robotica, ci sono volte in cui vuoi ripetere un blocco di codice. Se eseguire una serie di istruzioni su una raccolta di oggetti o eseguire un blocco di codice per tutto il tempo in cui esiste una condizione, è necessario utilizzare un ciclo. I cicli consentono di ripetere un blocco di codice per eseguire le attività più volte. Esistono due tipi di loop: il ciclo for e il ciclo while. Ciascuno fornisce una funzionalità specifica che è cruciale per scrivere programmi efficienti. 

Ciclo for

Un ciclo for esegue un blocco di codice per ogni elemento in un elenco. 
Una raccolta di valori, una tupla, un elenco o un dizionario, viene fornito al ciclo for. Quindi itera nell'elenco ed esegue il codice contenuto nel blocco di codice. Quando esaurisce gli elementi nella raccolta, il ciclo viene chiuso e viene eseguita la riga di codice successiva all'esterno del blocco for. 
Come con l'istruzione if, inserisci il codice che vuoi eseguire come parte del ciclo in un blocco indicato dal rientro. 
È importante assicurarsi di aver corretto il rientro, altrimenti verrà visualizzato un errore. Quando lo inserisci nella shell Python, fai attenzione a cosa fa con il rientro. Dopo aver inserito il comando di stampa e premuto Invio, è necessario premere nuovamente Invio in modo che la shell sappia che hai finito. 

>>> for robot in robots: 
          print(robot) 
Uno 
Due 
Tre 

Il programma entra nell'elenco dei robot e estrae il primo valore, Uno, che poi stampa. Poiché questa è l'ultima riga del blocco, l'interprete ritorna all'elenco ed estrae il valore successivo. Questo si ripete fino a quando non ci sono più valori nell'elenco. A questo punto, il programma esce dal ciclo. 
Tendo a usare parole plurali per i nomi delle mie liste. Ciò mi consente di utilizzare la forma singolare del nome per fare riferimento agli elementi all'interno dell'elenco per un ciclo. Ad esempio, ogni elemento nella tupla di Robots è un robot. 
Se desideri scorrere gli elementi in un dizionario, devi fornire due variabili per memorizzare i singoli elementi. È inoltre necessario utilizzare il metodo items della classe dictionary. Ciò consente di accedere a turno a ciascuna coppia chiave / valore. 

>>> for nome, dati in Robots.items(): 
                print(nome + ':' + dati) 
colore:nero 
tipo: con ruote 

È possibile utilizzare la funzione enumerate per aggiungere un valore numerico sequenziale all'output di un ciclo for. 

>>> for num, robot in enumerate(robots): 
                print(num, robot) 
(0, 'Uno') 
(1, "Due") 
(2, "Tre") 

Ciclo while 

Mentre un ciclo for esegue un blocco di codice per ogni elemento in un elenco, il ciclo while esegue un blocco di codice fintanto che la sua condizione restituisce true
Viene spesso utilizzato per eseguire codice un numero specifico di volte o mentre il sistema si trova in uno stato specifico. Per scorrere il codice un numero specifico di volte, utilizzare una variabile per contenere un valore intero. Nell'esempio seguente, diciamo al programma di eseguire il codice fintanto che il valore della nostra variabile di conteggio è inferiore a cinque. 

>>> conta = 1 
>>> while conta <5: 
            print(conta)
            conta = conta + 1

Iniziamo dichiarando una variabile, conta, per contenere il nostro numero intero, e gli assegniamo il valore 1. 
Entriamo nel ciclo e il valore di 1 è minore di 5, quindi il codice stampa il valore sulla console. 
Quindi incrementiamo il valore di count di 1. Perché questa è l'ultima istruzione del ciclo e l'ultimo valore valutato se la condizione while era inferiore a 5, il codice ritorna alla clausola while. 
Il valore di count, ora 2, è ancora inferiore a 5, quindi il codice viene eseguito di nuovo. Questo processo si ripete fino a quando il valore di count è 5. 
Cinque non è inferiore a cinque, quindi l'interprete esce dal ciclo senza eseguire il codice nel blocco. 
Se ci fossimo dimenticati di incrementare la variabile conta, sarebbe risultato un ciclo aperto. 
Poiché conta è uguale a 1 e non lo incrementiamo mai, il valore di conta è sempre uguale a 1. Uno è inferiore a cinque, quindi l'esecuzione del codice non si interromperà mai e dovremmo premere Ctrl-C per terminarlo. 
Viene anche utilizzato come un tipo di ciclo principale, eseguendo il codice continuamente. Vedi quanto segue in molti programmi: 

while(true): 

True restituisce sempre true; pertanto, il codice all'interno di questo blocco continua a essere eseguito finché non si esce dal programma. 
Questo è chiamato un ciclo aperto poiché non si chiude mai. 
Fortunatamente, esiste un modo conveniente per uscire dai loop aperti. Se ti trovi in ​​un ciclo aperto, o vuoi semplicemente uscire da un programma arbitrariamente, premi Ctrl-C
Ciò causa la chiusura immediata del programma. Lo userai frequentemente. Questa tecnica può essere utilizzata anche per far aspettare il programma una condizione specifica da soddisfare. Ad esempio, se richiedessimo la disponibilità di una connessione seriale prima di continuare, avremmo prima avviato il comando di connessione. Quindi potremmo attendere il completamento della connessione prima di continuare utilizzando alcuni come questo: 

while(!connesso): 
            pass

Il punto esclamativo significa not. Quindi, in questo caso, supponendo che la variabile connesso contenga la connessione seriale che restituisce true quando viene stabilita, stiamo dicendo al programma di eseguire il codice contenuto nel blocco while fintanto che non è connesso. In questo caso, il codice che gli diciamo di eseguire è chiamato pass, che è un comando vuoto. Viene utilizzato quando in realtà non vuoi fare nulla, ma hai bisogno di qualcosa in quel posto. Quindi, stiamo dicendo al sistema questo: "Anche se non sei connesso, non fare nulla e continua finché non sei connesso".