100 Días de Código en Python — Día 7: Proyecto Ahorcado

🎯 Objetivo de aprendizaje#

• Descomponer un problema grande en pasos pequeños.
• Representar la lógica de un juego completo en un diagrama de flujo antes de programar.

📖 Explicación conceptual#

Frente a un proyecto grande, el error más común es empezar a escribir código de inmediato. El curso propone primero entender el juego (jugarlo o leer sus reglas) y luego dibujar su lógica.

"No hay una única respuesta correcta." Hay muchos diagramas válidos. Este es el del curso:

flowchart TD
    A([Inicio]) --> B[Elegir palabra al azar]
    B --> C[Generar un espacio en blanco por cada letra]
    C --> D[/El usuario adivina una letra/]
    D --> E{¿La letra está en la palabra?}
    E -- Sí --> F[Reemplazar los espacios por la letra]
    F --> G{¿Quedan espacios en blanco?}
    G -- Sí --> D
    G -- No --> W([Fin: ¡GANASTE!])
    E -- No --> H[Perder una vida]
    H --> I{¿Quedan vidas?}
    I -- Sí --> D
    I -- No --> L([Fin: PERDISTE])

📝 Ejercicio original del curso: tu propio diagrama#

Enunciado: antes de ver el diagrama del curso, dibuja tu propio diagrama de flujo del Ahorcado, en papel o en draw.io (se abre en otra pestaña).

🔍 Antes de dibujar#

• ¿Qué pasa primero, antes de que el usuario haga algo?
• ¿Qué ocurre cuando la letra es correcta? ¿Y cuando es incorrecta?
• ¿Cuándo termina el juego? (Hay dos formas de terminar.)
• ¿Qué parte del diagrama se repite? Esa será un bucle.

🧩 Comprueba lo aprendido: Tema 1#

• Compara tu diagrama con el del curso: ¿qué pasos olvidaste o agregaste?
• Señala en el diagrama del curso qué rombos serán if y qué flechas de regreso serán un while.
• Reto de diseño: agrega al diagrama la situación "el usuario repite una letra que ya había dicho".

Evidencia: tu diagrama, con las diferencias frente al del curso marcadas.

🎯 Objetivo de aprendizaje#

• Recorrer un string con for, letra por letra, igual que una lista.
• Normalizar la entrada con .lower().

📖 Explicación conceptual#

Un for también recorre strings:

for letra in "camello":
    print(letra)      # c, a, m, e, l, l, o (una por línea)

¿Por qué .lower()? Las palabras de la lista están en minúsculas. Si el usuario escribe A, la comparación "A" == "a" da False. Convertir todo a minúsculas antes de comparar evita el problema.

💡 Consejo del curso sobre la organización: en PyCharm, View → Tool Windows → TODO muestra todas las tareas pendientes del archivo en orden. Y la guía PEP 8 pide que los import vayan al inicio del archivo.

📝 Ejercicio original del curso: TODO del Paso 1#

1. Elegir al azar una palabra de word_list, guardarla en chosen_word e imprimirla (solo para probar).
2. Pedir al usuario una letra, guardarla en guess y convertirla a minúsculas.
3. Recorrer cada letra de chosen_word e imprimir "Correcto" si coincide con guess, o "Incorrecto" si no.

Resultado esperado: con camello y la letra a → Incorrecto, Correcto, Incorrecto, Incorrecto, Incorrecto, Incorrecto, Incorrecto.

El código inicial del curso (con word_list, por ejemplo ["aardvark", "baboon", "camel"]) no está incluido entre los archivos suministrados. Crea tu propia lista, en español y en minúsculas.

🔍 Antes de programar#

• ¿Qué función del Día 4 elige un elemento al azar de una lista?
• ¿Dónde aplicas .lower(): al guardar la entrada o al comparar?
• ¿Por qué se imprime la palabra elegida? ¿La dejarías en la versión final?

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: en lugar de imprimir "Correcto" o "Incorrecto" por cada letra, muestra al final cuántas veces aparece la letra en la palabra.
• 🟡 Reto 2: muestra también las posiciones (índices) donde aparece la letra.
• 🟠 Reto 3: recorre la palabra y cuenta cuántas vocales tiene, usando in "aeiou".
• 🔴 Reto 4: ¿qué pasa si la lista de palabras incluye "Árbol" (con mayúscula y tilde) y el usuario escribe a? Analiza el problema y propón dos soluciones: una al elegir las palabras y otra en el código.

🎯 Objetivo de aprendizaje#

• Construir un string carácter por carácter con un acumulador.
• Generar una "vista" de la palabra que muestre las letras acertadas y oculte las demás.

