Disegnare con Python: arte con il modulo turtle

Divento Programmatore — Capitolo 6: Arte con il Computer

Obiettivi di Apprendimento

Al termine di questo capitolo avrai costruito un programma completo di Arte con il Computer e imparerai a:

Utilizzare il modulo turtle di Python per generare grafica bidimensionale a schermo
Comprendere il sistema di coordinate cartesiane con origine al centro dello schermo
Gestire lo stato della penna grafica alzandola (penup) e abbassandola (pendown)
Usare cicli creativi per variare le direzioni e i passi di disegno creando spirografi
Manipolare colori e spessori in modo dinamico all'interno dei cicli di disegno

Termini Fondamentali

| Termine | Simbolo | Significato | | --------- | --------- | ------------- | | Turtle Graphics | 🐢 | Celebre modulo Python usato per l'introduzione alla programmazione grafica tramite la simulazione di una tartaruga che si muove su un foglio da disegno virtuale | | Coordinate piane (x, y) | 🗺️ | Coppia di valori numerici che individuano la posizione esatta nello spazio grafico (dove l'asse X è orizzontale e l'asse Y è verticale) | | penup() / pendown() | 🖊️ | Funzioni utilizzate per staccare la penna dal foglio (muoversi senza disegnare) o appoggiarla (iniziare a tracciare linee) | | Spirografo | 🌀 | Strumento o disegno geometrico ottenuto tracciando curve complesse basate su rotazioni matematiche ripetute | | colormode() | 🎨 | Impostazione che definisce come vengono specificati i colori in turtle (tramite nomi di colori testuali o terne numeriche RGB) |

La Storia: La tartaruga che camminava sul pavimento

Oggi consideriamo ovvio che i computer abbiano schermi grafici ricchi di colori e animazioni. Ma alla fine degli anni '60, i computer non avevano monitor: l'output veniva stampato su rulli di carta continui o su schede perforate!

Nel 1967, lo scienziato e matematico Seymour Papert, insieme ai suoi colleghi del MIT (Massachusetts Institute of Technology), inventò un linguaggio di programmazione chiamato LOGO. Papert voleva trovare un modo fisico e divertente per insegnare la matematica e la logica ai bambini. Così, costruì una vera tartaruga robotica di plastica, dotata di ruote e di un pennarello inserito sotto la pancia, e la collegò al computer.

I bambini scrivevano comandi come FORWARD 50 (avanti di 50 passi) o RIGHT 90 (gira a destra di 90 gradi) e il robot si muoveva fisicamente sul pavimento della stanza, disegnando figure geometriche su grandi fogli di carta stesi a terra. Quando gli schermi grafici divennero popolari, la tartaruga fisica si trasformò nel cursore a forma di freccia (o di piccola tartaruga) che oggi usiamo all'interno di Python. Programmare con turtle significa ripercorrere i passi dei pionieri della didattica del coding!

Concept 1: Il piano cartesiano dello schermo

Quando disegniamo con turtle, la finestra grafica si comporta come una mappa con un sistema di coordinate cartesiane. Il centro esatto dello schermo corrisponde alle coordinate (0, 0).

                  +Y (Su)
                   |
                   |
    -X (Sinistra) --(0,0)-- +X (Destra)
                   |
                   |
                  -Y (Giù)

Per spostare la tartaruga in un punto specifico dello schermo, usiamo la funzione goto(x, y).

L'asse X rappresenta lo spostamento orizzontale: numeri positivi vanno a destra, numeri negativi a sinistra.
L'asse Y rappresenta lo spostamento verticale: numeri positivi vanno in alto, numeri negativi in basso.

Attenzione: se ti sposti usando goto() quando la penna è abbassata (pendown()), la tartaruga traccerà una linea continua dal punto di partenza a quello di arrivo. Se vuoi spostarti senza disegnare, ricordati di chiamare prima penup() e poi ripristinare il disegno con pendown() una volta giunto a destinazione!

Concept 2: I cicli geometrici (Come nascono gli spirografi)

Come fa un computer a disegnare curve perfette o motivi simmetrici complessi usando solo linee rette? Semplice: esegue piccoli passi ripetuti migliaia di volte, ruotando leggermente a ogni passo.

Ad esempio, per disegnare un cerchio completo senza usare la funzione predefinita circle(), possiamo dire alla tartaruga di fare 1 passo in avanti e girare a destra di 1 grado, ripetendo il tutto per 360 volte:

