100 Días de Código en Python — Día 31: Proyecto Final "Flashy", la aplicación de tarjetas de estudio

La idea pedagógica: el diccionario de frecuencias#

La profesora del curso cuenta que estudió francés durante años memorizando listas y tablas gramaticales, y no aprendió a hablarlo. Lo que sí le funcionó fue una idea sencilla:

• En chino hay unos 50 000 caracteres, pero para leer textos sencillos basta con unos 1000.
• Lo importante es aprender primero las palabras más usadas. Un diccionario de frecuencias no ordena las palabras alfabéticamente, sino por cuántas veces aparecen en el uso real.
• Las listas que usa el curso se construyeron contando las palabras de los subtítulos de películas y series.

Para crear las tarjetas, la profesora copió 100 palabras frecuentes en una hoja de cálculo de Google y usó la fórmula =GOOGLETRANSLATE(celda, "fr", "en") para traducirlas. Luego descargó la hoja como CSV. Ese archivo, french_words.csv, ya viene en el proyecto inicial.

💡 Conexión: esta es una aplicación del análisis de datos que viste con pandas (Día 25): contar frecuencias y ordenar por ellas para decidir qué es más importante.

Materiales del proyecto#

Si no tienes el proyecto inicial: crea un data/french_words.csv con al menos 10 palabras (primera línea: French,English). Para las imágenes, crea en cualquier editor un PNG de 800 × 526 para cada cara de la tarjeta y dos PNG pequeños (por ejemplo, 100 × 100) para los botones. También puedes hacer las tarjetas en inglés–español: solo cambian los nombres de las columnas.

Prerequisito general: Tkinter, Canvas, PhotoImage, grid, columnspan y highlightthickness (Días 27 y 28); window.after y after_cancel (Día 28, Pomodoro); pandas, read_csv y DataFrame (Día 25); excepciones y FileNotFoundError (Día 30); variables globales (Día 12); random.choice (Día 4).

🎯 Objetivo de aprendizaje#

Construir una interfaz con un Canvas que superpone una imagen y dos textos, y botones con imágenes, organizados en una cuadrícula.

📝 Ejercicio original del curso#

Enunciado: usar las imágenes de la carpeta images para construir la interfaz: una tarjeta con un título y una palabra, y debajo dos botones con imagen (❌ y ✅).

Pistas del curso:

1. Una cuadrícula de 2 × 2, donde la tarjeta ocupa 2 columnas.
2. La tarjeta es un Canvas con 1 imagen y 2 textos.
3. La imagen es card_front.png, creada con PhotoImage. Cuidado con la ruta: la imagen está dentro de la carpeta images.
4. Para poner una imagen en un botón:

my_image = PhotoImage(file="path/to/image_file.png")
button = Button(image=my_image, highlightthickness=0)

🔍 Antes de programar#

• Dibuja la cuadrícula: ¿en qué fila y columna va cada elemento?
• ¿Por qué la tarjeta necesita un Canvas y no un Label? (Pista: ¿cuántas cosas van una encima de otra?)
• La imagen de la tarjeta mide 800 × 526. ¿Cuál es el punto central?

📖 Explicación conceptual#

¿Por qué un Canvas? Un Canvas (lienzo) permite superponer elementos: primero la imagen de la tarjeta y encima los dos textos. Cada elemento se ubica con coordenadas relativas al lienzo, no a la ventana.

Coordenadas en el lienzo: en Tkinter, el punto (0, 0) es la esquina superior izquierda y Y crece hacia abajo (al contrario de Turtle). Por eso el centro de un lienzo de 800 × 526 es (400, 263), y un texto en Y = 150 queda más arriba que el centro.

🔎 Ejemplo explicado (la solución del curso, reconstruida)#

from tkinter import *

BACKGROUND_COLOR = "#B1DDC6"   # usa el valor que trae el main.py del proyecto inicial

window = Tk()
window.title("Flashy")
window.config(padx=50, pady=50, bg=BACKGROUND_COLOR)