📖 Explicación conceptual#

Espacios en blanco: un string vacío al que se le suma un _ por cada letra.

espacios = ""
for posicion in range(len(palabra)):
    espacios += "_"

El curso llega a esto por pasos: primero prueba con range(1, 6) para una palabra de 5 letras, observa que el bucle se repite 5 veces y después generaliza con la longitud de la palabra. Probar con un valor fijo y luego generalizar es una buena estrategia.

La vista de la palabra (display): se recorre la palabra y, por cada letra, se agrega la letra si coincide con la adivinada, o un _ si no coincide.

📝 Ejercicio original del curso: TODO del Paso 2#

1. Crear un string vacío placeholder y, con un bucle, agregarle un _ por cada letra de chosen_word. Imprimirlo.
2. Crear display: recorrer la palabra y poner la letra adivinada en sus posiciones y _ en las demás. Imprimirlo.

Resultado esperado: palabra apple y letra p → _pp__.

⚠️ Errores frecuentes#

• Desfase por uno con range(1, len(palabra)): queda un espacio de menos.
• Inicializar display = "" fuera del bucle que recorre las letras: en este paso todavía no hay while, pero en el Paso 3 esto importará mucho.
• Espacios invisibles: si en lugar de "_" escribes "_ ", la longitud cambia y las comprobaciones posteriores podrían fallar.

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: muestra la vista con espacios entre los caracteres (_ p p _ _) para que se lea mejor. (Pista: investiga " ".join(...) o agrega el espacio al acumular.)
• 🟡 Reto 2: muestra también cuántas letras faltan por descubrir.
• 🟠 Reto 3: crea la vista con una lista en lugar de un string, y modifica solo las posiciones acertadas con índices (lista[i] = letra). Compara las dos técnicas.
• 🔴 Reto 4: si la palabra secreta fuera una frase con espacios ("tienda escolar"), ¿cómo mostrarías el espacio real sin convertirlo en _?

🎯 Objetivo de aprendizaje#

• Controlar un bucle while con una variable bandera (game_over).
• Usar el operador in / not in para buscar dentro de strings y listas.
• Conservar información entre vueltas del bucle.

📖 Explicación conceptual#

Variable bandera. Una variable booleana que indica si el juego terminó:

game_over = False
while not game_over:
    # ...jugar una ronda...
    if "_" not in display:
        game_over = True
        print("¡Ganaste!")

El operador in: pregunta si algo está contenido en otra cosa.

"_" in "c_mello"         # True
"z" not in "camello"     # True
"a" in ["a", "b"]        # True

Cómo recordar las letras acertadas. El curso descubre un problema: en cada vuelta, display se reconstruye desde cero y las letras acertadas antes se pierden. La solución es una lista correct_letters creada fuera del while, a la que se agrega cada acierto. Al construir display hay un tercer caso:

¿Por qué correct_letters va FUERA del while? Si se crea dentro, correct_letters = [] la vaciaría en cada vuelta. Es el mismo error del "acumulador reiniciado" del Día 5.

🛠️ Nota técnica: la transcripción llama a in "una función". Es un operador de pertenencia: no lleva paréntesis y se escribe entre dos valores.

📝 Ejercicio original del curso: TODO del Paso 3#

1. Usar un while para que el usuario pueda seguir adivinando. El juego termina cuando ya no quedan _ en display, y entonces se imprime "Ganaste".
2. Modificar el bucle for para conservar en display las letras acertadas en rondas anteriores.

🔍 Antes de programar#

• ¿Qué líneas del Paso 2 deben quedar dentro del while? ¿Cuáles fuera?
• ¿Cuál es la condición exacta de victoria?
• Consejo del curso: intenta resolverlo solo durante 10 a 20 minutos antes de ver la solución. "Sin la fase de pensamiento, no estamos aprendiendo."

⚠️ Errores frecuentes#

• Bucle infinito: olvidar game_over = True.
• Lista reiniciada: correct_letters = [] dentro del while.
• Sangría: que el if "_" not in display quede fuera del while (y nunca se revise) o dentro del for (y se revise demasiado pronto).

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: cuenta cuántos intentos le tomó al usuario ganar y muéstralo al final.
• 🟡 Reto 2: sin usar in, escribe tu propio bucle que determine si "_" está en display.
• 🟠 Reto 3: muestra en cada ronda la lista de letras ya acertadas, ordenada. (Investiga sorted().)
• 🔴 Reto 4: diseña una versión del juego sin la lista correct_letters, que mantenga display como una lista y solo cambie las posiciones acertadas. ¿Cuál diseño te parece más simple?

