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:



Nessun commento: