El tutorial simple de Turtle para el módulo turtle.py de Python

• 🇺🇸 🇬🇧 English / Inglés Translation

Una guía de programación para estudiantes y sus padres, profesores e instructores.

Este es un tutorial de programación con Tortuga escrito por Al Sweigart, autor de Automate the Boring Stuff with Python y otros libros de programación. Puedes leer todos sus libros de forma gratuita en https://inventwithpython.com.

Este tutorial fue originalmente escrito en inglés y traducido al español. Los enlaces externos corresponden a recursos en inglés. Si tienes correcciones para este tutorial, por favor envía un correo a [email protected].

Tabla de Contenidos

1. Introducción
2. Dibujo de un cuadrado
3. Dibujo de un cuadrado más pequeño
4. Errores comunes y mensajes de error
5. Dibujar un cuadrado con un bucle
6. Revisión rápida 1
7. Ejercicios de práctica 1
8. Escribir texto en la ventana de Tortuga
9. Ángulos
10. Coordenadas cartesianas XY
11. Inicio, borrar, reiniciar, deshacer
12. Revisión rápida 2
13. Ejercicios de práctica 2
14. Colores
15. Levantar y bajar la pluma
16. Ejemplos de espirales cuadrados
17. Dibujar muy rápido
18. Dibujo interactivo
19. Dibujar curvas y círculos
20. Programa Flores Azules
21. Formas rellenas
22. Para más información
23. Desafíos avanzados de Tortuga
24. Soluciones
25. Contactar al autor
26. Lista de URLs del sitio web en este tutorial

Los gráficos de Tortuga son una manera fácil de aprender programación dibujando con código. Programas una pluma virtual, llamada tortuga, para que se mueva por la pantalla y trace líneas. Haces dibujos con la computadora mientras aprendes a programar. Puedes pensar en la tortuga como un Etch A Sketch controlado por tu programa de Python.

Esta guía explica cómo usar el módulo turtle de Python a través del paquete Tortuga. No enseña el lenguaje Python en sí. Es bueno ya conocer ideas básicas de Python, como variables, operadores, bucles, funciones, importación de módulos y números aleatorios. El libro gratuito Automate the Boring Stuff with Python en https://automatetheboringstuff.com/ es una introducción para principiantes completos. Si te interesa más programar videojuegos, puedes leer Invent Your Own Computer Games with Python en https://inventwithpython.com.

Antes de comenzar, necesitas descargar e instalar el intérprete de Python (el software que ejecuta el código Python) desde https://python.org. Hay una guía para instalar Python en el sitio Real Python, en https://realpython.com/installing-python/.

También necesitas instalar un editor de código como:

• IDLE, que viene con el intérprete de Python.
• Mu, gratuito en https://codewith.mu/.
• Visual Studio Code, gratuito en https://code.visualstudio.com/download.

Hay una guía para usar IDLE en Real Python, en https://realpython.com/python-idle/.

Los programas escritos en Python se llaman programas Python. No todos usan gráficos de Tortuga. Pero en esta guía, llamaremos programas Tortuga a los que usan el módulo turtle (a través de Tortuga).

Aunque no sepas programar en Python, puedes copiar el código de este tutorial en tu editor y ejecutarlo.

Nota para las versiones de este tutorial que no están en inglés: El lenguaje de programación Python incluye el paquete turtle. Sin embargo, el código del paquete turtle está en inglés. El paquete tortuga proporciona código traducido a varios idiomas. Para instalar el paquete tortuga, ejecuta el siguiente código desde el intérprete interactivo de Python, también llamado REPL. El intérprete interactivo muestra el prompt >>> o In [1]:.

import sys, subprocess; subprocess.run([sys.executable, '-m', 'pip', 'install', 'tortuga'])

Para verificar si tortuga se instaló correctamente, ejecuta el siguiente código desde el intérprete interactivo:

from tortuga import *

Si no aparece nada, entonces tortuga se instaló correctamente.

Las palabras clave y los mensajes de error del lenguaje de programación Python siguen en inglés. Puedes usar https://translate.google.com/ para traducirlos. La versión original en inglés de este tutorial está en https://inventwithpython.com/stt/

# primer_cuadrado.py

# Esto es un comentario.
# Todo lo que esté después de # es un "comentario" y no se ejecuta como código.
# Usa comentarios para hacer anotaciones sobre tu código.

from tortuga import *

tamano_pluma(4)  # Haz que las líneas sean más gruesas de lo normal.

adelante(200)  # Mueve la tortuga adelante 200 pasos.
izquierda(90)  # Gira la tortuga a la izquierda 90 grados.

