100 Días de Código en Python — Día 18: Turtle, Interfaces Gráficas (GUI) y la Pintura de Hirst

🎯 Objetivo de aprendizaje#

• Crear y controlar un objeto Turtle y la ventana Screen.
• Buscar en la documentación los métodos necesarios, con ayuda de internet cuando haga falta.

📖 Explicación conceptual#

from turtle import Turtle, Screen

timmy_the_turtle = Turtle()
timmy_the_turtle.shape("turtle")      # formas: arrow, turtle, circle, square, triangle, classic
timmy_the_turtle.color("red")
timmy_the_turtle.forward(100)
timmy_the_turtle.right(90)            # gira 90° a la derecha: de mirar al Este a mirar al Sur

screen = Screen()
screen.exitonclick()                  # SIEMPRE al final: mantiene la ventana abierta hasta hacer clic

¿Cómo se sabe todo esto? "¿Porque tengo mucha experiencia o soy muy inteligente? No." Se sabe gracias a la documentación. Su índice está organizado por categorías: movimiento, control del lápiz, color, visibilidad…

Estrategia de búsqueda del curso: el buscador interno de Stack Overflow da resultados poco relevantes. Es mejor buscar en un buscador general agregando "stack overflow" al final, leer la respuesta y luego confirmarla en la documentación oficial.

¿Qué es Tk y qué es una GUI?

• Los nombres de colores de Turtle vienen de las especificaciones de color de Tk. Turtle funciona "por debajo" con tkinter, la librería de Python para crear interfaces gráficas de usuario (GUI).
• Antes existían solo las interfaces de texto (como MS-DOS o nuestra consola). Con las GUI llegaron las ventanas, el ratón y el "apuntar y hacer clic". El curso menciona el Apple Lisa como la primera computadora con este tipo de interfaz.

🛠️ Nota técnica: el Apple Lisa (1983) fue uno de los primeros computadores comerciales con interfaz gráfica, pero no el primero en tenerla: el Xerox Alto (1973) y los trabajos anteriores de Douglas Engelbart ya usaban ventanas y ratón. Es un buen tema para investigar en clase.

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: prueba las 6 formas de tortuga y 5 colores distintos.
• 🟡 Reto 2: encuentra en la documentación cómo cambiar el color de fondo de la ventana y el título.
• 🟠 Reto 3: encuentra la diferencia entre color, pencolor y fillcolor. Dibuja una figura rellena con begin_fill y end_fill.
• 🔴 Reto 4: investiga en la documentación el sistema de coordenadas: ¿dónde está el punto (0, 0)? Usa goto(x, y) para dibujar las letras de las iniciales de tu colegio.

📖 Explicación conceptual#

Biblioteca estándar frente a paquetes. turtle viene en la biblioteca estándar de Python: una "biblioteca familiar", pequeña pero siempre disponible. Otros módulos deben instalarse desde PyPI (Día 16). Si no están instalados, aparece ModuleNotFoundError: No module named '...'. El curso lo muestra con los paquetes de ejemplo heroes y villains, que generan nombres de héroes y villanos.

Entornos virtuales (.venv). Los paquetes se instalan por proyecto, no en todo el computador. PyCharm crea un entorno virtual para cada proyecto nuevo. Por eso, un paquete instalado en el proyecto del Día 18 no aparece en un proyecto nuevo.

🛠️ Nota técnica:

• El curso explica la existencia de los entornos virtuales sobre todo por la transición de Python 2 a Python 3. Ese es un motivo histórico, pero hoy la razón principal es aislar las versiones de los paquetes de cada proyecto para que no entren en conflicto. Python 2 dejó de recibir soporte en 2020.
• Sobre pip: el riesgo que menciona el curso es real (instalar en el entorno equivocado). Se evita usando la terminal de PyCharm, que ya activa el entorno del proyecto, o ejecutando python -m pip install paquete con el Python de ese entorno.

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: reescribe un programa de Turtle con cada una de las 4 formas de importar y compara su legibilidad.
• 🟡 Reto 2: provoca un ModuleNotFoundError con un paquete que no tengas y luego instálalo.
• 🟠 Reto 3: busca en tu proyecto la carpeta .venv y encuentra dónde quedó instalado un paquete.
• 🔴 Reto 4: investiga qué es un archivo requirements.txt y cómo se genera con pip freeze. ¿Para qué le serviría a un compañero que quiere ejecutar tu proyecto?