# La tarjeta: un lienzo del tamaño de la imagen
canvas = Canvas(width=800, height=526)
card_front_img = PhotoImage(file="images/card_front.png")
canvas.create_image(400, 263, image=card_front_img)
canvas.create_text(400, 150, text="Title", font=("Arial", 40, "italic"))
canvas.create_text(400, 263, text="word", font=("Arial", 60, "bold"))
canvas.config(bg=BACKGROUND_COLOR, highlightthickness=0)
canvas.grid(row=0, column=0, columnspan=2)

# Los botones
cross_image = PhotoImage(file="images/wrong.png")
unknown_button = Button(image=cross_image, highlightthickness=0)
unknown_button.grid(row=1, column=0)

check_image = PhotoImage(file="images/right.png")
known_button = Button(image=check_image, highlightthickness=0)
known_button.grid(row=1, column=1)

window.mainloop()

Qué hace cada parte y por qué:

• padx=50, pady=50: deja 50 píxeles de margen alrededor.
• create_image(400, 263, ...): la imagen se ubica por su centro, así que la ponemos en el centro del lienzo.
• bg=BACKGROUND_COLOR: la imagen tiene esquinas redondeadas y sombra; sin esto se vería un fondo blanco detrás.
• highlightthickness=0: quita el borde que Tkinter dibuja alrededor del lienzo y de los botones.
• columnspan=2: el lienzo ocupa las columnas 0 y 1. Sin esto, el botón ✅ queda lejos a la derecha, porque la columna 0 se vuelve tan ancha como el lienzo. El curso muestra este error y lo corrige.
• El tamaño del texto de la palabra (60) es un ejemplo: la lección solo dice que es "más grande y en negrita" que el título.

Consejo del curso: al escribir rutas como "images/card_front.png" es fácil cometer errores de escritura. Usa el autocompletado del editor: escribe la carpeta, / y elige el archivo.

Detalle visual: en Windows y Mac queda una línea fina alrededor de los botones aunque pongas highlightthickness=0. El curso explica que es normal: le muestra al usuario que el botón se presionó.

⚠️ Errores frecuentes#

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: agrega una etiqueta debajo de los botones que diga "¿Conocías esta palabra?".
• 🟡 Reto 2: agrega un tercer texto en el lienzo, en la parte inferior de la tarjeta, que más adelante mostrará cuántas palabras faltan.
• 🟠 Reto 3: reemplaza las rutas escritas a mano por rutas construidas con Path(__file__).parent / "images" / "card_front.png". Ejecuta el programa desde otra carpeta y comprueba que sigue funcionando.
• 🔴 Reto 4: diseña la interfaz para una pantalla pequeña (por ejemplo, un portátil de 1366 × 768). ¿Cabe la ventana? ¿Qué cambiarías: el tamaño del lienzo, las imágenes o el margen? Justifica tu decisión.

🎯 Objetivo de aprendizaje#

• Convertir un CSV en una lista de diccionarios con pandas.
• Elegir un elemento al azar y mostrarlo en el lienzo con itemconfig.

📝 Ejercicio original del curso#

Enunciado:

1. Leer los datos de data/french_words.csv.
2. Elegir una palabra francesa al azar y mostrarla en la tarjeta. Cada vez que se pulse ❌ o ✅, debe aparecer una palabra nueva al azar.

Pista del curso: usar pandas para crear un DataFrame y convertirlo en una lista de diccionarios con DataFrame.to_dict(orient="records").

🔍 Antes de programar#

• ¿Qué forma tienen los datos del CSV? Abre el archivo y mira la primera línea.
• ¿Qué estructura es más cómoda para elegir "una fila al azar": un diccionario de columnas o una lista de filas?
• ¿Cómo cambias el texto de un elemento que ya existe en el lienzo?

📖 Explicación conceptual: las formas de to_dict#

Con un CSV de tres palabras:

French,English
partie,part
histoire,history
chaque,each

Forma por defecto (organizada por columnas):

data.to_dict()
# {'French': {0: 'partie', 1: 'histoire', 2: 'chaque'},
#  'English': {0: 'part', 1: 'history', 2: 'each'}}