# Avanza y gira tres veces más:
adelante(200)
izquierda(90)
adelante(200)
izquierda(90)
adelante(200)
izquierda(90)

hecho()  # Sin esto, la ventana de Tortuga podría cerrarse antes de que veas el dibujo.

En la ventana Tortuga, la tortuga aparece como un triángulo. Imagina que la tortuga lleva una pluma en la boca y dibuja líneas al moverse. El código Python le indica cómo moverse:

1. Avanza 200 pasos. (Al iniciar, la tortuga mira hacia la derecha.)
2. Gira 90 grados a la izquierda.
3. Avanza 200 pasos.
4. Gira 90 grados a la izquierda.
5. Avanza 200 pasos.
6. Gira 90 grados a la izquierda.
7. Avanza 200 pasos. (La tortuga vuelve al punto de partida.)
8. Gira 90 grados a la izquierda. (Queda en la dirección original.)
9. El programa termina, pero la ventana Tortuga sigue abierta para que veas el resultado.

Con estos nueve pasos, la tortuga dibuja un cuadrado. Esto es lo básico de cada instrucción:

# primer_cuadrado.py

# Esto es un comentario.
# Todo lo que esté después de # es un "comentario" y no se ejecuta como código.
# Usa comentarios para hacer anotaciones sobre tu código.

La línea # primer_cuadrado.py es un comentario que Python ignora. No es necesario copiarlo; solo identifica el nombre del programa en este tutorial.

Las líneas en blanco también se ignoran.

from tortuga import *

Debes tener from tortuga import * al inicio de tus programas Tortuga. Esto importa todas las funciones de Tortuga para que puedas usar llamadas como tamano_pluma(), adelante(), izquierda() y hecho(). Si olvidas esta línea, tu programa fallará con un error NameError: name '...' is not defined.

tamano_pluma(4)  # Haz que las líneas sean más gruesas de lo normal.

pensize es una función y pensize(4) es una llamada a la función. Una función es como un mini-programa que contiene código. Tu programa puede ejecutar el código de las funciones realizando una llamada a la función. Las llamadas a funciones pueden recibir valores, como el 4 en pensize(4). Estos se llaman argumentos de función o simplemente argumentos.

En este tutorial, siempre añadimos paréntesis al nombre de una función para que sea fácil ver que es una función: “la función pensize()”

adelante(200)  # Mueve la tortuga adelante 200 pasos.
izquierda(90)  # Gira la tortuga a la izquierda 90 grados.

# Avanza y gira tres veces más:
adelante(200)
izquierda(90)
adelante(200)
izquierda(90)
adelante(200)
izquierda(90)

La llamada adelante(200) hace que la tortuga se mueva hacia adelante en su dirección actual por 100 pasos. Mientras la tortuga se mueve, dibuja una línea detrás de ella. Imagina una tortuga con un marcador negro en la boca, dibujando líneas en el suelo mientras avanza.

La función izquierda() hace que la tortuga gire su dirección hacia la izquierda. Imagina que estamos en el cielo mirando hacia abajo a la tortuga en la ventana del programa. La izquierda de la tortuga es en sentido contrario a las agujas del reloj. La llamada izquierda(90) en nuestro programa hace que la tortuga gire 90 grados a la izquierda.

(Si quieres que la tortuga gire a la derecha o en sentido horario, también existe la función derecha().)

hecho()  # Sin esto, la ventana de Tortuga podría cerrarse antes de que veas el dibujo.

La función hecho() mantiene el programa en ejecución hasta que cierres la ventana. Sin ella, Python terminaría el programa y cerraría la ventana al instante.

La llamada a la función hecho() no tiene argumentos, pero todavía debes escribir los paréntesis () después de hecho.

Hay muchas otras funciones como izquierda(), adelante() y hecho(). A medida que aprendas más funciones del módulo turtle, podrás dibujar formas y figuras cada vez más complejas.

Pero primero, hagamos algunos programas Tortuga más sencillos.

# cuadrado_mas_pequeno.py
from tortuga import *

tamano_pluma(4)  # Haz que las líneas sean más gruesas de lo normal.

adelante(25)  # Ahora la tortuga avanza solo 25 pasos.
izquierda(90)
adelante(25)
izquierda(90)
adelante(25)
izquierda(90)
adelante(25)
izquierda(90)

hecho()  # Sin esto, la ventana de Tortuga podría cerrarse antes de que veas el dibujo.

