Logo e turtle

Logo e turtle: negli informatici sufficientemente attempati come me, questi due termini dovrebbero risvegliare un ricordo.
Progettato nel 1967 da Wally Feurzeig, Seymour Papert e Cynthia Solomon e realizzato due anni dopo, il linguaggio Logo ha trovato utilizzo in modo particolare nella didattica.
Pur con una sintassi molto semplice, consente infatti di costruire con poco sforzo grafici, anche ricorsivi. La comprensione di come operare con la sua grafica è semplificata poi dal concetto della tartaruga (turtle), che traccia disegni sullo schermo guidata dalle istruzioni del programma.
Ancora oggi si trovano sul web ambienti Logo online su cui è facile sperimentare.
Salvando il concetto grafico di Turtle, su Python è disponibile un modulo (turtle, per l’appunto) che consente di giocare con la grafica alla Logo.
Quando, nel 2006, scrissi i miei primi post, li incentrai proprio su alcuni disegni ricorsivi costruiti con logica Logo e Turtle, ma realizzati in Basic. Con un’operazione amarcord, ho provato, oltre 15 anni dopo, a riprodurre uno di quei disegni, un albero.


Il linguaggio Logo sul web

Un ambiente di sperimentazione su Logo, completo anche di sintetico manuale del linguaggio, è gratuitamente disponibile sul sito Calormen.com. Bastano pochi minuti per capire come muoversi e cominciare a giocare. Ad esempio, ecco come tracciare dei pentagoni:

Logo e turtle: un ambiente di prova su web

Nelle prime righe viene costruita la funzione pent,  che traccia un pentagono di lato dato (:size). Le parole chiave sono di facile comprensione: fd sta per forward, muoviti in avanti, mentre rt sta per rotate, ed è seguìto dall’indicazione dell’angolo in gradi.

Riproporre Logo e Turtle in ambiente Python

Python è un linguaggio semplice da apprendere e da utilizzare, su qualunque piattaforma, ed è anche estremamente potente, grazie ai moduli disponibili che ne estendono l’utilizzo nelle più varie applicazioni. Un modulo disponibile è, appunto, turtle.
In questo esercizio non ho utilizzato, come faccio in genere, l’ambiente Google Colaboratory, ma Replit. Il motivo è presto detto: il Google Colaboratory prevede un proprio modulo, ColabTurtle. Preferisco l’ambiente Replit, che consente di utilizzare il modulo standard.
Per utilizzare Replit è sufficiente creare un account gratuito, aprire un nuovo progetto vuoto e cominciare a inserire il codice Python. La velocità non è entusiasmante, ma va bene per lo scopo amarcord dell’operazione.

Il programma

La struttura del programma è abbastanza semplice:

  • import del modulo turtle;
  • la funzione che traccia ricorsivamente le fronde dell’albero;
  • la definizione dei parametri che configurano l’albero (dimensioni, colori, livelli e numerosità di ramificazione);
  • il blocco principale, che disegna il tronco e chiama la funzione che traccia le fronde;
  • export del disegno dell’albero.

Il risultato è questo (spero traspaia il mio forte desiderio di primavera):

Logo e Turtle: un albero

Un esempio di utilizzo di Replit

Prima di descrivere il programma che traccia l’albero, può tornar utile una breve introduzione all’utilizzo di Replit.
Dopo aver registrato il proprio account gratuito su Replit, autenticarsi e aprire il proprio primo progetto. Inserire quindi nel modulo main.py questo semplice codice:

from turtle import *
penup() # non tracciare!
sety(-250) # sposta la tartaruga per centrare il disegno nel foglio
pendown() # ricomincia a tracciare
color('red') # il prossimo tratto è di colore rosso
forward(300) # avanza di 300 pixel
left(120) # ruota a sinistra di 120°
color('green')
forward(300)
left(120)
color('blue')
forward(300)
left(120)