for i in range(360):
    t.forward(1)
    t.right(1)

Se invece di fare passi di lunghezza fissa facciamo passi che crescono a ogni iterazione (usando la variabile del ciclo for), otteniamo una bellissima spirale geometrica:

for i in range(100):
    t.forward(i * 2)  # Il passo diventa sempre più lungo!
    t.right(45)

Costruiamo il Gioco: Versione Base

Ecco la versione base che disegna un quadrato colorato e lo ripete ruotando leggermente per creare un fiore geometrico:

import turtle

# Setup della finestra
finestra = turtle.Screen()
finestra.bgcolor("white")

# Creiamo la tartaruga artista
t = turtle.Turtle()
t.speed(5)
t.color("blue")

print("🎨 BENVENUTO AD ARTE BASE 🎨\n")

# Disegniamo un fiore geometrico ripetendo 36 quadrati
for _ in range(36):
    # Disegniamo un singolo quadrato
    for _ in range(4):
        t.forward(100)
        t.right(90)
    # Ruotiamo la tartaruga di 10 gradi prima del prossimo quadrato
    t.right(10)

# Lasciamo lo schermo aperto finché non ci si clicca sopra
finestra.exitonclick()

Sfide: Fai salire di livello la tua Arte

Sfida 1 — La Stella a 5 Punte

Crea una funzione chiamata disegna_stella che disegni una stella a 5 punte regolare. L'angolo interno di rotazione per una stella a 5 punte è di 144 gradi.

Sfida 2 — I Colori Arcobaleno

Invece di usare un unico colore, crea una lista contenente 6 colori diversi. Fai in modo che a ogni lato disegnato nello spirografo, la tartaruga cambi colore prendendolo in sequenza dalla lista.

Sfida 3 — Lo Spirografo Matematico

Crea una spirale complessa multicolore in cui la larghezza del tratto della penna cresce all'aumentare dei passi, creando un effetto 3D.

Sfida 4 — L'opera d'arte astratta

Combina tutti i concetti: scrivi un programma che generi uno spirografo multicolore al centro, e poi posizioni in modo casuale sullo sfondo (usando coordinate random) una pioggia di piccole stelle piene e cerchi colorati, nascondendo la tartaruga alla fine per mostrare il quadro pulito.

Il Codice Completo con Tutte le Sfide

Salva questo codice in Thonny come arte_astratta.py ed eseguilo per vedere il computer dipingere in tempo reale!

import turtle
import random

def disegna_stella(t, dimensione, colore):
    """Sfida 1: Disegna una stella a 5 punte con riempimento colore."""
    t.color(colore)
    t.begin_fill()
    for _ in range(5):
        t.forward(dimensione)
        t.right(144)
    t.end_fill()

def disegna_cerchio(t, raggio, colore):
    """Disegna un cerchio pieno per decorare lo sfondo."""
    t.color(colore)
    t.begin_fill()
    t.circle(raggio)
    t.end_fill()

def sposta_tartaruga(t, x, y):
    """Sposta la tartaruga senza lasciare tracce sullo schermo."""
    t.penup()
    t.goto(x, y)
    t.pendown()

def crea_spirografo_arcobaleno(t):
    """Sfida 2 & 3: Crea uno spirografo geometrico multicolore con spessore crescente."""
    colori = ["red", "purple", "blue", "green", "orange", "yellow"]
    for i in range(120):
        # Il modulo % ci consente di scorrere la lista colori all'infinito
        t.color(colori[i % len(colori)])
        # Lo spessore della penna cresce leggermente ad ogni ciclo
        t.width(i / 100 + 1)
        t.forward(i * 1.5)
        t.left(59)

