100 Días de Código en Python — Día 86: Proyecto de portafolio — Test de velocidad de escritura

📝 Contenido original del curso#

Usando Tkinter y lo que aprendiste sobre aplicaciones gráficas con Python, construye una aplicación de escritorio que evalúe tu velocidad de escritura. Dale al usuario un texto de muestra y detecta cuántas palabras por minuto puede escribir.

La velocidad promedio de escritura es de 40 palabras por minuto; con práctica puedes llegar a 100. (El enunciado enlaza un artículo de typing.com sobre la velocidad promedio y una versión web del test: typing-speed-test.aoeu.eu.)

Si tienes más tiempo, convierte tu test en un entrenador de mecanografía, con puntajes máximos y más textos de muestra. Puedes diseñar el programa como quieras.

Pregunta de la tarea — Momento de reflexión: cómo abordaste el proyecto; qué fue difícil y qué fácil; cómo mejorarías; tu mayor aprendizaje; qué harías distinto.

Prerequisitos: Tkinter y el temporizador del Pomodoro con after (Días 27–28); manejo de archivos y JSON (Días 24 y 30); listas, cadenas y random (Días 2 y 4); funciones con retorno (Día 10).

🔍 Antes de programar#

Dos formatos de test#

🎯 Objetivo de aprendizaje#

Traducir una definición (palabras por minuto) a una fórmula y a una función que se pueda probar.

📖 Explicación conceptual#

¿Qué es una "palabra"? Si contamos palabras reales, escribir "sol" no vale lo mismo que "electroencefalograma". Por eso los tests de mecanografía usan la palabra estándar = 5 caracteres (incluidos espacios y signos).

Ejemplo a mano: escribes 200 caracteres en 60 s → 200 ÷ 5 = 40 palabras en 1 minuto → 40 PPM. Si fueron 30 s: 40 ÷ 0,5 = 80 PPM.

🔎 Ejemplo explicado#

def contar_correctos(modelo, escrito):
    return sum(1 for a, b in zip(modelo, escrito) if a == b)

def ppm_brutas(escrito, segundos):
    if segundos <= 0:
        return 0
    return (len(escrito) / 5) / (segundos / 60)

• zip(modelo, escrito) recorre ambos textos a la par: primer carácter con primer carácter, etc. Se detiene en el más corto.
• sum(1 for ... if a == b) cuenta cuántas parejas coinciden (una expresión generadora, pariente de la comprensión de listas del Día 26).
• if segundos <= 0: return 0 evita un ZeroDivisionError si el tiempo no ha empezado.

Tu turno: escribe ppm_netas(modelo, escrito, segundos) y precision(modelo, escrito) (cuidado con el texto vacío). Comprueba: ppm_netas("el perro come", "el perro come", 6) debe dar 26.0.

⚠️ Una limitación importante (analízala)#

La comparación posición a posición es muy estricta: si el usuario omite una letra, todo lo que sigue queda "corrido" y cuenta como error. Comprobado: contar_correctos("hola", "hla") da 1, aunque solo faltó una letra.

Alternativas (elige una y justifícala en tu diario):

1. Comparar palabra por palabra (modelo.split() y escrito.split()): una palabra mal escrita no arrastra a las demás.
2. No dejar avanzar mientras haya un error (como algunos tests en línea): el usuario debe corregir con Retroceso.
3. Usar difflib.SequenceMatcher (biblioteca estándar) para medir el parecido: más justo, pero más difícil de explicar.

⚠️ Errores frecuentes#

Dos herramientas clave#

⚠️ Nunca uses time.sleep() en una app Tkinter: congela la ventana entera. after programa la tarea y deja que mainloop siga atendiendo al usuario.

🔎 Esqueleto#

import time
import tkinter as tk

TEXTO = "La práctica constante mejora la velocidad y la precisión."
DURACION = 60

ventana = tk.Tk()
ventana.title("Test de mecanografía")

tk.Label(ventana, text=TEXTO, wraplength=500, font=("Arial", 14)).pack(pady=10)
entrada = tk.Text(ventana, height=4, width=60, font=("Arial", 14))
entrada.pack()
reloj = tk.Label(ventana, text=f"{DURACION} s")
reloj.pack()

inicio = None

def al_teclear(evento):
    global inicio
    if inicio is None:                  # la primera tecla inicia el reloj
        inicio = time.perf_counter()
        cuenta_regresiva(DURACION)
    escrito = entrada.get("1.0", "end-1c")
    # Tu turno: comparar con TEXTO y actualizar una etiqueta de errores

def cuenta_regresiva(restante):
    reloj.config(text=f"{restante} s")
    if restante > 0:
        ventana.after(1000, cuenta_regresiva, restante - 1)
    else:
        entrada.config(state="disabled")
        # Tu turno: calcular y mostrar PPM y precisión

entrada.bind("<KeyRelease>", al_teclear)
ventana.mainloop()

Puntos clave:

• entrada.get("1.0", "end-1c"): en un Text, "1.0" es línea 1, carácter 0; "end-1c" quita el salto de línea que Tkinter agrega siempre al final.
• after(1000, cuenta_regresiva, restante - 1): los argumentos extra se pasan a la función. La función se reprograma a sí misma cada segundo.
• state="disabled" impide seguir escribiendo cuando se acaba el tiempo.