Recuerda que debes cambiar las cuatro llamadas de adelante(200) a adelante(25), o el cuadrado saldrá mal. Por ejemplo, creé un programa llamado cuadrado_mas_pequeno_error.py que solo cambió tres de ellas:

# cuadrado_mas_pequeno_error.py
from tortuga import *

tamano_pluma(4)
adelante(25)
izquierda(90)
adelante(25)
izquierda(90)
adelante(200)  # ¡Ups, olvidamos cambiar esta línea!
izquierda(90)
adelante(25)
izquierda(90)

hecho()

Este programa tiene un bug y dibuja el cuadrado incorrectamente:

¡Está bien cometer errores! Puedes corregirlos. Tu computadora hace exactamente lo que le indicas. Está en ti asegurarte de que lo que quieres que haga sea lo que le dices que haga.

# cuadrado_variable.py
from tortuga import *

tamano_pluma(4)
longitud_linea = 25  # Esta variable almacena el número 25.
adelante(longitud_linea)  # La tortuga avanza 25 pasos.
izquierda(90)
adelante(longitud_linea)
izquierda(90)
adelante(longitud_linea)
izquierda(90)
adelante(longitud_linea)
izquierda(90)

hecho()

Ahora, para cambiar el tamaño solo necesitas modificar longitud_linea, por ejemplo longitud_linea = 300 o longitud_linea = 5.

# cuadrado_con_bucle.py
from tortuga import *

tamano_pluma(4)

# Las líneas con sangría se ejecutan 4 veces:
for i in range(4):
    adelante(200)
    izquierda(90)
hecho()

for i in range(4):
....adelante(200)
....izquierda(90)
hecho()

Nuestro programa solo necesita llamar a tamano_pluma(4) una vez, por eso lo ponemos antes del bucle.

Cambiemos izquierda(90) por izquierda(86). Crea un archivo nuevo. Guárdalo como cuadrado_bucle_86.py. Escribe:

# cuadrado_bucle_86.py
from tortuga import *

tamano_pluma(4)

for i in range(4):
    adelante(200)
    izquierda(86)  # Gira 86 grados en lugar de 90.
hecho()

Esto dibuja una figura distinta, no un cuadrado perfecto:

Bucle de 50 iteraciones

En lugar de 4, hagamos el bucle 50 veces. Crea un archivo nuevo. Guárdalo como circulo_cuadrado_86.py. Escribe:

# circulo_cuadrado_86.py
from tortuga import *

tamano_pluma(4)
velocidad('mas rapida')  # Hace que la tortuga se mueva más rápido.

for i in range(50):  # 50 iteraciones en vez de 4.
    adelante(200)
    izquierda(86)
ocultar_tortuga()  # Oculta el cursor de la tortuga al final.
hecho()

En este programa llamamos a velocidad() con la cadena 'mas rapida'. A diferencia de 200 o 86, este valor es texto y debe ir entre comillas: 'mas rapida' o "mas rapida".

Los argumentos que puedes pasar a velocidad() son, de más rápido a más lento: 'mas rapida', 'rapida', 'normal', 'lenta' y 'mas lenta'.

Este programa también usa ocultar_tortuga() para hacer desaparecer el cursor.

El resultado es muy diferente de un cuadrado simple:

Al experimentar con distintos números podemos crear todo tipo de dibujos. También podemos usar números aleatorios para los giros. Hagamos un programa que dibuje un cuadrado con giros entre 80 y 100 grados. Crea un archivo nuevo. Guárdalo como cuadrado_aleatorio.py. Escribe:

# cuadrado_aleatorio.py
from tortuga import *
from random import *

tamano_pluma(4)
velocidad('mas rapida')

for i in range(50):
    adelante(200)
    # Gira a la izquierda un número aleatorio de grados entre 80 y 100:
    izquierda(randint(80, 100))
ocultar_tortuga()
hecho()

Como este programa usa números aleatorios, la imagen será diferente cada vez:

La instrucción from random import * permite usar la función randint(), que devuelve un entero aleatorio. La llamada izquierda(randint(80, 100)) gira la tortuga aleatoriamente entre 80 y 100 grados.

Cuando nuestro programa combina bucles y números aleatorios, podemos crear "arte generativo". No hacemos el arte nosotros mismos, sino los programas que lo generan. Busca en Internet "generative art" para ver ejemplos. ¡Hay muchísimas imágenes que podemos aprender a dibujar con Tortuga!

# Esto es un comentario.

from tortuga import *

adelante(100)    # Mueve la tortuga 100 pasos hacia adelante.
atras(100)       # Mueve la tortuga 100 pasos hacia atrás.
adelante(-100)   # Mueve la tortuga 100 pasos hacia atrás.

