La “tortuga” es un concepto que surgió hace varias décadas para enseñar elementos básicos de programación, especialmente a los niños (aunque es también muy buen punto de inicio para los adultos). Básicamente, el usuario ve una “tortuga” en pantalla que permite dibujar gráficos siguiendo un algoritmo.

En Python, el módulo “turtle” ya viene incorporado con la instalación básica (es decir que no es necesario agregar nada). Entonces, es posible usar las estructuras que se usan normalmente en Python, agregándoles las instrucciones específicas de Turtle. Para poder agregar estas instrucciones, debemos escribir from turtle import * al principio del programa.

La tortuga en Python siempre empieza “mirando” hacia la derecha y, a medida que camina, deja una línea dibujada. Si se la hace caminar hacia adelante, empezará haciendo una línea de izquierda a derecha.

Algunas órdenes básicas de Turtle (hay muchas más):

forward(x)	Caminar hacia adelante (la cantidad de pixeles indicada en el número x)
backward(x)	Caminar hacia atrás (la cantidad de pixeles indicada en el número x)
right(x)	Girar la tortuga hacia la derecha en un ángulo de x grados
left(x)	Girar la tortuga hacia la izquierda en un ángulo de x grados
begin_fill()	Las figuras cerradas dibujadas a continuación serán pintadas con un color x especificado por fillcolor(x)
end_fill()	Pinta todas las figuras cerradas que se hayan dibujado a partir de donde dice begin_fill() y hasta donde se coloca end_fill()
fillcolor(x)	Rellena, con el color indicado en el string x, la figura dibujada por las instrucciones incluidas entre begin_fill() y end_fill() Algunos ejemplos de colores: 'red', 'green', 'yellow' (deben escribirse entre comillas)
pencolor(x)	Indica que, todo lo que se dibuje, en adelante será del color indicado por el string x
circle(x)	Dibuja un círculo del radio indicado por el número x

Ejemplos:

Veamos algunos ejemplos de código para dibujar formas geométricas. Para interpretar código, una buena idea es seguirlo en papel, respetando las instrucciones en el orden en que están escritas.

Ejemplo 1:

from turtle import *
forward(50)
left(90)
forward(50)
left(90)
forward(50)
left(90)
forward(50)
left(90)

Esto dibuja un cuadrado, porque hace 4 veces lo mismo: dibuja una línea recta y gira a la izquierda en 90º. Como esas dos órdenes se repiten 4 veces, lo mejor es escribirlo con alguna herramienta que permita repetir algo. Por ejemplo, un for que itere 4 veces:

from turtle import *
for i in range(4):
    forward(50)
    left(90)

Ejemplo 2:

En este caso dibuja un triángulo, entonces las instrucciones se repiten tres veces y, en vez de girar 90º, gira 120º:

from turtle import *
for i in range(3):
    forward(100)
    left(120)

(el ángulo de 120 es porque se dividen los 360 grados totales por la cantidad de lados que tiene la figura a formar: 360/3=120)

Para hacer el mismo triángulo, pero relleno de color rojo:

from turtle import *
fillcolor('red')
begin_fill()
for i in range(3):
    forward(100)
    left(120)
end_fill()

Ejemplo 3:

Para hacer una estrella:

from turtle import *
for i in range(5):
    forward(100)
    right(144)

Ejemplo 4:

Para dibujar una cuadrícula de 3x3 habrá que usar iteraciones anidadas: por un lado, la iteración más interna que dibuja un cuadrado (la misma vista en ejemplo 1), por otro lado la que forma las columnas y por otro la que forma las filas:

from turtle import *
for fila in range(3):   #qué quiero hacer en cada fila
    for columna in range(3):   #qué quiero hacer en cada columna
        for cuadrado in range(4):   #dibujo un cuadrado
            forward(50)  
            right(90)
        forward(50)   #para no empezar otra vez en el mismo punto al terminar una fila, me corro a la derecha en el ancho de 1 cuadradito
    backward(50*3)   #vuelvo 3 cuadraditos para atrás (cada uno mide 50 de ancho) para quedar nuevamente en la primera columna
    right(90)
    forward(50)
    left(90)   #con las últimas 3 líneas me vuelvo a posicionar para empezar a dibujar la siguiente fila

Si quisiera que cada cuadrado quede pintado de un color, alternando entre 2 colores, entonces tengo que usar alguna estrategia: por ejemplo, empiezo contando del 1 en adelante cada cuadrado que dibujo; si el número es par pinto de un color y si es impar pinto de otro. Para contar los cuadrados uso una variable:

from turtle import *
recuadro = 1   #número de cuadrado
for fila in range(3):
    for columna in range(3):
        begin_fill()   #lo que quiero pintar es lo que se dibuja a continuación: un cuadrado
        for cuadrado in range(4):
            forward(50)
            right(90)
        if recuadro % 2 == 0:   #si el número es par
                fillcolor('red')   #pinto de rojo
        else:   #si el número no es par
                fillcolor('green')  #pinto de verde
        end_fill()   #terminé de dibujar un cuadrado, entonces lo pinto
            recuadro += 1;   #paso a contabilizar el siguiente cuadrado
            forward(50)
    backward(150)
    right(90)
    forward(50)
    left(90)