Ho inserito i commenti in linea nel codice (es.: # non tracciare!), ma è ovviamente possibile evitare di inserirli.
Il risultato dovrebbe essere questo (la diversa colorazione dei lati dovrebbe aiutare a capire come si muove la tartaruga, che parte e termina nell’angolo in basso a sinistra):

I dettagli del programma per tracciare l’albero

L’import del modulo turtle è banale:

from turtle import *

Lasciando da parte per un momento la funzione di tracciamento dell’albero, vediamo la sezione di configurazione dei parametri dell’albero:

size, resize = 120, 1.3
pensize(1.5)
rot = [-45,-15,20,40]
color_list = ['darkgoldenrod','goldenrod','pink']
level = 5

Il parametro size determina la lunghezza in pixel della base dell’albero. Ogni successivo livello di ramificazione ha una lunghezza scalata progressivamente da size secondo il fattore resize.

Pensize determina lo spessore del tratto che traccia l’albero, mentre la lista rot elenca gli angoli di deviazione di ciascuna diramazione, rispetto alla direzione del ramo genitore. Il numero di diramazioni a ciascun livello è quindi dato semplicemente dal numero di elementi nella lista rot.
La lista color_list descrive poi i colori da applicare rispettivamente alla base dell’albero, ai rami dei livelli successivi, all’ultimo livello. I colori seguono la definizione standard, che può essere consultata sul sito del World Wide Web Consortium (W3C).

La funzione ricorsiva di tracciamento dell’albero

La funzione branch() riceve in ingresso il livello di diramazione da tracciare e la dimensione dei rami, oltre al parametro globale resize. Sono implicitamente globali anche le liste, poiché in Python questo tipo di variabile è passato alle funzioni mediante riferimento e non mediante valore. Le liste in questione sono due: color_list e rot.

Il funzionamento della funzione è abbastanza semplice: se si sono esauriti i livelli richiesti, la funzione ritorna al chiamante senza fare nulla. Altrimenti adegua il colore e traccia, dal punto in cui si trova la tartaruga, un mini albero, chiamando sé stessa.


def branch(level,size):
  global resize
  if level == 0:
      return (True)
  else:
    curr_color = color()[0]
    if level == 1:
      color(color_list[-1])
    else:
      color(color_list[1])
    for i in rot:
      right(i)
      forward(size)
      branch(level-1,size/resize)
      backward(size)
      left(i)
    color(curr_color)
    return(True)

Il corpo centrale del programma

In questa sezione di codice si predispone lo stato della tartaruga (non visibile e che punta verso il bordo superiore del foglio), si traccia la base dell’albero e poi si chiama la funzione che, ricorsivamente, si occuperà di tracciare l’intero albero.

hideturtle()
color(color_list[0])
left(90)
penup()
sety(-size*resize)
pendown()
forward(size)
branch(level,size/resize)

Export dell’immagine tracciata

Anche l’export dell’immagine non è complicato. Unica osservazione, è possibile esportare in formato postscript, che poi andrà convertito nel formato grafico preferito. Ho usato gimp per esportare in jpeg.

getscreen().getcanvas().postscript(file='albero.ps')

Come ottenere il codice del programma e come giocarci

Il codice del programma può essere scaricato da qui.
Il modo più semplice per mettere le mani sul codice e sperimentare è quello di ricreare l’ambiente in cui l’ho sviluppato. Quindi:

  • registrare un account gratuito su replit.com;
  • creare un progetto vuoto;
  • fare upload del file main.py, estratto dall’archivio postato appena più su;
  • run!

Immagine di OpenClipart-Vectors da Pixabay.

Ti è piaciuto? Condividilo!

Scritto da:

Pasquale

Mi chiamo Pasquale Petrosino, radici campane, da alcuni anni sulle rive del lago di Lecco, dopo aver lungamente vissuto a Ivrea.
Ho attraversato 40 anni di tecnologia informatica, da quando progettavo hardware maneggiando i primi microprocessori, la memoria si misurava in kByte, e Ethernet era una novità fresca fresca, fino alla comparsa ed esplosione di Internet.
Tre passioni: la Tecnologia, la Matematica per diletto e le mie tre donne: la piccola Luna, Orsella e Valentina.
Potete contattarmi scrivendo a: p.petrosino@inchiostrovirtuale.it