📝 Ejercicio original del curso 1: dibujar un cuadrado de 100 × 100#

Estrategia: avanzar 100 y girar 90°, cuatro veces. Primero en 8 líneas y luego con for _ in range(4):.

Atajo del curso: para renombrar una variable en todo el archivo (por ejemplo, timmy_the_turtle → tim), usa en PyCharm Refactor → Rename.

📝 Ejercicio original del curso 2: línea punteada#

Enunciado: alternar 10 pasos dibujando y 10 pasos sin dibujar. Pista de la documentación: penup() levanta el lápiz y pendown() lo baja. Solución del curso: un for que repite forward(10), penup(), forward(10) y pendown().

🛠️ Nota: en el enunciado el curso dice "repetir 50 veces", pero la solución usa range(15). Como aclara la lección, el número exacto de repeticiones no importa. Lo que importa es alternar entre dibujar y no dibujar.

El curso aprecia las soluciones creativas (como dibujar en blanco), pero el objetivo era encontrar en la documentación el método adecuado.

📝 Ejercicio original del curso 3: polígonos del triángulo al decágono#

Enunciado: dibujar, superpuestos, un triángulo, un cuadrado, un pentágono… hasta un decágono, con lados de 100 y cada figura de un color aleatorio.

La clave matemática: la tortuga debe girar en total 360° para cerrar la figura, así que en cada esquina gira 360 / número de lados.

🛠️ Nota técnica (verificada): el curso dice que "cada esquina de un pentágono tiene 72°". En realidad, 72° es el ángulo que gira la tortuga (el ángulo exterior). El ángulo interior del pentágono es 180° − 72° = 108°. El código es correcto; solo hay que precisar el término.

Estructura de la solución del curso:

1. Una función draw_shape(num_sides) que calcula el ángulo una vez y repite forward(100) y right(angle) tantas veces como lados tenga la figura.
2. for shape_side_n in range(3, 11): (hasta el 11 para incluir el 10) que cambia el color con random.choice(colours) y llama draw_shape.
3. La lista de colores sale de una paleta en línea (el curso usa la de Trinket) o de la lista de colores de Tk.

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: dibuja un triángulo, un cuadrado y un pentágono rellenos de colores distintos.
• 🟡 Reto 2: haz una línea punteada en la que los segmentos se vuelvan más largos cada vez.
• 🟠 Reto 3: dibuja un polígono de 36 lados muy pequeños. ¿A qué se parece? Explica por qué.
• 🔴 Reto 4: dibuja una estrella de 5 puntas (ángulo de 144°) y una de 7 puntas. Deduce una fórmula para el ángulo de una estrella de n puntas y verifícala.

📖 Explicación conceptual#

Una caminata aleatoria (random walk) es una sucesión de pasos en direcciones al azar. Se usa para modelar fenómenos reales: el movimiento de una molécula en un líquido o un gas, un animal buscando comida, las finanzas de un jugador de azar e incluso investigaciones sobre el cerebro. El curso recomienda el artículo de Wikipedia sobre el tema.

📝 Ejercicio original del curso#

Enunciado: hacer que la tortuga dé 200 pasos de 30 unidades, cada uno en una dirección aleatoria entre Este, Norte, Oeste y Sur, con colores aleatorios, líneas gruesas y dibujo rápido.

Métodos que se buscan en la documentación:

Estructura: directions = [0, 90, 180, 270] y un bucle que cambia el color, avanza 30 y aplica setheading(random.choice(directions)).

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: cuenta cuántas veces se eligió cada dirección y muéstralo al final en la consola.
• 🟡 Reto 2: permite 8 direcciones (cada 45°).
• 🟠 Reto 3: evita que la tortuga se salga de la ventana. Si abs(tim.xcor()) o abs(tim.ycor()) supera un límite, hazla volver al centro con home().
• 🔴 Reto 4: mide qué tan lejos del origen termina la tortuga después de 100, 400 y 1600 pasos, repitiendo cada experimento 5 veces (tim.distance(0, 0)). ¿La distancia promedio crece de forma proporcional al número de pasos? Investiga qué dice la matemática de las caminatas aleatorias.