🎯 Objetivo de aprendizaje#

• Llevar un contador de vidas que termina el juego al llegar a 0.
• Usar el contador como índice de una lista de imágenes.
• Separar la lógica en condiciones independientes para facilitar la depuración.

📖 Explicación conceptual#

1. lives = 6 antes del bucle.
2. Si la letra no está en la palabra: lives -= 1. Si lives == 0, game_over = True y "Perdiste".
3. El curso escribe esta comprobación como un if guess not in chosen_word: aparte del for, en lugar de mezclarla con el if/elif/else que construye display. Lógica separada = código más fácil de depurar.
4. La lista stages contiene 7 dibujos ASCII, ordenados para que stages[lives] muestre el dibujo correcto: stages[6] es la horca vacía y stages[0] el ahorcado completo.

print(stages[lives])   # dentro del while, en cada ronda

Otra vez aparece la idea del Día 4: ordenar una lista para que coincida con un número evita escribir muchos if.

📝 Ejercicio original del curso: TODO del Paso 4#

1. Crear lives con valor 6.
2. Si guess no está en chosen_word, restar una vida. Si llega a 0, terminar el juego con "Perdiste".
3. Imprimir el dibujo de stages que corresponde a las vidas restantes.

La lista stages con el arte ASCII viene en el archivo inicial del curso, que no está incluido entre los materiales suministrados. Puedes dibujar tus propias 7 etapas.

⚠️ Errores frecuentes#

• Orden invertido de las etapas: si stages[0] fuera la horca vacía, el dibujo avanzaría al revés. Imprime stages[0] y stages[6] para verificar.
• Restar la vida dentro del for: se restaría una vida por cada letra de la palabra que no coincide. ¡Perderías todas las vidas en un solo intento!

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1: cambia el número de vidas a 8 y ajusta los dibujos. ¿Qué otras partes del código hay que cambiar?
• 🟡 Reto 2: muestra las letras falladas en cada ronda.
• 🟠 Reto 3: en vez de dibujos, muestra una barra de vidas con emojis: ❤️❤️❤️🖤🖤🖤. (Pista: "❤️" * lives.)
• 🔴 Reto 4: ¿qué pasa si el jugador repite una letra incorrecta? Pruébalo. Con la lógica del curso, repetir z tres veces cuesta 3 vidas. ¿Es justo? Diseña la corrección (ver Paso 5).

🎯 Objetivo de aprendizaje#

• Organizar el programa en varios archivos (módulos) y usar import y from ... import ....
• Mejorar la experiencia de usuario (UX) con mensajes claros.

📖 Explicación conceptual#

Dos formas de importar:

import hangman_words
palabra = random.choice(hangman_words.word_list)   # nombre_del_módulo.cosa

from hangman_art import stages, logo               # importar cosas específicas
print(logo)                                        # se usan sin el prefijo

Experiencia de usuario (UX). El curso insiste en dar retroalimentación: el jugador debe saber siempre qué pasó y cómo va.

• "Ya adivinaste la letra r" (sin quitar una vida).
• "Adivinaste d, esa letra no está en la palabra. Pierdes una vida."
• "Te quedan 4/6 vidas."
• Al perder, revelar la palabra: "La palabra era: camello". El curso dice: "Nunca es bueno frustrar demasiado a los usuarios."

📝 Ejercicio original del curso: TODO del Paso 5#

1. Importar word_list desde hangman_words.py.
2. Importar stages desde hangman_art.py.
3. Importar e imprimir logo al inicio.
4. Si el usuario repite una letra ya acertada, avisarle sin restar vidas.
5. Si la letra no está en la palabra, decírselo.
6. Mostrar las vidas restantes en formato "X/6".
7. Al perder, mostrar la palabra correcta.

Los archivos hangman_words.py y hangman_art.py del curso no están incluidos entre los materiales suministrados: créalos tú. Esto es parte de la práctica con módulos.

🛠️ Nota técnica: la comprobación del curso ("¿la letra ya está en correct_letters?") solo detecta letras acertadas repetidas. Una letra incorrecta repetida sigue quitando vidas (lo comprobamos: repetir z tres veces cuesta 3 vidas). Mejora propuesta: guarda todas las letras intentadas en una lista letras_intentadas y revísala antes de cualquier otra cosa.

🛠️ Nota técnica: si el usuario presiona Enter sin escribir nada, guess es "", y "" in "camello" es True (el string vacío "está" en cualquier string). El intento vacío no cuesta vidas y el juego no avisa nada. Mejora propuesta: valida que la entrada sea exactamente una letra, con len(guess) == 1 y guess.isalpha().