izquierda(90)    # Gira 90 grados a la izquierda.
derecha(45)      # Gira 45 grados a la derecha.

tamano_pluma(4)

hecho()

longitud_linea = 25   # Esta variable almacena el número 25.
adelante(longitud_linea)

for i in range(4):
    adelante(200)
    izquierda(90)

velocidad('mas rapida')

ocultar_tortuga()

from random import *
adelante(randint(1, 100))

Crea un programa llamado solucion_pentagono.py que dibuje esta imagen. Pista: Todas las líneas del pentágono miden 200 pasos. Todos los giros son de 72 grados.

Crea un programa llamado solucion_hexagono.py que dibuje esta imagen. Pista: Todas las líneas del hexágono miden 200 pasos. Todos los giros son de 60 grados.

Crea un programa llamado solucion_octagono.py que dibuje esta imagen. Pista: Todas las líneas del octágono miden 100 pasos. Todos los giros son de 45 grados.

Crea un programa llamado solucion_triangulo_rectangulo.py que dibuje esta imagen. Pista: Un giro es de 90 grados y el otro de 135 grados. Dos lados miden 200 pasos. Según el Teorema de Pitágoras, el tercer lado mide 282.8 pasos.

Crea un programa llamado solucion_estrella.py que dibuje esta imagen. Pista: Todas las líneas de la estrella miden 200 pasos. Todos los giros son de 144 grados.

Crea un programa llamado solucion_cuadrados_anidados.py que dibuje esta imagen. Pista: Dibuja cuadrados de lados 100, luego 150, 200, 250 y 300 pasos. Puedes usar un for dentro de otro for.

Crea un programa llamado solucion_cruz.py que dibuje esta imagen. Pista: Todas las líneas de la cruz miden 100 pasos. Todos los giros son de 90 grados, alternando giros a la izquierda y a la derecha.

Crea un programa llamado solucion_cubo.py que dibuje esta imagen. Pista: Todas las líneas miden 100 pasos. Los giros son de 45, 90 o 135 grados. Puede que necesites superponer líneas usando adelante(100) y luego atras(100) para volver al punto inicial.

Crea un programa llamado solucion_trifuerza.py que dibuje esta imagen. Pista: Los giros son de 60 o 120 grados. Si el triángulo exterior tiene lados de 100 pasos, a veces querrás avanzar 50 pasos en su interior.

# escribir_hola.py

from tortuga import *

escribir('¡Hola, mundo!')
adelante(80)
derecha(45)
adelante(50)
escribir('123456789', fuente=('Arial', 48, 'normal'))
derecha(45)
adelante(30)
escribir('oOoOoOoOoOo')
hecho()

La esquina inferior izquierda del texto coincide con la posición de la tortuga. Por ejemplo, escribir('¡Hola, mundo!') aparece en el centro de la ventana, donde inicia la tortuga. Luego la tortuga avanza y gira con adelante(80), derecha(45) y adelante(50). Cuando se ejecuta escribir('123456789', fuente=('Arial', 48, 'normal')), el texto “123456789” aparece en la nueva posición de la tortuga.

La llamada escribir('123456789', fuente=('Arial', 48, 'normal')) también usa un parámetro con nombre fuente=. Podemos pasarle una tupla como ('Arial', 48, 'normal') para cambiar la tipografía del texto.

Hay tres partes en el argumento de fuente=:

• El nombre de la tipografía. ('Arial')
• El tamaño de la tipografía. (48)
• El estilo de la tipografía. ('normal')

Si no pasas este argumento, la tipografía predeterminada es ('Arial', 8, 'normal'). Puedes cambiar el nombre de la tipografía siempre que esté instalada en tu sistema. El tamaño debe ser un número (sin comillas). El estilo puede ser 'normal', 'negrita', 'cursiva', 'subrayada' o cualquier combinación como 'negrita cursiva'.

# direcciones_tortuga.py
from tortuga import *

for i in range(24):
    adelante(200)  # Avanza en la dirección actual.
    escribir(direccion(), fuente=('Arial', 12, 'normal'))  # Escribe los grados de orientación.
    atras(200)     # Regresa al centro.
    izquierda(15)  # Gira 15 grados a la izquierda y repite.
hecho()

Las funciones izquierda() y derecha() giran según la orientación actual. Si la tortuga mira a 45 grados y llamas izquierda(90), pasará a 135 grados (45 + 90). Sin embargo, la función establecer_direccion() fija la tortuga a la orientación indicada, sin importar su estado previo.