📖 Explicación conceptual#

Tuplas. Se parecen a las listas: tienen un orden y se accede a sus elementos por índice. Pero se escriben con paréntesis y son inmutables, es decir, no se pueden cambiar después de creadas.

my_tuple = (1, 3, 8)
print(my_tuple[2])       # 8
my_tuple[2] = 12         # ❌ TypeError: 'tuple' object does not support item assignment (verificado)
list(my_tuple)           # [1, 3, 8] → si necesitas modificarla, conviértela en lista

¿Cuándo usar una tupla? Cuando los datos no deben cambiar, como la paleta de colores de un sitio web o, en este caso, un color.

Colores RGB. Todo color se forma mezclando Rojo, Verde (G) y Azul (B), cada uno con un valor de 0 a 255. El negro es (0, 0, 0) y el blanco (255, 255, 255). El curso recomienda un "calculador RGB" en línea para experimentar con las mezclas.

En Turtle hay que cambiar el modo de color del módulo, no del objeto tortuga:

import turtle as t
import random

t.colormode(255)

def random_color():
    r = random.randint(0, 255)
    g = random.randint(0, 255)
    b = random.randint(0, 255)
    return (r, g, b)

tim = t.Turtle()
tim.color(random_color())

Detalle del curso: si dentro de la función guardas el resultado en una variable llamada random_color, igual que la función, el editor advierte. Usa otro nombre, como color.

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: crea una tupla con los 3 colores de la bandera de Colombia en RGB. Busca los valores en internet y cita la fuente.
• 🟡 Reto 2: escribe random_pastel(), que devuelva colores claros (cada valor entre 150 y 255).
• 🟠 Reto 3: escribe mezclar(c1, c2), que reciba dos tuplas y devuelva el color promedio.
• 🔴 Reto 4: investiga el formato hexadecimal de los colores (#FF0000) y escribe a_hex(color) para convertir una tupla RGB a ese formato. (Pista: f"{255:02X}".)

📝 Ejercicio original del curso#

Enunciado: dibujar muchos círculos de radio 100, cada uno de un color aleatorio y girando un poco la dirección entre uno y otro, hasta completar la figura de un espirógrafo, como el juguete de engranajes.

Métodos que se buscan en la documentación: circle(radio), heading() (para leer la dirección actual) y setheading(angulo).

Cómo llega el curso a la solución:

1. Dibujar un círculo.
2. Girar un poco (setheading(tim.heading() + 10)) y dibujar otro.
3. Repetir en un bucle… y descubrir que, con un número fijo de repeticiones, se dibujan círculos encima de otros.
4. Calcular cuántos círculos hacen falta: 360 / tamaño_del_espacio.
5. Encontrar un error: range(360 / 5) produce TypeError: 'float' object cannot be interpreted as an integer, porque la división / siempre devuelve un float (Día 2). Solución del curso: int(360 / size_of_gap).

Mejora: 360 // size_of_gap (la división entera del Día 2) da directamente un entero. Además, si el tamaño del espacio no divide exactamente a 360 (por ejemplo, 7 → 360/7 ≈ 51.43, verificado), la figura no queda perfectamente cerrada. Elige divisores de 360: 5, 10, 12, 15…

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: prueba tamaños de espacio de 5, 10, 20 y 45. ¿Qué cambia?
• 🟡 Reto 2: haz que el radio también cambie en cada círculo.
• 🟠 Reto 3: en lugar de círculos, repite cuadrados girados (reutiliza tu draw_shape del Reto 3).
• 🔴 Reto 4: escribe draw_spirograph(size_of_gap, radio, figura), donde figura sea "circulo" o el número de lados de un polígono. Documenta la función con un docstring.

Contexto: el debate sobre el arte contemporáneo#

El curso cuenta varias anécdotas:

• Una instalación de Goldschmied y Chiari (¿Dónde vamos a bailar esta noche?), hecha con botellas y colillas, fue tirada a la basura por el personal de limpieza del museo, que la confundió con desechos.
• El libro El tiburón de 12 millones de dólares, sobre la economía del arte contemporáneo.
• Las obras de Damien Hirst: un tiburón en formol, una calavera con diamantes y las pinturas de puntos, que según el curso se han vendido por cifras millonarias.

💡 Para discutir en clase: ¿qué hace que algo sea "arte"? Si un programa puede generar pinturas de puntos, ¿el arte está en la obra, en la idea o en el artista? (Buen tema para trabajar con el área de Artes.)

Parte 1: extraer la paleta de colores de una imagen#

Herramienta: el paquete colorgram, que extrae los colores más frecuentes de una imagen.

🛠️ Nota técnica (verificada): en PyPI, el paquete se llama colorgram.py (con ".py" en el nombre), aunque en el código se importa como import colorgram. Para instalarlo: en PyCharm, busca "colorgram"; en la terminal, pip install colorgram.py. Instala también la librería de imágenes Pillow como dependencia.

📝 Ejercicio original del curso: obtener una lista de tuplas RGB

1. Descarga una imagen de una pintura de puntos, guárdala como image.jpg en la misma carpeta que main.py.
2. Extrae 30 colores con colorgram.extract("image.jpg", 30).
3. Cada color extraído es un objeto con el atributo rgb, que a su vez tiene los atributos r, g y b. Construye una lista de tuplas (r, g, b), el formato que usa Turtle.
4. Revisa la lista y elimina los tonos casi blancos (valores cercanos a 255): son el fondo de la imagen.
5. Copia la lista resultante como color_list en tu programa y comenta el código de extracción, porque no hace falta repetirla cada vez.

Resultado de la verificación (imagen de prueba con 3 círculos: rojo (200, 30, 40), azul (30, 120, 200) y amarillo (240, 200, 20) sobre fondo blanco):

[(254, 254, 250), (30, 119, 196), (198, 31, 40), (239, 199, 23), (247, 254, 253), (254, 250, 253)]

El primero y los dos últimos son tonos de blanco del fondo que hay que eliminar. Los otros tres corresponden, con pequeñas diferencias por la compresión JPG, a los colores originales.

Sugerencia de esta adaptación: en lugar de una obra de Hirst, puedes extraer la paleta de una foto propia: el uniforme del colegio, un paisaje de tu región o un plato típico. La obra final será aún más "tuya".

Parte 2: dibujar los puntos#

Requisitos del curso: una cuadrícula de 10 × 10 puntos, cada punto de tamaño 20, separados unos 50 pasos, con colores al azar de color_list.

🔍 Antes de programar#

• ¿Qué método de la documentación dibuja un punto sin tener que hacer un círculo? (Pista: dot(tamaño, color).)
• ¿Cómo evitas que la tortuga dibuje líneas entre los puntos?
• ¿Dónde debe empezar la tortuga para que la cuadrícula quede centrada?
• Después de cada 10 puntos, ¿cómo "salta" a la fila siguiente? (Pista: %, Día 3.)

Construcción paso a paso (siguiendo la solución del curso):

1. import turtle as t, t.colormode(255), crear tim y screen.exitonclick() al final.
2. Dibujar un punto con tim.dot(20, random.choice(color_list)).
3. Un bucle de 10 puntos: dot y luego forward(50). El curso observa que la tortuga se sale de la ventana y además deja líneas.
4. Punto de inicio (el curso lo encuentra experimentando): setheading(225) (hacia abajo y a la izquierda), avanzar unos 300 y luego setheading(0).
5. Cambiar de fila: si dot_count % 10 == 0, hacer setheading(90), forward(50), setheading(180), forward(500) y setheading(0).
6. El error del punto número 100: range(1, number_of_dots) dibuja solo 99 puntos. Se corrige con range(1, number_of_dots + 1). Es el desfase por uno del Día 5.
7. Acabados: penup() para no dibujar líneas, hideturtle() para que no se vea la flecha (según la documentación, además acelera el dibujo) y speed("fastest").

"Es a través de estos cambios paso a paso que realmente entiendes lo que hace tu código": el curso deja las líneas visibles mientras desarrolla, para ver el recorrido de la tortuga, y las quita al final.

Pruebas#

🧪 Prueba y depuración#

Este código tiene tres errores y deja una pregunta para analizar:

import turtle as t
import random

color_list = [(202, 164, 110), (149, 75, 50), (222, 201, 136)]
tim = t.Turtle()
tim.speed("fastest")
tim.hideturtle()
tim.setheading(225)
tim.forward(300)
tim.setheading(0)

for dot_count in range(1, 100):
    tim.dot(20, random.choice(color_list))
    tim.forward(50)
    if dot_count % 10 == 0:
        tim.setheading(90)
        tim.forward(50)
        tim.setheading(180)
        tim.forward(500)
        tim.setheading(0)

screen = t.Screen()
screen.exitonclick()

(Pistas de los errores: un modo de color que falta, porque sin t.colormode(255) Turtle rechaza las tuplas con valores mayores que 1; un desfase por uno; y un lápiz que sigue abajo. La pregunta: la ventana se crea después del bucle, ¿aun así se ve el dibujo mientras se hace? Explica por qué funciona.)

⭐ Extensión del proyecto#

• Tamaños de punto aleatorios entre 10 y 30.
• Una cuadrícula de N × M configurable, con los parámetros de una función.
• Guardar la imagen: investiga screen.getcanvas().postscript(file="obra.eps").

Situación#

Para la semana cultural, el área de Artes y la de Tecnología proponen crear mandalas digitales con Turtle.

Requisitos#

1. Una tupla de paletas: cada paleta es una tupla de colores RGB. Por ejemplo, la bandera de Colombia (con la fuente de los valores citada) y los colores de un paisaje de tu región (extraídos con colorgram de una foto propia).
2. Funciones reutilizables con parámetros:
   • petalo(tortuga, tamaño, color): dibuja un pétalo con dos arcos (circle(radio, extent)).
   • anillo(tortuga, n_petalos, tamaño, paleta): dibuja n pétalos girando 360 / n.
3. El mandala tiene al menos 3 anillos concéntricos, de tamaños distintos, y un punto central con dot.
4. El usuario elige la paleta con screen.textinput(...), un cuadro de diálogo de Turtle que debes buscar en la documentación.
5. hideturtle() y speed("fastest") para el resultado final.

Reflexión#

¿Qué partes de tu código reutilizaste del espirógrafo y de los polígonos? ¿Cómo te ayudaron las funciones con parámetros?

Situación problema#

El curso quiere montar una galería de arte generativo para la feria de tecnología: un programa que, a partir de la foto que elija cada estudiante, produzca tres obras distintas con la paleta de esa foto.

Pregunta orientadora#

¿Cómo combinar paquetes externos, clases propias y la documentación para construir una herramienta creativa y reutilizable?

Requerimientos#

1. Una clase Paleta:
   • __init__(self, ruta_imagen, n_colores) extrae los colores con colorgram y filtra los tonos casi blancos (define el criterio como una constante).
   • Método color_aleatorio() que devuelve una tupla.
   • Método resumen() que devuelve un texto con la cantidad de colores y los tres primeros.
2. Una clase Artista que recibe una Paleta y crea su propia tortuga, con los métodos:
   • pintura_puntos(filas, columnas, tamaño, separacion)
   • espirografo(espacio)
   • caminata(pasos)
3. Un programa principal con un menú (screen.textinput) para elegir la obra y validar la opción. Al terminar cada obra, se limpia la pantalla (investiga clear() o reset()).
4. Manejar el caso de una imagen que no existe (FileNotFoundError) con try/except (Día 13) y mostrar un mensaje claro.
5. Todas las clases y métodos con docstring. Sin variables globales modificables.

Entregables#

• El código, con al menos dos archivos de clases y un main.py.
• La foto original y capturas de las tres obras.
• Un requirements.txt con los paquetes necesarios (Reto 4 del Tema 2).
• Una "ficha de museo" de tu obra favorita: título, técnica ("Python + Turtle") y una descripción de 3 líneas.

Criterios técnicos#

• El programa funciona en el computador de un compañero siguiendo tu requirements.txt.
• La paleta nunca contiene el fondo blanco.
• Cambiar la foto no exige modificar ninguna clase.