Con orient="records" (organizada por filas, una lista de diccionarios):

data.to_dict(orient="records")
# [{'French': 'partie', 'English': 'part'},
#  {'French': 'histoire', 'English': 'history'},
#  {'French': 'chaque', 'English': 'each'}]

(Ambos resultados verificados con pandas 3.0.)

La segunda forma es perfecta para tarjetas: cada diccionario es una tarjeta, con su frente ("French") y su reverso ("English"). Así, random.choice elige una tarjeta completa.

🛠️ Nota técnica: la pista de la lección 237 dibuja el resultado como [{french_word: english_word}, ...], es decir, con la palabra francesa como clave. No es así: las claves son los nombres de las columnas, "French" y "English", como muestra el resultado verificado. La solución en video (238) sí lo usa correctamente: current_card["French"].

Cambiar un elemento del lienzo: create_text devuelve un identificador. Si lo guardas en una variable, después puedes modificarlo:

card_title = canvas.create_text(400, 150, text="", font=("Arial", 40, "italic"))
# ... más adelante:
canvas.itemconfig(card_title, text="French")

🔎 La solución del curso (estructura)#

import random
import pandas

data = pandas.read_csv("data/french_words.csv")
to_learn = data.to_dict(orient="records")

def next_card():
    current_card = random.choice(to_learn)
    canvas.itemconfig(card_title, text="French")
    canvas.itemconfig(card_word, text=current_card["French"])

• Los dos botones reciben command=next_card (sin paréntesis: se pasa la función, no su resultado).
• Se llama next_card() una vez después de crear la interfaz y antes de mainloop(), para que la primera tarjeta no muestre los textos de prueba "Title" y "word".
• Las claves distinguen mayúsculas: el CSV dice French, con F mayúscula.

⚠️ Errores frecuentes#

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: imprime len(to_learn) al iniciar. ¿Coincide con el número de filas del CSV sin contar el encabezado?
• 🟡 Reto 2: evita que la misma palabra salga dos veces seguidas.
• 🟠 Reto 3: crea tu propio CSV de 20 palabras inglés–español con vocabulario de tu clase de inglés y haz que la aplicación funcione con él. ¿Qué tuviste que cambiar en el código? ¿Podrías cambiarlo en un solo lugar?
• 🔴 Reto 4: en lugar de elegir totalmente al azar, haz que las palabras aparezcan en el orden del diccionario de frecuencias (primero las más usadas). ¿Qué ventaja y qué desventaja tiene frente al azar?

🎯 Objetivo de aprendizaje#

• Programar una acción retrasada sin bloquear la interfaz, usando window.after.
• Cancelar un temporizador pendiente con after_cancel.
• Cambiar la imagen y el color de los elementos de un lienzo.

📝 Ejercicio original del curso#

Enunciado:

1. A los 3 segundos (3000 ms), la tarjeta se voltea y muestra la traducción al inglés de la palabra actual.
2. La imagen cambia a card_back.png, el texto se vuelve blanco y el título pasa de "French" a "English".

Pistas del curso:

1. Para cambiar la imagen del lienzo necesitas guardar la referencia que devuelve create_image y luego usar itemconfig(..., image=nueva_imagen).
2. Importante: los objetos PhotoImage no deben crearse dentro de una función.
3. El color del texto de un lienzo se cambia con el parámetro fill.
4. Dentro de mainloop() no uses time.sleep(); usa window.after().
5. Un window.after() se puede cancelar con window.after_cancel().

🔍 Antes de programar#

• flip_card necesita saber qué tarjeta está en pantalla. ¿Dónde está guardada esa información ahora? ¿Puede verla otra función?
• ¿Qué debe cambiar cuando se voltea la tarjeta? ¿Y qué debe volver a su estado inicial cuando aparece la siguiente?
• Si el usuario pulsa ✅ muy rápido cinco veces, ¿cuántos temporizadores quedan "contando"?

📖 Explicación conceptual#