Requisitos funcionales (versión final del curso)#

1. Mostrar el logo al inicio.
2. Elegir una palabra al azar de un módulo aparte.
3. Mostrar los espacios en blanco y pedir letras hasta ganar o perder.
4. Mostrar la palabra parcialmente descubierta, conservando los aciertos anteriores.
5. Controlar 6 vidas, mostrar el dibujo que corresponde y "X/6 vidas restantes".
6. Retroalimentación: letra repetida, letra incorrecta, victoria y derrota revelando la palabra.

Pruebas#

(Para probar, fija temporalmente chosen_word = "camello". Recuerda quitarlo al final.)

🧪 Prueba y depuración#

Este fragmento tiene cuatro errores. Encuéntralos usando la tabla de pruebas:

lives = 6
game_over = False
while not game_over:
    correct_letters = []
    guess = input("Adivina una letra: ").lower()
    display = ""
    for letter in chosen_word:
        if letter == guess:
            display += letter
            correct_letters.append(letter)
        elif letter in correct_letters:
            display += letter
        else:
            display += "_"
            lives -= 1
    if "_" not in display:
        game_over = True
        print("¡Ganaste!")
    if lives == 0:
        print("Perdiste")
    print(stages[lives])

(Pistas: una lista que se reinicia, vidas que se restan donde no deben, un juego que no termina al perder y un posible IndexError.)

⭐ Extensión del proyecto#

• Mostrar las letras ya intentadas, ordenadas.
• Dar una pista (revelar una letra) a cambio de una vida.
• Preguntar "¿Jugar otra vez?" al terminar, usando otro while que envuelva todo el juego.

Situación#

Construir una versión de consola de un juego en el que hay que adivinar una palabra de 5 letras en 6 intentos. Después de cada intento, el juego da pistas por posición:

Requisitos#

1. Lista de palabras de 5 letras, en español, sin tildes y en minúsculas.
2. Validar que el intento tenga exactamente 5 letras. Si no, avisar sin gastar un intento.
3. Por cada intento, recorrer las posiciones con for i in range(5) y construir la línea de pistas.
4. Ganar si todas las pistas son 🟩. Perder después de 6 intentos, revelando la palabra.

Casos de prueba (palabra secreta: perro)#

💡 Diferencia con el Ahorcado: aquí importa la posición (índices), no solo la pertenencia (in). Discute: en la versión simple, ¿qué pasa con las letras repetidas? Por ejemplo, con el intento error y la palabra perro. ¿Cómo lo resolvería el juego original?

⭐ Extensión#

Muestra un "teclado" con las letras ya descartadas.

Situación problema#

La profesora de Ciencias Naturales quiere usar el Ahorcado para repasar vocabulario de varias materias, con distintos niveles de dificultad.

Pregunta orientadora#

¿Cómo convertir un juego que ya funciona en una herramienta configurable sin reescribirlo desde cero?

Requerimientos#

1. Un módulo palabras.py con una lista anidada de categorías, por ejemplo: [["ciencias", "celula", "atomo", ...], ["matematicas", "fraccion", ...], ...]. El primer elemento de cada sublista es el nombre de la categoría.
2. Un menú que muestre las categorías numeradas (con un for) y permita elegir una.
3. Elegir la dificultad: fácil (8 vidas), normal (6) o difícil (4). La cantidad de vidas depende del nivel, así que no puedes usar stages[lives] directamente: diseña otra forma de mostrar el progreso.
4. Toda la lógica del Ahorcado, con las dos mejoras del Paso 5: letras intentadas y validación de la entrada.
5. Puntaje: 10 puntos por letra acertada, más un bonus por las vidas restantes al ganar.
6. Al terminar, preguntar "¿Jugar otra vez? (s/n)" y acumular el puntaje entre partidas.
7. Funciones sin parámetros para mostrar el logo, las instrucciones y la despedida.

Etapas#

1. Módulo de palabras y menú de categorías.
2. Niveles y barra de vidas.
3. Integrar el juego, con sus mejoras.
4. Puntaje.
5. Bucle "jugar otra vez".

Entregables#

Código en al menos 2 archivos (principal y palabras.py), diagrama de flujo actualizado y tabla de pruebas.

Criterios técnicos#

• Ningún IndexError con entradas inválidas en los menús.
• Las letras repetidas nunca restan vidas.
• El puntaje se acumula correctamente entre partidas.

Posibles extensiones#

• Guardar el mejor puntaje de la sesión.
• Mostrar una definición de la palabra al terminar (requiere una lista paralela de definiciones).