100 Días de Código en Python — Día 19: Instancias, Estado y Funciones de Orden Superior

🎯 Objetivo de aprendizaje#

• Hacer que un programa de Turtle responda a una tecla con listen() y onkey().
• Explicar qué es una función de orden superior y por qué una función se pasa sin paréntesis.

🧠 ¿Qué aprenderemos?#

Detectores de eventos (event listeners), funciones como argumentos y argumentos de palabra clave.

📖 Explicación conceptual#

¿Qué es un evento? Es algo que ocurre mientras el programa está abierto: presionar una tecla, hacer clic, mover el ratón. Un detector de eventos es código que "se queda escuchando" y, cuando el evento ocurre, ejecuta una función.

Piensa en el timbre de tu casa: nadie está mirando la puerta todo el tiempo. Cuando alguien toca, el timbre avisa y alguien reacciona. Así funcionan los eventos.

La documentación de Turtle tiene una sección completa llamada eventos de la pantalla. Los dos métodos clave son:

🔎 Ejemplo explicado#

from turtle import Turtle, Screen

tim = Turtle()
screen = Screen()


def move_forwards():
    tim.forward(10)


screen.listen()
screen.onkey(key="space", fun=move_forwards)   # sin paréntesis después de move_forwards
screen.exitonclick()

¿Cómo se ejecuta?

1. Se crean la tortuga y la pantalla.
2. Se define move_forwards, pero todavía no se ejecuta.
3. listen() activa la escucha.
4. onkey guarda la función para usarla después. No la ejecuta.
5. Cada vez que pulsas la barra espaciadora, Turtle llama a move_forwards() y tim avanza 10 pasos.

🛠️ Nota técnica (verificada en la documentación del módulo): onkey se activa al soltar la tecla (key-release). Si quieres que la acción ocurra al presionarla, existe onkeypress. Volveremos a esto en el Día 22.

La regla de oro de hoy: cuando una función se pasa como argumento, se escribe sin paréntesis. Los paréntesis la ejecutan en ese mismo momento; sin ellos, solo entregamos "la receta" para que otro la ejecute cuando corresponda.

Consejo del curso: en métodos que no escribiste tú, como onkey, usa argumentos de palabra clave (key=, fun=). Así quien lea el código entiende qué es cada valor, sobre todo cuando el orden no tiene un significado evidente. (Verificado: la firma real es onkey(fun, key), así que con palabras clave puedes escribirlos en cualquier orden.)

Funciones de orden superior#

Una función de orden superior es una función que recibe otra función como entrada (o la devuelve) y trabaja con ella. onkey es una. El curso lo muestra con la calculadora del Día 10:

def add(n1, n2):
    return n1 + n2

def subtract(n1, n2):
    return n1 - n2

def multiply(n1, n2):
    return n1 * n2

def divide(n1, n2):
    return n1 / n2


def calculator(n1, n2, func):
    return func(n1, n2)          # aquí sí van los paréntesis: se llama a la función recibida


result = calculator(2, 3, add)   # add se pasa sin paréntesis
print(result)                    # 5

Si cambias add por multiply, obtienes 6. Con divide, obtienes 0.6666666666666666 (verificado).

🛠️ Nota técnica (verificada): en la lección se dice que la división da 0 "porque se redondea a un número entero". En Python 3, / siempre devuelve un float (Día 2): 2 / 3 da 0.666…. Solo la división entera // daría 0.

No todos los lenguajes permiten pasar funciones como si fueran datos. En Python es muy común y resulta especialmente útil para responder a eventos.

⚠️ Errores frecuentes#

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: vincula la tecla "r" a una función que cambie el color de tim a rojo y "b" a una que lo cambie a azul.
• 🟡 Reto 2: escribe aplicar_dos_veces(func, x) que devuelva func(func(x)). Pruébala con una función duplicar(n). ¿Qué devuelve aplicar_dos_veces(duplicar, 5)?
• 🟠 Reto 3: crea un diccionario operaciones = {"+": add, "-": subtract, ...} (¡las funciones pueden ser valores de un diccionario!) y úsalo para que el usuario escriba el símbolo y el programa calcule.
• 🔴 Reto 4: busca en la documentación screen.onscreenclick(fun). ¿Cuántos argumentos recibe la función que le pasas? Escribe un programa en el que la tortuga vaya al punto donde haces clic.