def main():
    # Setup dello schermo grafico
    schermo = turtle.Screen()
    schermo.bgcolor("black")
    schermo.title("🤖 Galleria d'Arte Astratta di Python 🎨")
    
    # Setup dell'artista tartaruga
    artista = turtle.Turtle()
    artista.speed(0)  # Massima velocità di disegno (istantanea)
    
    # 1. Creiamo lo spirografo centrale
    sposta_tartaruga(artista, 0, 0)
    crea_spirografo_arcobaleno(artista)
    
    # 2. Sfida 4: Aggiungiamo dettagli artistici sparsi a caso (stelle e cerchi)
    colori_disponibili = ["cyan", "magenta", "yellow", "white", "pink", "lime"]
    
    # Disegniamo 8 stelle in posizioni casuali nella parte alta dello schermo
    for _ in range(8):
        x = random.randint(-250, 250)
        y = random.randint(150, 250)
        dim = random.randint(20, 60)
        col = random.choice(colori_disponibili)
        
        sposta_tartaruga(artista, x, y)
        disegna_stella(artista, dim, col)
        
    # Disegniamo 6 cerchi in posizioni casuali nella parte bassa dello schermo
    for _ in range(6):
        x = random.randint(-250, 250)
        y = random.randint(-250, -150)
        raggio = random.randint(10, 30)
        col = random.choice(colori_disponibili)
        
        sposta_tartaruga(artista, x, y)
        disegna_cerchio(artista, raggio, col)
        
    # Nascondiamo la tartaruga a disegno ultimato per non coprire l'opera
    artista.hideturtle()
    
    print("🎨 Disegno completato! Clicca sulla finestra grafica per chiuderla.")
    schermo.exitonclick()

if __name__ == "__main__":
    main()

Analisi del Codice Completo

Analizziamo i concetti cardine applicati in questo generatore d'arte:

1. Massima velocità di calcolo (`speed(0)`)

La velocità di turtle varia da 1 (lenta) a 10 (veloce). Tuttavia, passando il valore 0 diciamo a Python di disattivare l'animazione dei passi intermedi, eseguendo il tracciamento delle linee alla massima velocità consentita dal processore del tuo computer.

2. Operatore Modulo per cicli infiniti (`i % len(colori)`)

Quando usiamo una lista colori contenente 6 elementi, ad esempio, e il nostro ciclo for fa 120 iterazioni, l'indice i crescerà ben oltre la dimensione della lista (causando un errore di tipo IndexError). Usando l'operatore modulo % (i % 6), il risultato sarà sempre un numero compreso tra 0 e 5 (il resto della divisione per 6), garantendo un ciclo continuo e sicuro di colori.

3. Riempimento delle forme (`begin_fill` / `end_fill`)

Per colorare l'interno delle stelle o dei cerchi, racchiudiamo le istruzioni di movimento tra t.begin_fill() e t.end_fill(). Python memorizza il percorso tracciato dalla tartaruga e, non appena viene chiamato end_fill(), colora automaticamente l'area interna con il colore selezionato.

Curiosità: I frattali in natura

Lo sapevi che la grafica generata al computer viene usata per studiare i frattali? I frattali sono figure geometriche infinite in cui ogni minima parte riproduce in piccolo la figura intera (un concetto chiamato auto-somiglianza). Esempi di frattali in natura sono i fiocchi di neve, le foglie di felce e i cavolfiori romaneschi!

Provaci tu! — Disegna un poligono

Prova a modificare il codice per creare una funzione disegna_poligono(t, lati, dimensione) che disegni qualsiasi poligono regolare (un triangolo, un pentagono o un esagono). Ricorda la formula matematica: per girare correttamente, la tartaruga deve ruotare di un angolo pari a 360 / lati gradi!

Il Piccolo Glossario

| Termine | Definizione | | --------- | ------------- | | API (Application Programming Interface) | L'insieme di funzioni e comandi messi a disposizione da una libreria (come turtle) per consentire ai programmatori di interagire con essa. | | Cartesian coordinates / Coordinate cartesiane | Un sistema di riferimento geometrico basato su due assi perpendicolari (X e Y). | | begin_fill() / end_fill() | Comandi Python usati per indicare l'inizio e la fine di una forma geometrica chiusa da colorare interamente. | | hideturtle() | Funzione che nasconde il cursore a forma di freccia dallo schermo, lasciando visibile solo il disegno completato. | | exitonclick() | Comando che tiene aperta la finestra grafica di disegno finché il giocatore non fa clic con il mouse all'interno di essa. |

Prossimo capitolo

Capitolo 7: Snake — Il Classico dei Classici
pygame installazione pip, Game Loop, clock.tick(), eventi tastiera tempo reale, collisioni discrete (cibo, bordi, corpo), lista segmenti snake, crescita. Codice completo con 4 sfide: coda, velocità progressiva, effetti sonori, ostacoli fissi.

Questo post è un estratto dal libro "Divento Programmatore: Python e i Giochi" (Volume 2 della collana "Cervello Elettronico") di Rocco Balzamà. Target: 10-14 anni · ~180 pagine · Thonny + VS Code.

Per approfondire

Fonti e riferimenti

Modulo turtle, documentazione Python