Por ejemplo, crea un programa llamado establecer_direccion_tortuga.py con este código:

# establecer_direccion_tortuga.py

from tortuga import *
from random import *

tamano_pluma(4)
izquierda(randint(0, 360))
escribir(direccion(), fuente=('Arial', 48, 'normal'))
adelante(200)

establecer_direccion(45)
escribir(direccion(), fuente=('Arial', 48, 'normal'))
adelante(200)

hecho()

Al ejecutarlo, la tortuga gira a un ángulo aleatorio, escribe ese valor (grados) en pantalla y avanza 200 pasos. Luego establecer_direccion(45) fija la orientación a 45 grados, de modo que la segunda llamada a escribir(direccion()) siempre muestra “45.0”. La tortuga apunta hacia la esquina superior derecha y avanza otros 200 pasos en esa dirección.

Así, sin importar la orientación inicial, establecer_direccion(45) hace que la tortuga mire siempre hacia arriba a la derecha. Si ejecutas varias veces, verás algo como esto:

Hagamos un programa que escriba las coordenadas XY en la ventana a medida que la tortuga se mueve. Crea un archivo nuevo en tu editor de código. Guárdalo como posicion_aleatoria.py. Introduce el siguiente código Python:

# posicion_aleatoria.py
from tortuga import *
from random import *

for i in range(8):
    escribir(posicion(), fuente=('Arial', 18, 'normal'))
    izquierda(randint(0, 90))
    adelante(100)

hecho()

Al ejecutar este programa, verás algo como esto:

La tortuga comienza en el origen, es decir, en las coordenadas 0, 0. Observa que al moverse a la derecha o arriba, X e Y aumentan; al moverse a la izquierda o abajo, disminuyen.

Las funciones adelante() y atras() siempre mueven desde la posición actual. Sin embargo, puedes llevar la tortuga a coordenadas específicas con ir_a(x, y) pasando los valores X e Y.

Hagamos ahora un programa que mueva la tortuga a coordenadas aleatorias. Crea un archivo nuevo. Guárdalo como ir_aleatorio.py. Introduce el siguiente código Python:

# ir_aleatorio.py
from tortuga import *
from random import *

tamano_pluma(4)

for i in range(6):
    x = randint(-400, 400)
    y = randint(-400, 400)
    ir_a(x, y)
    escribir(posicion(), fuente=('Arial', 18, 'normal'))

hecho()

Al ejecutar este programa, verás algo como esto:

La instrucción x = randint(-400, 400) guarda un número entero aleatorio entre –400 y 400 en la variable x, y y = randint(-400, 400) hace lo mismo para y. Luego, ir_a(x, y) lleva la tortuga a esas coordenadas.

::contentReference[oaicite:0]{index=0}

Colores

Puedes cambiar el color de fondo de la ventana con la función color_pluma() y pasarle uno de estos nombres de color (o su valor RGB si prefieres):

• 'negro' es (0.0, 0.0, 0.0)
• 'azul' es (0.0, 0.0, 1.0)
• 'marron' es (0.6, 0.4, 0.2)
• 'naranja' es (1.0, 0.5, 0.0)
• 'gris' es (0.5, 0.5, 0.5)
• 'verde' es (0.0, 1.0, 0.0)
• 'morado' es (0.5, 0.0, 0.5)
• 'violeta' es (0.56, 0.0, 1.0)
• 'rosa' es (1.0, 0.75, 0.8)
• 'amarillo' es (1.0, 1.0, 0.0)
• 'blanco' es (1.0, 1.0, 1.0)
• 'rojo' es (1.0, 0.0, 0.0)
• 'magenta' es (1.0, 0.0, 1.0)
• 'cian' es (0.0, 1.0, 1.0)
• Un color aleatorio es (random(), random(), random()) (tras from random import *)

Para cambiar el color de las líneas de la tortuga, usa color_pluma() de la misma manera.

Por ejemplo, agregando color_pluma('amarillo') y color_pluma('azul') al programa circulo_cuadrado_86.py:

Los colores personalizados usan un valor RGB (rojo, verde, azul) con cada componente entre 0.0 (ninguno) y 1.0 (máximo). Por ejemplo, (1.0, 0.0, 0.0) equivale a 'rojo', y (1.0, 1.0, 0.0) a 'amarillo'. Ajusta los valores para obtener tonos más claros o más oscuros.

Puedes usar el programa Turtle Colors para explorar valores RGB. Descárgalo desde https://invpy.com/stt/turtlecolors.py y ejecútalo. Ajusta los tres deslizadores de rojo, verde y azul para ver el color resultante.