📝 Ejercicio original del curso#

Enunciado: crear un programa de dibujo en el que:

Objetivo: practicar los detectores de eventos y buscar en la documentación los métodos necesarios. Resultado esperado: combinando W con A o D se pueden dibujar líneas y curvas.

🔍 Antes de programar#

• Como onkey solo acepta funciones sin argumentos, ¿cuántas funciones necesitas?
• ¿Qué método borra los dibujos? En la documentación hay dos clear: uno de la tortuga y otro de la pantalla. ¿Cuál necesitas?
• ¿Qué método lleva la tortuga al centro?
• Al volver al centro, ¿dejará un rastro? ¿Cómo lo evitas?

Cómo lo resuelve el curso#

1. Cuatro funciones de movimiento: move_forwards, move_backwards, turn_left y turn_right, cada una vinculada a su tecla.
2. Dos formas válidas de girar:
   • Leer el rumbo actual y sumarle 10: tim.setheading(tim.heading() + 10). Como 0° es el Este y 90° el Norte, sumar gira a la izquierda y restar gira a la derecha.
   • Usar directamente tim.left(10) o tim.right(10). El curso aclara que ambas funcionan y la elección es tuya.
3. Borrar: tim.clear() borra solo los dibujos de esa tortuga. En cambio, screen.clear() borra todo, incluida la tortuga.
4. Volver al centro: tim.home(). El curso descubre que la tortuga dibuja su camino de regreso, así que la solución es penup(), home() y pendown().

🛠️ Nota técnica (verificada en la documentación del módulo): screen.clear() no solo borra las tortugas: también elimina todos los vínculos de teclas y deja la pantalla en su estado inicial. Si lo usaras en el Etch-A-Sketch, las teclas dejarían de funcionar. Otra alternativa válida es tim.reset(), que borra el dibujo y devuelve la tortuga al centro de una vez.

Reflexión del curso: no te castigues si no encontraste home o clear. Leer la documentación es cuestión de práctica y paciencia. El ciclo del desarrollo es: agrega algo, ejecuta, revisa si hace lo que quieres y, si no, arréglalo. "Siempre aprendo más cuando cometo más errores."

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1 — Aplicación: agrega las teclas "plus" (+) y "minus" (-) para cambiar el grosor del lápiz con pensize.
• 🟡 Reto 2 — Ampliación: agrega la tecla "space" para subir o bajar el lápiz alternadamente. (Pista: tim.isdown() devuelve True si el lápiz está abajo.)
• 🟠 Reto 3 — Desafío: evita que la tortuga salga de la ventana: antes de avanzar, calcula si su nueva posición quedaría fuera y, en ese caso, no la muevas.
• 🔴 Reto 4 — Pensamiento computacional: diseña un "modo espejo": una segunda tortuga dibuja de forma simétrica respecto al eje Y. ¿Qué debe pasarle a su rumbo cuando la primera gira a la izquierda?

🎯 Objetivo de aprendizaje#

• Diferenciar clase, objeto, instancia y estado.
• Crear varias instancias de una misma clase que actúan de forma independiente.

📖 Explicación conceptual#

La clase Turtle es un plano: define qué tiene una tortuga (atributos) y qué puede hacer (métodos). Con ese plano podemos construir tantos objetos como necesitemos: timmy, tommy, jenny…

from turtle import Turtle

timmy = Turtle()
tommy = Turtle()

timmy.color("green")
tommy.color("purple")
timmy.forward(100)     # timmy se mueve; tommy sigue quieto

• Instancia: cada objeto creado es una instancia (un ejemplo) de la clase. Tú y tu compañero son dos "instancias" de ser humano: comparten la misma estructura, pero cada uno es independiente.
• Estado: son los valores de los atributos y lo que está haciendo el objeto en un momento dado. El estado del color de timmy es verde y el de tommy es morado. En este momento timmy se está moviendo y tommy está quieto.

Relación con el Día 16: allí creamos objetos a partir de clases. Hoy la novedad es trabajar con muchas instancias a la vez, normalmente guardadas en una lista.

