Python – Una tortuga de brocha fina

Objetivo: presentar el módulo turtle para la creación de gráficos en Python.

Python no sólo es un lenguaje versátil, potente y elegante. Programar en Python es, desde mi opinión, una labor usualmente más gratificante y divertida que hacerlo con otros lenguajes. El artículo de hoy explora una de sus facetas particularmente lúdica, pero no por ello menos interesante y práctica.

He aprovechado para matar dos pájaros de un tiro: por un lado, tenía previsto que la siguiente entrada del blog estuviera dedicada a Python, a la par que estoy empezando a preparar otras, relacionadas con la música, que expliquen el concepto y utilidades del círculo de quintas. Para ello, requería hacer uso del siguiente gráfico:

circulo-quintas-python

Al final del artículo presentaré el código Python que genera este diagrama.

Vamos a introducirnos en el modo gráfico presentando una sencilla herramienta: una tortuga artista que podemos manejar a nuestra conveniencia y que va dejando rastro allá por donde pisa.

El módulo turtle es, además, un excelente medio para explicar a un niño en qué consiste la programación de ordenadores, pues propone una forma visual y divertida de comprobar las relaciones causa-efecto que suceden a lo largo de un programa.

Para introducir en escena a nuestra tortuguita de brocha fina necesitamos invocar, en primer lugar, al módulo turtle:

>>> import turtle

A continuación le pedimos que se muestre en la pantalla:

>>> turtle.showturtle()

Aparece una nueva ventana gráfica en la que, posicionado en su centro, se muestra un cursor con forma de punta de flecha: la tortuga pintadora.

turtle-1

Ciertamente, este cursor no se asemeja mucho a una tortuga, pero quizás este otro sí:

>>> turtle.shape("turtle")

turtle-2

Graciosa, ¿verdad? A un niño le encantaría.

Si ya has dejado atrás tu lado infantil (qué triste es decir eso), puedes restablecer su aspecto nuevamente, más discreto y menos aparatoso:

>>> turtle.shape("classic")

Lo curioso de esta tortuga es que lleva una brocha encima con la que va dejando rastro allá donde se mueve.

Para ilustrar esto, mostremos, por ejemplo, la función forward(), encargada de desplazar la tortuga hacia adelante el número de píxeles que le indiquemos, en el sentido en que apunta la flecha:

>>> turtle.forward(150)

turtle-3

Observa que hemos desplazado la tortuga 150 píxeles a la derecha (que es hacia donde apunta la flecha). En su camino, ha trazado una recta.

Una función similar, backward(), permite a la tortuga andar hacia atrás, de espaldas.

Podemos modificar la dirección en la que apunta. Las funciones left() y right(), respectivamente, giran la tortuga hacia la izquierda o la derecha el ángulo en grados que indiquemos:

>>> turtle.left(120)
>>> turtle.forward(200)

turtle-4

Hemos combinado un giro de 120 grados con un avance de 200 pixeles, provocando el trazado del segundo tramo.

Los giros de left() y right() son siempre relativos, en relación a la orientación actual. Por ejemplo, giremos otros noventa grados a la izquierda y avancemos 50 pixels en esa dirección:

>>> turtle.left(90)
>>> turtle.forward(75)

turtle-5

También podemos indicar el ángulo que forma la tortuga de una manera absoluta, es decir, no relativa a la posición actual. Para ello disponemos de la función setheading():

>>> turtle.setheading(-180)
>>> turtle.forward(100)

turtle-6

Si lo que queremos es desplazar la tortuga a un punto determinado de la ventana, utilizamos la función goto(), a la que facilitamos las coordenadas en píxeles del destino (horizontal, vertical). Ten en cuenta que el punto (0, 0), ubicado en el centro de la ventana, lugar donde se posiciona inicialmente la tortuga, representa el origen de coordenadas:

>>> turtle.goto(-25, 100)

turtle-7

Observa que la tortuga se ha desplazado directamene al punto especificado. Presta atención a la punta de la flecha: continúa apuntando a donde lo hacía antes del último tramo.

Para regresar al lugar de origen puedes hacer un goto(0, 0) o decirle directamente que se marche a casa:

>>> turtle.home()

turtle-8

La función home(), a diferencia de goto(), restablece además el sentido original con el que comenzó la tortuga su andadura.

Si estamos usando turtle para pintar interactivamente un gráfico, hay dos funciones que te vendrán de maravilla:

turtle.undo() deshace la última maniobra efectuada.

turtle.reset() limpia la ventana y restablece la tortuga a su posición de origen.

Para trazar círculos disponemos del comando circle():

>>> turtle.reset()
>>> turtle.circle(100)

turtle-9