Resaltar errores (idea): un Text admite etiquetas (tags) de formato. Con entrada.tag_config("error", background="#ffb3b3") y entrada.tag_add("error", "1.5", "1.6") pintas de rojo el carácter 5. Elimina las marcas anteriores con tag_remove antes de volver a pintar.

⚠️ Errores frecuentes#

Problema#

Construir una aplicación de escritorio que muestre un texto, mida la velocidad de escritura del usuario y le dé su resultado.

Contexto#

En la clase de tecnología se quiere medir el progreso en mecanografía durante el periodo, sin depender de páginas web con publicidad.

Objetivo#

Una app Tkinter que mida PPM netas y precisión, con varios textos y un registro de mejores puntajes.

Requisitos funcionales#

1. Muestra un texto de muestra elegido al azar de una lista (o de un archivo).
2. El tiempo empieza con la primera tecla y termina a los 60 s (o al completar el texto, según tu diseño).
3. Muestra PPM netas y precisión al final.
4. Permite reiniciar con otro texto.

Restricciones técnicas#

• Cálculos en funciones separadas y probadas con assert (sección 3).
• Tiempo con after, nunca con sleep.
• Textos de muestra en un archivo (textos.txt o textos.json), no escritos dentro del código.

Planificación#

1. Comprender cómo funciona un test real (prueba la versión web del enunciado). 2. Entradas: teclas del usuario. 3. Procesos: iniciar reloj → comparar → terminar → calcular. 4. Salidas: PPM, precisión, errores resaltados. 5. Dividir en cálculos, interfaz y datos. 6. Bocetar la ventana. 7. Implementar. 8. Probar. 9. Corregir. 10. Mejorar.

Construcción paso a paso#

• Versión 1 — Cálculos en consola: las funciones de la sección 3 con sus pruebas. Simula: ppm_netas(modelo, escrito, 45).
• Versión 2 — Ventana: texto de muestra, área de escritura, reloj que baja al teclear la primera letra.
• Versión 3 — Resultado: al terminar el tiempo, bloquear la escritura y mostrar PPM y precisión.
• Versión 4 — Retroalimentación en vivo: resaltar errores mientras se escribe.
• Versión 5 — Varios textos y reinicio: textos desde archivo, botón "Otra vez" (con after_cancel).
• Versión final — Mejores puntajes: guardar en puntajes.json los 5 mejores (fecha, PPM, precisión); README.md y diario.

Pruebas#

🧪 Prueba y depuración#

def al_teclear(evento):
    inicio = time.time()
    cuenta_regresiva(60)
    escrito = entrada.get()
    ppm = len(escrito.split()) / (time.time() - inicio)

Encuentra cuatro problemas: inicio se reinicia en cada tecla (y es local); la cuenta regresiva se lanza en cada tecla; get() sin índices falla en un Text; y las PPM usan palabras reales, segundos en vez de minutos y un tiempo casi cero (división por un número diminuto o por cero).

⭐ Extensión del proyecto#

• 🟢 Reto 1 — Aplicación: muestra también las PPM en vivo cada segundo.
• 🟡 Reto 2 — Ampliación: tabla de mejores puntajes por usuario (nombre o alias) en JSON.
• 🟠 Reto 3 — Desafío: estadísticas de errores: ¿qué letras falla más el usuario? Guárdalas y muestra las 5 peores al final (pista: diccionario o collections.Counter).
• 🔴 Reto 4 — Pensamiento computacional: con las estadísticas del reto 3, genera textos de práctica que incluyan con más frecuencia las letras que el usuario falla. Diseña la estrategia y comprueba en 3 sesiones si la precisión mejora.

Situación#

El área de inglés quiere una app para practicar la ortografía de palabras del periodo: se muestra la palabra en español (o se escucha, como extensión) y el estudiante escribe la traducción contra reloj.

Requisitos#

1. Leer las palabras desde un CSV (español, inglés) (Día 25; parecido a las tarjetas del Día 31).
2. Límite de 10 segundos por palabra con after; si se acaba, cuenta como error y pasa a la siguiente.
3. Al final: aciertos, errores y la lista de palabras falladas, guardada para repasarla.

Decisiones que debes tomar (y justificar)#

• ¿Aceptas "Colour" y "color"? ¿Mayúsculas? ¿Espacios al final?
• ¿Cómo haces que las palabras falladas aparezcan con más frecuencia en la próxima sesión?

Casos de prueba#

• Responder a los 9,9 s cuenta; a los 10 s, no.
• Una respuesta con espacios de más (" dog ") se acepta.

Conceptuales#

1. ¿Por qué se usa la "palabra estándar" de 5 caracteres?
2. ¿Qué diferencia hay entre PPM brutas y netas?
3. ¿Por qué time.sleep congela una app Tkinter y after no?
4. ¿Para qué sirve after_cancel?

Análisis de código#

sum(1 for a, b in zip("gato", "gata") if a == b)

¿Qué devuelve y por qué?

Predicción#

¿Cuántas PPM brutas obtiene quien escribe 150 caracteres en 45 segundos?

Depuración#

"Mi reloj baja de 2 en 2 y a veces de 3 en 3." ¿Cuál es la causa más probable?

Modificación#

Cambia el formato del test a "texto fijo": el tiempo termina cuando lo escrito es igual al modelo.

Creación#

Escribe comparar_palabras(modelo, escrito) que devuelva cuántas palabras están bien escritas, comparando palabra por palabra.