⚠️ Errores frecuentes#

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: crea 3 tortugas de colores distintos y haz que cada una dibuje un polígono diferente (Día 18).
• 🟡 Reto 2: prueba tommy = timmy y luego tommy.color("red"). ¿De qué color queda timmy? Explica por qué.
• 🟠 Reto 3: guarda 5 tortugas en una lista y haz que todas giren 72° y avancen 100 con un solo bucle.
• 🔴 Reto 4: con tus palabras, explica la diferencia entre el estado de una tortuga y su clase. Da un ejemplo de tu vida escolar (por ejemplo, la clase "Estudiante" y el estado de cada estudiante durante una jornada).

🎯 Objetivo de aprendizaje#

• Configurar el tamaño de la ventana y pedir datos al usuario con textinput.
• Ubicar objetos en la pantalla con goto(x, y) usando el plano cartesiano.

📖 Explicación conceptual#

Tamaño de la ventana. Con screen.setup(width=500, height=400) la ventana mide 500 píxeles de ancho y 400 de alto. El curso recomienda de nuevo los argumentos de palabra clave: setup(500, 400) obliga al lector a adivinar cuál es el ancho.

Pedir datos en una ventana emergente:

user_bet = screen.textinput(title="Haz tu apuesta", prompt="¿Qué tortuga ganará la carrera? Escribe un color: ")

Funciona como input(): devuelve un string. Si necesitas un número, existe numinput.

El plano cartesiano de Turtle. La ventana es como un plano cartesiano de matemáticas, con el origen (0, 0) en el centro:

                 y = +200
                    |
 x = -250 ----------+---------- x = +250
                    |  (0, 0)
                 y = -200

Con una ventana de 500 × 400:

• El eje X va de −250 (borde izquierdo) a +250 (borde derecho): la mitad del ancho hacia cada lado.
• El eje Y va de −200 (abajo) a +200 (arriba).

Pregunta del curso: ¿cuáles son las coordenadas de un punto ubicado a mitad de camino del borde derecho y a mitad de camino del borde superior? Respuesta: (125, 100), porque la mitad de 250 es 125 y la mitad de 200 es 100.

Otros detalles de la lección:

• goto(-250, -100) deja la tortuga justo en el borde, casi invisible. El curso usa x = -230 para que se vea.
• Se puede crear la tortuga con su forma desde el inicio: Turtle(shape="turtle").
• penup() para que las tortugas no dibujen al moverse.

📝 Ejercicio original del curso: seis tortugas en la línea de salida#

Enunciado: crear seis tortugas, una por cada color de colors = ["red", "orange", "yellow", "green", "blue", "purple"], y ubicarlas en la línea de salida, espaciadas de forma uniforme en el eje Y.

🔍 Antes de programar#

• ¿Qué coordenada debe ser igual para todas las tortugas y cuál debe cambiar? ¿Por qué?
• ¿Cómo relacionas la tortuga número i con su color y su posición?

Solución del curso (en palabras): un for turtle_index in range(0, 6): que crea cada tortuga, le asigna colors[turtle_index] y la envía a goto(x=-230, y=y_positions[turtle_index]), con y_positions = [-70, -40, -10, 20, 50, 80] (empieza en −70 y sube de 30 en 30).

Alternativa de esta adaptación: en lugar de escribir la lista de posiciones a mano, puedes calcularla: y = -70 + turtle_index * 30. Así, si cambias el número de tortugas, no tienes que reescribir la lista. Ambas formas son válidas; la calculada escala mejor.

⚠️ Errores frecuentes#

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: cambia la ventana a 800 × 600 y ubica las tortugas en la nueva línea de salida. ¿Qué valores cambiaste?
• 🟡 Reto 2: dibuja con una tortuga auxiliar la línea de meta vertical en x = 230.
• 🟠 Reto 3: calcula las posiciones Y para que cualquier número de tortugas quede centrado verticalmente. Prueba con 3, 6 y 9.
• 🔴 Reto 4: escribe una función esta_dentro(x, y, ancho, alto) que devuelva True si el punto está dentro de la ventana. Pruébala con 5 puntos antes de usarla en Turtle.

Problema#

Seis tortugas de colores compiten en una carrera. El usuario apuesta por un color, las tortugas avanzan una distancia aleatoria en cada turno y la primera que cruza la meta gana. El programa informa si el usuario ganó o perdió.

Contexto#