# lineas_punteadas.py
from tortuga import *
from random import *

tamano_pluma(4)
velocidad('mas rapida')

for i in range(12):
    # Apunta en una dirección aleatoria:
    establecer_direccion(randint(0, 360))

    # Dibuja una línea punteada:
    for j in range(6):
        pluma_abajo()
        adelante(10)   # Dibuja un segmento.
        pluma_arriba()
        adelante(10)   # Avanza sin dibujar.

    # Último segmento:
    pluma_abajo()
    adelante(10)

hecho()

# espiral.py
from tortuga import *

velocidad('mas rapida')
for i in range(300):
    adelante(i)   # Usa la variable i como argumento de la función.
    izquierda(91)
ocultar_tortuga()
hecho()

En nuestros programas anteriores con bucles for, habíamos ignorado la variable i. Pero en este programa, la usamos en la instrucción adelante(i).

En este bucle, la variable i toma el valor 0 en la primera iteración, de modo que adelante(i) equivale a adelante(0). La siguiente vez, i vale 1 y adelante(i) equivale a adelante(1). El bucle sigue aumentando i, haciendo que la tortuga dibuje líneas cada vez más largas.

La variable i recorre los valores desde 0 hasta 299 (porque escribimos for i in range(300):). Por tanto, en la última iteración, i vale 299.

Esto hace que nuestro programa sea equivalente a:

from tortuga import *

velocidad('mas rapida')

adelante(0)
izquierda(91)
adelante(1)
izquierda(91)
adelante(2)
izquierda(91)
adelante(3)
izquierda(91)
adelante(4)
izquierda(91)

# ... muchas más iteraciones ...

adelante(297)
izquierda(91)
adelante(298)
izquierda(91)
adelante(299)
izquierda(91)

ocultar_tortuga()
hecho()

¡Usar el bucle for nos ahorra muchísimo tecleo!

Prueba cambiar el 91 en izquierda(91) por otros números entre 30 y 180, y vuelve a ejecutar el programa para ver cómo cambia la figura.

A continuación, creemos una espiral colorida aleatoria. Crea un archivo nuevo. Guárdalo como espiral_fondo_negro.py. Introduce:

# espiral_fondo_negro.py
from tortuga import *
from random import *

colores = ['rojo', 'naranja', 'amarillo', 'azul', 'verde', 'morado']

velocidad('mas rapida')
tamano_pluma(3)
color_fondo('negro')
for i in range(300):
    color_pluma(choice(colores))
    adelante(i)
    izquierda(91)
ocultar_tortuga()
hecho()

Al ejecutar este programa, se ve así:

Podemos dibujar una espiral con los colores del arcoíris usando este código. Crea un archivo nuevo. Guárdalo como espiral_arcoiris.py. Introduce:

# espiral_arcoiris.py
from tortuga import *

velocidad('mas rapida')
tamano_pluma(3)
color_fondo('negro')

color_pluma('rojo')
for i in range(60):
    adelante(i)
    izquierda(91)

color_pluma('naranja')
for i in range(60):
    adelante(60 + i)
    izquierda(91)

color_pluma('amarillo')
for i in range(60):
    adelante(120 + i)
    izquierda(91)

color_pluma('verde')
for i in range(60):
    adelante(180 + i)
    izquierda(91)

color_pluma('azul')
for i in range(60):
    adelante(240 + i)
    izquierda(91)

color_pluma('morado')
for i in range(60):
    adelante(300 + i)
    izquierda(91)

hecho()

Al ejecutar este programa, se ve así:

# ruta_curva.py

from tortuga import *
from random import *

tasa_dibujo(4, 0)

for i in range(100):  # Dibuja 100 trayectorias curvas.
    # Mover la tortuga de regreso al origen (0, 0):
    pluma_arriba()
    origen()
    pluma_abajo()

    # Fijar un ángulo aleatorio y dibujar varias líneas cortas con cambio de dirección:
    establecer_direccion(randint(0, 360))
    for j in range(randint(200, 600)):  # Cada curva tiene de 200 a 600 segmentos.
        adelante(1)         # Cada segmento mide 1 paso.
        izquierda(randint(-4, 4))  # Cambia ligeramente la dirección

actualizar()
hecho()

# dibujar_circulos.py
from tortuga import *

velocidad('mas rapida')

# Dibujar círculos en la mitad superior de la ventana:
establecer_direccion(0)  # Mirar hacia la derecha.
for i in range(20):
    circulo(i * 10)