¿Por qué no time.sleep(3)? mainloop() es un bucle que atiende constantemente la ventana: clics, dibujos, teclado. sleep congela ese bucle: la ventana no responde durante 3 segundos. window.after(3000, flip_card) en cambio le dice a Tkinter: "dentro de 3000 ms, llama a flip_card", y mientras tanto la ventana sigue funcionando. Ya lo usaste en el Pomodoro (Día 28).

after devuelve un identificador. Si lo guardas, puedes cancelarlo:

flip_timer = window.after(3000, func=flip_card)
window.after_cancel(flip_timer)

🔎 La solución del curso, construida por partes#

Parte 1 — Compartir la tarjeta actual. current_card estaba "encerrada" dentro de next_card. El curso la saca como variable global que empieza como diccionario vacío:

current_card = {}

def next_card():
    global current_card
    current_card = random.choice(to_learn)
    ...

def flip_card():
    canvas.itemconfig(card_title, text="English", fill="white")
    canvas.itemconfig(card_word, text=current_card["English"], fill="white")
    canvas.itemconfig(card_background, image=card_back_img)

Parte 2 — Cambiar la imagen. Se guarda la referencia de la imagen del lienzo (card_background = canvas.create_image(...)) y se crea card_back_img fuera de las funciones, junto a card_front_img.

Parte 3 — Devolver la tarjeta al frente. En next_card hay que deshacer el volteo: título "French", texto negro (fill="black") e imagen card_front_img.

Parte 4 — Repetir el volteo en cada tarjeta. Si window.after solo se llama al crear la ventana, la primera tarjeta se voltea, pero las siguientes no. Por eso next_card también programa el volteo.

Parte 5 — El error de los temporizadores acumulados. El curso lo muestra: si pulsas los botones muchas veces, la tarjeta se voltea de inmediato. ¿Por qué? Cada after sigue contando en segundo plano, sin importar que ya cambiaste de tarjeta. La solución es cancelar el temporizador anterior antes de crear uno nuevo:

flip_timer = window.after(3000, func=flip_card)   # justo después de crear la ventana

def next_card():
    global current_card, flip_timer
    window.after_cancel(flip_timer)
    current_card = random.choice(to_learn)
    # ... volver al frente y mostrar la palabra ...
    flip_timer = window.after(3000, func=flip_card)

🛠️ Nota técnica: la pista dice que un PhotoImage "no debe crearse dentro de una función, o no funcionará". La causa real es que, al terminar la función, la variable local desaparece y Python libera la imagen (recolección de basura); Tkinter se queda mostrando un espacio vacío. Se puede crear dentro de una función si se conserva una referencia (por ejemplo, en una variable global o en un atributo de un objeto). La regla del curso es la forma más sencilla de evitar el problema.

⚠️ Errores frecuentes#

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: convierte los 3000 ms en una constante FLIP_DELAY_MS y prueba con 1500 y con 5000. ¿Cuál es mejor para estudiar?
• 🟡 Reto 2: permite voltear la tarjeta manualmente haciendo clic sobre ella (investiga canvas.bind("<Button-1>", ...)), además del volteo automático.
• 🟠 Reto 3: muestra una cuenta regresiva (3, 2, 1) en una esquina de la tarjeta antes de voltear, usando after cada segundo como en el Pomodoro.
• 🔴 Reto 4: reescribe la aplicación con una clase FlashyApp en la que current_card, flip_timer y las imágenes sean atributos, sin ninguna variable global. ¿Qué ventajas tiene? (En el Día 34 el curso construye una interfaz Tkinter con clases.)

🎯 Objetivo de aprendizaje#

• Eliminar elementos de una lista y guardar la lista como CSV.
• Elegir entre dos fuentes de datos según exista o no un archivo, usando try/except/else.

📝 Ejercicio original del curso#

Enunciado:

1. Si el usuario pulsa ✅, la palabra actual se elimina de la lista de palabras que pueden salir.
2. La lista actualizada se guarda en un archivo nuevo: words_to_learn.csv.
3. Al iniciar, el programa revisa si existe words_to_learn.csv. Si existe, usa esas palabras; si no (la primera vez), usa french_words.csv.