Es el tipo de juego que podría animar una feria del colegio: un juego de azar sencillo en el que nadie tiene ventaja… o eso creemos (lo comprobaremos en la sección de depuración).

Objetivo#

Construir el juego usando varias instancias de Turtle, cada una con su propio estado.

Requisitos funcionales#

1. Ventana de 500 × 400.
2. Ventana emergente para la apuesta.
3. Seis tortugas de colores alineadas en la línea de salida.
4. Avances aleatorios entre 0 y 10 en cada turno.
5. Detectar a la ganadora y mostrar en la consola si el usuario ganó o perdió, y el color de la ganadora.

Restricciones técnicas#

textinput, goto, listas de objetos, random.randint, while con una variable de control y pencolor().

Planificación#

Construcción paso a paso#

Versión 1 — Configuración: setup, textinput e imprimir la apuesta para comprobarla.

Versión 2 — Salida: el bucle del Tema 4 con las seis tortugas en la línea de salida.

Versión 3 — Guardar las instancias. El curso observa que ya no tiene sentido llamar tim a todas las tortugas: refactoriza el nombre a new_turtle y agrega cada una a una lista all_turtles = [].

Versión 4 — Movimiento:

is_race_on = False
if user_bet:                 # solo empieza cuando hay una apuesta
    is_race_on = True

while is_race_on:
    for turtle in all_turtles:
        rand_distance = random.randint(0, 10)   # randint incluye el 0 y el 10
        turtle.forward(rand_distance)

La variable is_race_on evita que la carrera empiece mientras el usuario todavía está decidiendo.

Versión 5 — Condición de parada. El borde derecho está en x = 250, pero hay que detectar la llegada antes, en 230, teniendo en cuenta el tamaño de la tortuga. Dentro del for:

• Si turtle.xcor() > 230: se termina la carrera (is_race_on = False).
• El color se obtiene con turtle.pencolor(). El curso descubre que turtle.color() devuelve dos valores (el color del lápiz y el de relleno) y por eso imprime algo como ('yellow', 'yellow').
• Se compara winning_color == user_bet y se imprime "Has ganado" o "Has perdido" junto con el color de la ganadora.

🛠️ Nota técnica (verificada): el curso dice que la tortuga mide 40 × 40 píxeles y por eso resta 20 al borde. Según la definición de formas del módulo, la forma "turtle" mide unos 18 × 24 píxeles y las formas "square" y "classic" unos 20 × 20. El margen de 20 (230 = 250 − 20) sigue siendo razonable, pero la razón exacta es "la mitad del tamaño de la forma, más un poco de margen".

Pruebas#

🧪 Prueba y depuración: ¿la carrera es justa?#

En el código del curso, cuando una tortuga cruza la meta, is_race_on pasa a False, pero el for sigue recorriendo el resto de tortugas en esa misma vuelta. Además, las tortugas siempre se mueven en el mismo orden.

Se simularon 100 000 carreras sin ventana gráfica, con los mismos valores del curso (salida en −230, meta en 230, pasos de 0 a 10). Resultados verificados:

1. En aproximadamente el 10,5 % de las carreras, dos o más tortugas cruzan la meta en la misma vuelta y el programa anuncia más de un ganador.
2. Incluso deteniendo el recorrido en la primera que cruza, el orden de la lista da ventaja: la primera tortuga ganó cerca del 18,6 % de las carreras y la última cerca del 14,9 %. En una carrera justa, cada una ganaría alrededor del 16,7 %.

Actividad:

• Explica por qué la primera tortuga de la lista tiene ventaja.
• Corrige el error de los varios ganadores (pista: break, o revisar la meta después de mover a todas).
• Propón una forma de hacer la carrera justa. (Ideas: desordenar la lista en cada vuelta con random.shuffle, o mover a todas primero y, si hay empate, elegir al que avanzó más o declarar empate.)
• Si tienes tiempo, escribe tu propia simulación sin Turtle para comprobar tu solución.

⭐ Extensión del proyecto#

• Mostrar el ganador en la ventana con turtle.write() en lugar de la consola.
• Validar que el color apostado exista en la lista y volver a preguntar si no.
• Jugar varias rondas y llevar la cuenta de aciertos.

Situación#