# Dibujar círculos en la mitad inferior de la ventana:
establecer_direccion(180)  # Mirar hacia la izquierda.
for i in range(20):
    circulo(i * 10)

hecho()

# dibujar_muchos_circulos.py
from tortuga import *

velocidad('mas rapida')

for j in range(6):
    establecer_direccion(j)
    for i in range(20):
        circulo(i * 10)

    establecer_direccion(j + 120)
    for i in range(20):
        circulo(i * 10)

    establecer_direccion(j + 240)
    for i in range(20):
        circulo(i * 10)

hecho()

# flores_azules.py
from tortuga import *
from random import *

tasa_dibujo(100, 0)

for n in range(50):
    # Mover a una posición aleatoria:
    pluma_arriba()
    x = randint(-300, 300)
    y = randint(-300, 300)
    ir_a(x, y)
    pluma_abajo()

    # Crear un tono de azul aleatorio:
    color_pluma((0, 0, random()))

    # Grosor de pluma aleatorio:
    tamano_pluma(randint(1, 5))

    # Tamaño aleatorio para los círculos:
    tamano_circulo = randint(10, 40)

    # Dibujar seis círculos:
    for i in range(6):
        circulo(tamano_circulo)
        izquierda(60)

actualizar()
hecho()

# cuadrado_relleno.py

from tortuga import *

tamano_pluma(4)

color_relleno('azul')

comenzar_rellenar()
for i in range(4):
    adelante(200)
    izquierda(90)
terminar_relleno()

hecho()

# cuadrados_coloridos.py

from tortuga import *
from random import *

tamano_pluma(4)
tasa_dibujo(10, 0)

for i in range(100):  # Dibuja 100 cuadrados.
    # Mover a un lugar aleatorio:
    pluma_arriba()
    ir_a(randint(-400, 200), randint(-400, 200))
    pluma_abajo()

    # Colores de relleno y de pluma aleatorios:
    color_relleno((random(), random(), random()))
    color_pluma((random(), random(), random()))

    # Tamaño del cuadrado aleatorio:
    longitud_linea = randint(20, 200)

    # Dibujar el cuadrado relleno:
    comenzar_rellenar()
    for j in range(4):
        adelante(longitud_linea)
        izquierda(90)
    terminar_relleno()

hecho()

# ruta_curva_rellena.py

from tortuga import *
from random import *

tasa_dibujo(4, 0)

for i in range(50):
    # Color de relleno aleatorio:
    color_relleno((random(), random(), random()))

    # Definir un ángulo aleatorio y dibujar varias líneas cortas:
    establecer_direccion(randint(0, 360))
    comenzar_rellenar()
    for j in range(randint(200, 600)):
        adelante(1)
        izquierda(randint(-4, 4))
    origen()
    terminar_relleno()

actualizar()
hecho()

• La documentación oficial del módulo Turtle en https://docs.python.org/3/library/turtle.html
• La lista de métodos de Tortuga en la documentación oficial en https://docs.python.org/3/library/turtle.html#turtle-methods
• Capítulo 9 de The Recursive Book of Recursion, con dibujos recursivos de Tortuga en https://inventwithpython.com/recursion/chapter9.html
• Capítulo 13 de The Recursive Book of Recursion, con un programa fractal recursivo en https://inventwithpython.com/recursion/chapter13.html
• Charla en PyCon US 2023: The Creative Art of Algorithmic Embroidery (Marie Roald, Yngve Mardal Moe) en https://www.youtube.com/watch?v=OcuhrDIrblo

Python también incluye el programa turtledemo que ofrece muchos más ejemplos. Crea un programa con este código:

import turtledemo.__main__
turtledemo.__main__.main()

Al ejecutarlo, verás un menú para seleccionar uno de los ejemplos. Haz clic en Start para ejecutarlo. El código fuente aparece en el lado izquierdo de la ventana. Este es el programa de ejemplo Peace:

¡Buena suerte en tu viaje de programación!

Si buscas formas realmente desafiantes para tus programas de Tortuga, echa un vistazo a los dibujos de Oscar Reutersvärd en el sitio Impossible World: https://im-possible.info/english/library/. También puedes buscar en internet “Oscar Reutersvärd” para ver ejemplos de su arte.

Algunos ejemplos:

# solucion_triangulo_equilatero.py
from tortuga import *
tamano_pluma(4)

derecha(60)
adelante(200)

derecha(120)
adelante(200)

derecha(120)
adelante(200)

hecho()

# solucion_pentagono.py
from tortuga import *
tamano_pluma(4)

izquierda(72)
adelante(200)