Ejemplo del curso: si french_words.csv tuviera chaque,each, parlé,speak y arrivé,come, y el usuario marca que conoce parlé, words_to_learn.csv quedaría solo con chaque y arrivé.

Pistas del curso: list.remove(), DataFrame.to_csv() y el parámetro index=False.

🔍 Antes de programar#

• ¿Qué hace ❌ ahora y qué debe hacer ✅? ¿Siguen llamando a la misma función?
• ¿En qué momento conviene guardar el archivo: al cerrar la aplicación o cada vez que se pulsa ✅? ¿Qué pasa si la aplicación se cierra de forma inesperada?
• ¿Qué línea puede fallar la primera vez que se ejecuta el programa?

🔎 La solución del curso, paso a paso#

1. Una función nueva para ✅. El botón ❌ sigue con next_card; el ✅ ahora llama a is_known:

def is_known():
    to_learn.remove(current_card)
    data = pandas.DataFrame(to_learn)
    data.to_csv("data/words_to_learn.csv", index=False)
    next_card()

remove busca en la lista un diccionario igual a current_card y elimina el primero que encuentra (verificado).

2. Elegir la fuente de datos. Es el patrón del Día 30:

try:
    data = pandas.read_csv("data/words_to_learn.csv")
except FileNotFoundError:
    original_data = pandas.read_csv("data/french_words.csv")
    to_learn = original_data.to_dict(orient="records")
else:
    to_learn = data.to_dict(orient="records")

3. Guardar junto a los otros datos. La primera versión del curso guardaba words_to_learn.csv en la carpeta principal; luego lo movió a data/ para mantener el proyecto ordenado.

📖 El error de las columnas que se multiplican#

El curso encontró un error "extraño": cada vez que se ejecutaba el programa, words_to_learn.csv tenía una columna más. Así se ve, paso a paso (verificado):

pandas guarda por defecto el índice (los números de fila) como primera columna. Al leer, esa columna se convierte en un dato más (Unnamed: 0), y al guardar se agrega otro índice. La solución: to_csv(..., index=False).

🛠️ Nota técnica: la pista 2 de la lección 241 habla de crear un CSV "a partir de un diccionario". En realidad, to_learn es una lista de diccionarios; pandas.DataFrame(to_learn) la convierte en tabla (una fila por diccionario).

⚠️ Errores frecuentes#

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: muestra en la ventana cuántas palabras quedan por aprender y actualízalo al pulsar ✅.
• 🟡 Reto 2: agrega un botón Reiniciar que borre words_to_learn.csv (con confirmación, messagebox.askyesno) para empezar de cero. (Pista: Path.unlink() del Día 24.)
• 🟠 Reto 3: además de las palabras que faltan, guarda en data/learned.csv las que ya aprendiste, con la fecha en que las marcaste. (Pista: datetime, que se estudia a fondo el Día 32.)
• 🔴 Reto 4: ahora mismo, pulsar ❌ no cambia nada. Diseña un sistema en el que las palabras que fallas aparezcan más seguido (por ejemplo, contando fallos por palabra). ¿Qué columna nueva necesitaría el CSV?

Problema#

Integrar los cuatro pasos en una aplicación de estudio funcional, probada y robusta.

Contexto#

El curso cierra con esta idea: la aplicación sirve para cualquier cosa que se estudie con "frente y reverso": idiomas, términos de programación, historia o geografía. Tú decides qué mazo construir.

Requisitos funcionales#

1. Tarjeta con título e idioma al frente; a los 3 segundos se voltea y muestra la traducción.
2. ❌ muestra otra palabra; ✅ la elimina del mazo y muestra otra.
3. El temporizador se reinicia con cada tarjeta nueva.
4. El progreso se guarda en data/words_to_learn.csv sin columnas de índice.
5. La primera ejecución usa french_words.csv sin errores.

Restricciones técnicas#

Tkinter con Canvas y grid; pandas para leer y guardar; window.after (nunca sleep); try/except/else para elegir el archivo; todos los PhotoImage fuera de las funciones.

Planificación#