La profesora de Matemáticas necesita una pizarra digital sencilla para explicar el plano cartesiano: al hacer clic, se marca el punto y se muestran sus coordenadas.

Requisitos#

1. Ventana de 600 × 600 con los ejes X e Y dibujados por una tortuga auxiliar.
2. Al hacer clic en la pantalla (screen.onscreenclick), una tortuga va al punto, dibuja un dot y escribe sus coordenadas con write.
3. Teclas:
   • "l": activa o desactiva el modo "unir puntos con líneas".
   • "c": borra los puntos sin borrar los ejes. (Pista: por eso conviene usar dos instancias distintas.)
   • "1", "2", "3": cambian el color del marcador.
4. Muestra en la consola el cuadrante del último punto (I, II, III, IV o sobre un eje).

Decisiones que debes tomar#

• onscreenclick pasa dos argumentos a tu función. ¿Cuáles?
• ¿Dónde guardas si el modo "unir puntos" está activo? Justifica tu elección.

Reflexión#

¿En qué se parecen onkey y onscreenclick? ¿Por qué ambos son funciones de orden superior?

Situación problema#

Para la feria institucional, el curso organizará un puesto de carreras virtuales. Cada jugador empieza con 100 puntos y apuesta en cada ronda. El puesto debe ser justo y fácil de configurar.

Pregunta orientadora#

¿Cómo usar múltiples instancias con estado propio para construir un juego justo, configurable y verificable?

Requerimientos#

1. Una clase Corredor que contenga una tortuga (atributo) y guarde su nombre, color y número de victorias.
2. Una clase Carrera que reciba la lista de corredores, los ubique en la salida calculando las posiciones según el tamaño de la ventana y ejecute la carrera sin ventajas por el orden de la lista.
3. El jugador apuesta un color y una cantidad de puntos con textinput y numinput. Valida que el color exista y que la apuesta no supere los puntos disponibles.
4. Si gana, recibe el doble de lo apostado; si pierde, lo pierde.
5. Al final de cada ronda se muestra en la ventana el ganador y los puntos del jugador.
6. El juego termina cuando el jugador se queda sin puntos o escribe "salir".
7. Constantes en mayúsculas para el tamaño de la ventana, la meta y el paso máximo.

Etapas de desarrollo#

1. Una ronda sin puntos (el proyecto del día, reorganizado en clases).
2. Corrección de la ventaja por orden y de los ganadores múltiples.
3. Sistema de puntos y validaciones.
4. Varias rondas y mensaje final.

Entregables#

• El código en al menos dos archivos (corredor.py y main.py).
• Una simulación sin ventana de 10 000 carreras que demuestre que tu carrera es justa (porcentaje de victorias de cada color).
• Capturas de una partida completa.

Casos de prueba#

Criterios técnicos#

• Cambiar el número de corredores solo requiere modificar la lista de colores.
• Nunca se anuncian dos ganadores.
• En la simulación, ningún color supera el 18 % ni queda por debajo del 15,5 % con 6 corredores.

Posibles extensiones#

Corredores con "habilidad" distinta (paso máximo diferente) y cálculo de cuotas de apuesta proporcionales a la probabilidad de ganar.

Conceptuales#

1. ¿Qué es un detector de eventos? Da un ejemplo fuera de la programación.
2. ¿Qué diferencia hay entre move_forwards y move_forwards()?
3. ¿Qué es el estado de un objeto? ¿Cambia con el tiempo?

Análisis de código#

def saludar():
    return "hola"

def ejecutar(f):
    return f().upper()

print(ejecutar(saludar))

¿Cuál es la función de orden superior? ¿Qué imprime?

Predicción#

Ventana de 600 × 400. ¿En qué lugar aparece la tortuga después de goto(-300, 200)? ¿Y después de goto(0, -250)?

Depuración#

screen.listen()
screen.onkey(turn_left(), "a")

def turn_left():
    tim.left(10)

Encuentra dos problemas.

Modificación#

En la carrera, cambia el paso aleatorio a randint(1, 5). ¿La carrera dura más o menos? ¿Cambia quién tiene ventaja?

Creación#

Crea un programa con tres tortugas controladas por teclas distintas (por ejemplo, W, I y la flecha arriba). La primera que llegue a y = 180 gana. Es un juego para tres personas en el mismo teclado.