izquierda(72)
adelante(200)

izquierda(72)
adelante(200)

izquierda(72)
adelante(200)

izquierda(72)
adelante(200)

# O puedes usar:
# for i in range(5):
#     izquierda(72)
#     adelante(200)
hecho()

# solucion_hexagono.py
from tortuga import *
tamano_pluma(4)

for i in range(6):
    izquierda(60)
    adelante(200)

hecho()

# solucion_octagono.py
from tortuga import *
tamano_pluma(4)

for i in range(8):
    izquierda(45)
    adelante(100)

hecho()

# solucion_triangulo_rectangulo.py
from tortuga import *
tamano_pluma(4)

adelante(200)
derecha(90)
adelante(200)
derecha(135)
adelante(282.8)

hecho()

# solucion_estrella.py
from tortuga import *
tamano_pluma(4)

for i in range(5):
    derecha(144)
    adelante(300)

hecho()

# solucion_cuadrados_anidados.py
from tortuga import *
tamano_pluma(4)

longitud_linea = 100
for i in range(4):
    adelante(longitud_linea)
    izquierda(90)

longitud_linea = 150
for i in range(4):
    adelante(longitud_linea)
    izquierda(90)

longitud_linea = 200
for i in range(4):
    adelante(longitud_linea)
    izquierda(90)

longitud_linea = 250
for i in range(4):
    adelante(longitud_linea)
    izquierda(90)

longitud_linea = 300
for i in range(4):
    adelante(longitud_linea)
    izquierda(90)

# O puedes usar:
# for longitud_linea in range(100, 350, 50):
#     for i in range(4):
#         adelante(longitud_linea)
#         izquierda(90)
hecho()

# solucion_cruz.py
from tortuga import *
tamano_pluma(4)

for i in range(4):
    adelante(100)
    derecha(90)

    adelante(100)
    derecha(90)

    adelante(100)
    izquierda(90)

hecho()

# solucion_cubo.py
from tortuga import *
tamano_pluma(4)

# Cuadrado frontal:
for i in range(4):
    adelante(200)
    derecha(90)

# Diagonal superior izquierda:
izquierda(45)
adelante(200)
derecha(45)

# Lado superior del cuadrado trasero:
adelante(200)
derecha(135)
adelante(200)
atras(200)
izquierda(45)

# Lado derecho del cuadrado trasero:
adelante(200)
derecha(45)
adelante(200)
atras(200)
derecha(45)

# Lado inferior del cuadrado trasero:
adelante(200)
izquierda(45)
adelante(200)
atras(200)

# Lado izquierdo del cuadrado trasero:
derecha(135)
adelante(200)

hecho()

# solucion_triforce.py
from tortuga import *
tamano_pluma(4)

derecha(60)
adelante(400)

derecha(120)
adelante(400)

derecha(120)
adelante(400)

derecha(120)
adelante(200)

derecha(60)
adelante(200)

derecha(120)
adelante(200)

derecha(120)
adelante(200)

hecho()

# solucion_contorno_estrella.py
from tortuga import *
tamano_pluma(4)

pluma_arriba()
ir_a(0, 300)

pluma_abajo()
ir_a(70, 95)
ir_a(285, 95)
ir_a(110, -35)
ir_a(175, -260)
ir_a(0, -100)
ir_a(-175, -260)
ir_a(-110, -35)
ir_a(-285, 95)
ir_a(-70, 95)
ir_a(0, 300)

hecho()

# solucion_cruz_establecer_direccion.py
from tortuga import *
tamano_pluma(4)

# Saliente derecha:
establecer_direccion(0)
adelante(100)
establecer_direccion(270)
adelante(100)
establecer_direccion(180)
adelante(100)

# Saliente inferior:
establecer_direccion(270)
adelante(100)
establecer_direccion(180)
adelante(100)
establecer_direccion(90)
adelante(100)

# Saliente izquierda:
establecer_direccion(180)
adelante(100)
establecer_direccion(90)
adelante(100)
establecer_direccion(0)
adelante(100)

# Saliente superior:
establecer_direccion(90)
adelante(100)
establecer_direccion(0)
adelante(100)
establecer_direccion(270)
adelante(100)

hecho()

# solucion_saludo_aleatorio.py
from tortuga import *
from random import *

tasa_dibujo(1000, 0)
pluma_arriba()
ocultar_tortuga()

for i in range(100):
    ir_a(randint(-400, 400), randint(-400, 400))
    escribir('Hello, world!', fuente=('Arial', randint(12, 48), 'normal'))

update()
hecho()