1. Entradas: clics en ❌ y ✅, y los archivos CSV.
2. Estado: to_learn, current_card, flip_timer.
3. Salidas: la tarjeta en pantalla y words_to_learn.csv.
4. Construye en el orden del curso: interfaz → tarjetas → volteo → progreso. Ejecuta después de cada paso.

Pruebas#

🧪 Prueba y depuración: ¿qué pasa cuando aprendes todo?#

Usa un CSV con 3 palabras para probar rápido.

1. Durante la sesión. Marca ✅ tres veces. Al eliminar la última, next_card() ejecuta random.choice([]) y aparece IndexError: Cannot choose from an empty sequence (verificado). La ventana sigue abierta pero los botones ya no funcionan.
2. En la siguiente ejecución. Guardar una lista vacía produce un archivo que solo contiene un salto de línea. Al leerlo, pandas lanza EmptyDataError: No columns to parse from file (verificado), y el except FileNotFoundError del curso no lo captura: la aplicación ni siquiera abre.

Actividad:

• Reproduce los dos errores y copia los mensajes en tu cuaderno.
• Decide qué debería pasar cuando el usuario aprende todas las palabras (¿un mensaje de felicitación?, ¿reiniciar el mazo?, ¿desactivar los botones?) e impleméntalo.
• Protege la lectura del archivo para que un words_to_learn.csv vacío o dañado no impida abrir la aplicación. (Pista: pandas.errors.EmptyDataError.)

⭐ Extensión del proyecto#

• Contador de palabras aprendidas y restantes.
• Teclas rápidas: ← para ❌ y → para ✅ (window.bind).
• Selector de mazo al iniciar (francés, inglés, términos de programación).
• Estadística al cerrar: cuántas palabras aprendiste en la sesión.

Situación#

Los estudiantes de grado 11 del colegio se preparan para las Pruebas Saber 11. El grupo de décimo quiere dejarles una herramienta: una aplicación de tarjetas con varios mazos (por ejemplo, Ciencias Naturales, Sociales y Ciudadanas, e Inglés), escritos por los propios estudiantes.

Requisitos#

1. Un CSV por mazo, con las columnas Pregunta,Respuesta (mínimo 15 tarjetas por mazo, redactadas y revisadas por el grupo).
2. Al iniciar, el usuario elige el mazo (con botones o un menú).
3. Voltear con retraso, ❌ y ✅ como en Flashy.
4. El progreso se guarda por mazo (un archivo de pendientes para cada uno).
5. Un archivo estadisticas.json guarda, por mazo, cuántas veces se respondió cada tarjeta con ❌ y con ✅.
6. Al terminar un mazo, un mensaje de felicitación y la opción de reiniciarlo.
7. Ningún archivo faltante, vacío o dañado debe cerrar la aplicación.

Decisiones que debes tomar#

• Las preguntas pueden ser más largas que una palabra. ¿Cómo haces que el texto quepa en la tarjeta? (Investiga el parámetro width de create_text.)
• ¿El retraso para voltear debe ser igual para todos los mazos?
• ¿Guardas las estadísticas en JSON o en CSV? Justifica.

Casos de prueba#

Situación problema#

Muchos estudiantes dicen que "estudian", pero no saben cuánto ni qué estudiaron. El comité académico del colegio propone una aplicación de escritorio que combine un temporizador Pomodoro con tarjetas de estudio y lleve un registro del tiempo y del progreso.

Pregunta orientadora#

¿Cómo integrar en una sola aplicación bien organizada lo que aprendimos sobre clases, archivos, datos, interfaces gráficas y manejo de errores, para ayudar a un estudiante a estudiar mejor?

Objetivo#

Construir la Estación de Estudio: una aplicación Tkinter que alterna bloques de estudio con tarjetas y descansos, y guarda estadísticas de cada sesión.

Requerimientos#