Hemos limpiado previamente la ventana, regresando a las condiciones iniciales.

Pintar círculos tiene su pequeño truco. Es importante comprender dónde se localiza el centro de la circunferencia que dibuja la tortuga. Se halla justo al oeste de donde está mirando, es decir, noventa grados a la izquierda, y a una distancia determinada por el radio que indiquemos en la llamada a la función. En el ejemplo, con la tortuga ubicada en (0,0) y mirando exactamente hacia la derecha, es fácil entender que su centro se halla en el punto (0, 100). En ocasiones, según donde esté ubicada y dependiendo de hacia dónde mire, puede ser necesario algún sencillo cálculo trigonométrico si necesitamos determinar el centro.

La tortuguita no nos sería de mucha utilidad práctica si siempre que se moviera estuviera pintando. Necesitamos un modo de lograr que “levante” la brocha de cuando en cuando para poder desplazarla al lugar que deseemos sin emborronar la pantalla.

Para levantar la brocha de la pantalla disponemos de la función penup(). Una vez ejecutada, los movimientos de la tortuga no dejarán trazos en la ventana. Si queremos volver a pintar, basta con bajarla de nuevo con la función pendown().

Observa en el siguiente ejemplo cómo desplazamos la tortuga 100 píxeles, sin el trazo oportuno, antes de dibujar la segunda circunferencia:

>>> turtle.penup()
>>> turtle.forward(100)
>>> turtle.pendown()
>>> turtle.circle(100)

turtle-10

Podemos insertar también textos en nuestro gráfico. La función write(), a la que pasamos una cadena de caracteres, imprime texto en la posición en la que se halla la tortuga, que no se ve afectada por esta impresión, permaneciendo en el mismo lugar:

>>> turtle.reset()
>>> turtle.left(45)
>>> turtle.forward(100)
>>> turtle.write("La casa de la pradera")

turtle-11

Disponemos ya de los conocimientos necesarios para dibujar el círculo de quintas que presentamos al comienzo del artículo. Ejecuta el siguiente programa Python y observa a la tortuga dicharachera trazarlo con gracilidad:

import turtle as t

radio = 150
quintas = ("C", "G", "D", "A", "E", "B",
           "F#/Gb", "Db", "Ab", "Eb", "Bb", "F")
correccion = (20, 20, 21, 25, 29, 31,
              31, 36, 33, 31, 25, 20)

t.penup()
t.goto(0, -radio) # para que el círculo quede centrado en (0, 0)
t.pendown()
t.circle(radio)
t.penup()
t.goto(0, 0) # regresamos al centro
t.left(90)
t.pendown()

for quinta in range(12):
    t.forward(radio)
    t.penup()
    t.forward(correccion[quinta]) # separamos del círculo el punto de escritura
    t.write(quintas[quinta], font=("Arial", 10, "bold")) # negrita
    t.goto(0, 0)
    t.right(30) # giramos 30 grados (360 dividido entre 12)
    t.pendown()

t.hideturtle() #para que no se vea la tortuga en la imagen final

El primer bloque de código, justo debajo de la declaración de las tuplas, simplemente traza una circunferencia centrada en el origen de coordenadas y deja la tortuga mirando al norte.

El bucle for se ocupa, en cada iteración, de trazar cada radio, escribir la nota correspondiente, regresar al origen y girar 30 grados, dejando la tortuga en la orientación oportuna para el dibujo de otro radio en la siguiente iteración.

Las tupla quintas contiene todas las notas musicales ordenadas por quintas justas, en la secuencia en la que deberán ser pintadas por la tortuga en cada iteración. La tupla correccion no es más que una separación adicional para que el texto de cada nota quede decentemente separado del círculo a una distancia visualmente parecida. Inicialmente partí de 20 píxeles para todas las notas, reajustando a simple vista después una a una para obtener una mejor presentación. Observa también un uso más avanzado de la función write(), indicando, además del texto, las características del tipo de letra (familia, tamaño y aspecto).

Finalmente, escondemos la tortuga para poder realizar una captura de pantalla sin que aparezca incordiando entre medias.

Esta ha sido sólo una pequeña introducción a la tortuga de Python. En otros artículos exploraremos otras funciones que nos permitirán nuevas posibilidades creativas. Que no te confunda su sencillez y aspecto lúdico: puedes dibujar con ella virtualmente cualquier cosa y, con los algoritmos adecuados, puedes realizar gráficos sumamente sofisticados con muy poco código.

Javier Montero Gabarró


Python – Una tortuga de brocha fina


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Consulta el índice completo de artículos relacionados con Python.

2 opiniones en “Python – Una tortuga de brocha fina”

Deja un comentario