1. Clases propias (mínimo 3), por ejemplo: Tarjeta, Mazo (carga, elimina y guarda tarjetas) y EstacionApp (la interfaz). Ninguna variable global.
2. Pomodoro: bloques de estudio y descanso con after; durante el estudio se muestran tarjetas; durante el descanso, los botones se desactivan.
3. Mazos en CSV leídos con pandas; el progreso de cada mazo se guarda sin columnas de índice.
4. Estadísticas en JSON: por fecha, minutos estudiados y tarjetas marcadas con ✅ y ❌.
5. Al menos una comprensión de listas o diccionarios (por ejemplo, para calcular el porcentaje de aciertos por mazo).
6. Rutas construidas con pathlib (Día 24).
7. Manejo de FileNotFoundError, EmptyDataError y JSONDecodeError: la aplicación nunca se cierra por un archivo.
8. Una ventana de resumen con las estadísticas de los últimos 7 días.

Restricciones#

• Solo bibliotecas vistas en el curso (Tkinter, pandas, json, random, pathlib, datetime básico).
• Todos los valores configurables (minutos, retraso de volteo, colores) como constantes en mayúsculas.

Etapas de desarrollo#

Entregables#

• Código en varios archivos (una clase por archivo como mínimo para Mazo y EstacionApp).
• Diagrama de clases y boceto de la interfaz.
• Al menos 12 casos de prueba con resultados.
• Registro de errores con al menos 6 errores reales y su solución.
• Video corto de una sesión de estudio.

Casos de prueba mínimos#

Criterios técnicos de funcionamiento#

• La clase Mazo se puede usar y probar sin la interfaz.
• No hay código repetido para cargar o guardar archivos.
• Ninguna acción del usuario congela la ventana (no hay sleep).
• Otro estudiante puede agregar un mazo nuevo sin tocar el código, solo agregando un CSV.

Posibles extensiones#

Gráfica de progreso semanal (con lo que se verá en días posteriores), sonido al terminar un bloque, envío del resumen por correo (Día 32).

Conceptuales#

1. ¿Por qué la tarjeta usa un Canvas y no un Label?
2. ¿Qué diferencia hay entre data.to_dict() y data.to_dict(orient="records")? ¿Cuál conviene para elegir una tarjeta al azar y por qué?
3. ¿Por qué no se puede usar time.sleep(3) para voltear la tarjeta?
4. ¿Qué es un "diccionario de frecuencias" y por qué ayuda a aprender un idioma?

Análisis de código#

try:
    data = pandas.read_csv("data/words_to_learn.csv")
except FileNotFoundError:
    original_data = pandas.read_csv("data/french_words.csv")
    to_learn = original_data.to_dict(orient="records")
else:
    to_learn = data.to_dict(orient="records")

¿Qué bloque se ejecuta la primera vez que se abre la aplicación? ¿Y la segunda? ¿Qué pasaría si se eliminara el else y su contenido?

Predicción#

1. Un usuario pulsa ✅ cuatro veces seguidas en menos de un segundo sin after_cancel. ¿Cuántas veces se ejecutará flip_card en los siguientes 3 segundos?
2. Un CSV con 100 palabras se guarda tres veces seguidas sin index=False (leyendo el anterior cada vez). ¿Cuántas columnas tendrá el archivo final?

Depuración#

def next_card():
    current_card = random.choice(to_learn)
    canvas.itemconfig(card_word, text=current_card["French"])

def flip_card():
    canvas.itemconfig(card_word, text=current_card["English"])

Con current_card = {} definido arriba, la tarjeta se voltea y el programa muestra un error. ¿Cuál? ¿Por qué? ¿Cómo se corrige?

def flip_card():
    card_back_img = PhotoImage(file="images/card_back.png")
    canvas.itemconfig(card_background, image=card_back_img)

Al voltear, la tarjeta queda vacía. ¿Por qué?

Modificación#

Cambia la aplicación para que la tarjeta muestre primero el inglés y al voltear el francés. ¿Cuántos lugares del código tuviste que modificar? ¿Cómo podrías lograrlo cambiando una sola constante?

Creación#

Escribe una función porcentaje_aprendido(total_original, pendientes) que devuelva el porcentaje de palabras aprendidas redondeado a un decimal, y úsala para mostrar el progreso en la ventana.