El juego del ahorcado es un proyecto clásico para practicar cadenas, conjuntos, bucles, condiciones, selección aleatoria, validación y funciones. El programa elige una palabra secreta, el jugador propone letras y cada error reduce las vidas disponibles.
En esta guía construiremos un juego del ahorcado en Python que evita intentos repetidos, acepta letras o palabras completas, muestra dibujos ASCII, utiliza pistas y separa la lógica en funciones fáciles de probar.
Reglas del juego
- El programa selecciona una palabra.
- Muestra guiones para las letras ocultas.
- El jugador escribe una letra o una palabra completa.
- Las letras correctas se revelan en todas sus posiciones.
- Los intentos nuevos e incorrectos reducen una vida.
- La ronda termina al completar la palabra o perder todas las vidas.
La selección utiliza el módulo random de Python.
Elegir una palabra secreta
import random
PALABRAS = ["python", "variable", "funcion", "iterador", "paquete"]
palabra_secreta = random.choice(PALABRAS)random.choice() es adecuado porque el juego no protege ningún dato sensible.
Guardar letras en un set
letras_probadas = set()
letras_probadas.add("p")
print("p" in letras_probadas) # TrueUn conjunto mantiene valores únicos y permite detectar repeticiones con una comprobación directa.
Crear la palabra oculta
def palabra_oculta(secreta, letras):
return " ".join(
letra if letra in letras else "_"
for letra in secreta
)
print(palabra_oculta("python", {"p", "o"}))
# p _ _ _ o _La función devuelve texto en lugar de imprimirlo. Así puede reutilizarse y probarse.
Comprobar la victoria
def palabra_completa(secreta, letras):
return all(letra in letras for letra in secreta)all() devuelve verdadero cuando todas las letras cumplen la condición. Las letras repetidas se revelan automáticamente en todas sus posiciones.
Validar la entrada
def leer_intento():
while True:
intento = input(
"Escribe una letra o la palabra completa: "
).strip().lower()
if not intento:
print("Escribe una letra o palabra.")
continue
if not intento.isalpha():
print("Utiliza solamente letras.")
continue
return intentoisalpha() acepta letras Unicode. Mantén palabras e intentos con la misma normalización.
Evitar intentos repetidos
if intento in letras_probadas:
print("Ya probaste esa letra.")
continue
letras_probadas.add(intento)Un intento repetido no debería restar una vida.
Etapas del dibujo
ETAPAS = [
"""
+---+
| |
|
|
|
|
=========
""",
"""
+---+
| |
O |
|
|
|
=========
""",
"""
+---+
| |
O |
| |
|
|
=========
""",
"""
+---+
| |
O |
/| |
|
|
=========
""",
"""
+---+
| |
O |
/|\ |
|
|
=========
""",
"""
+---+
| |
O |
/|\ |
/ |
|
=========
""",
"""
+---+
| |
O |
/|\ |
/ \ |
|
=========
""",
]Con siete etapas, el jugador puede cometer seis errores.
Añadir palabras y pistas
BANCO = [
{"palabra": "python", "pista": "Lenguaje de programación"},
{"palabra": "iterador", "pista": "Produce valores uno a uno"},
{"palabra": "funcion", "pista": "Bloque reutilizable de código"},
{"palabra": "variable", "pista": "Nombre que se refiere a un valor"},
{"palabra": "paquete", "pista": "Colección distribuible de módulos"},
]Código completo
import random
ETAPAS = [
"""
+---+
| |
|
|
|
|
=========
""",
"""
+---+
| |
O |
|
|
|
=========
""",
"""
+---+
| |
O |
| |
|
|
=========
""",
"""
+---+
| |
O |
/| |
|
|
=========
""",
"""
+---+
| |
O |
/|\ |
|
|
=========
""",
"""
+---+
| |
O |
/|\ |
/ |
|
=========
""",
"""
+---+
| |
O |
/|\ |
/ \ |
|
=========
""",
]
BANCO = [
{"palabra": "python", "pista": "Lenguaje de programación"},
{"palabra": "iterador", "pista": "Produce valores uno a uno"},
{"palabra": "funcion", "pista": "Bloque reutilizable de código"},
{"palabra": "variable", "pista": "Nombre que se refiere a un valor"},
{"palabra": "paquete", "pista": "Colección distribuible de módulos"},
]
def palabra_oculta(secreta, letras):
return " ".join(
letra if letra in letras else "_"
for letra in secreta
)
def palabra_completa(secreta, letras):
return all(letra in letras for letra in secreta)
def leer_intento():
while True:
intento = input(
"Escribe una letra o la palabra completa: "
).strip().lower()
if not intento:
print("Escribe una letra o palabra.")
continue
if not intento.isalpha():
print("Utiliza solamente letras.")
continue
return intento
def jugar_ronda(generador=None):
generador = generador or random.Random()
entrada = generador.choice(BANCO)
secreta = entrada["palabra"].lower()
pista = entrada["pista"]
letras = set()
palabras = set()
errores = 0
max_errores = len(ETAPAS) - 1
print(f"Pista: {pista}")
while errores < max_errores:
print(ETAPAS[errores])
print(palabra_oculta(secreta, letras))
print(f"Vidas: {max_errores - errores}")
if letras:
print("Letras:", " ".join(sorted(letras)))
intento = leer_intento()
if len(intento) == 1:
if intento in letras:
print("Ya probaste esa letra.")
continue
letras.add(intento)
if intento in secreta:
print("¡Letra correcta!")
else:
errores += 1
print("La letra no aparece.")
else:
if intento in palabras:
print("Ya probaste esa palabra.")
continue
palabras.add(intento)
if intento == secreta:
letras.update(secreta)
else:
errores += 1
print("No es la palabra secreta.")
if palabra_completa(secreta, letras):
print(palabra_oculta(secreta, letras))
print("¡Ganaste!")
return True
print(ETAPAS[errores])
print(f"Perdiste. La palabra era: {secreta}")
return False
def quiere_repetir():
while True:
respuesta = input("¿Jugar otra vez? [s/n]: ").strip().lower()
if respuesta in {"s", "si", "sí"}:
return True
if respuesta in {"n", "no"}:
return False
print("Escribe s o n.")
def main():
print("Juego del ahorcado")
while True:
jugar_ronda()
if not quiere_repetir():
print("¡Gracias por jugar!")
break
if __name__ == "__main__":
main()Probar las funciones principales
from ahorcado import palabra_completa, palabra_oculta
def test_palabra_oculta():
resultado = palabra_oculta("letra", {"l", "e", "a"})
assert resultado == "l e _ _ a"
def test_palabra_completa():
assert palabra_completa("gato", {"g", "a", "t", "o"}) is True
assert palabra_completa("gato", {"g", "a"}) is FalseConsulta la guía de Pytest en Python para ejecutar pruebas automatizadas.
Cargar palabras desde un archivo
from pathlib import Path
def cargar_palabras(ruta):
lineas = Path(ruta).read_text(encoding="utf-8").splitlines()
palabras = [linea.strip().lower() for linea in lineas]
return [palabra for palabra in palabras if palabra.isalpha()]Comprueba que la lista no esté vacía antes de usar choice().
Errores frecuentes
- Restar una vida por una letra repetida.
- Revelar solamente una posición de una letra repetida.
- Comparar mayúsculas con minúsculas sin normalización.
- Aceptar números o signos como intentos.
- Elegir una palabra de una lista vacía.
- Colocar toda la lógica dentro de un único bucle.
Ideas para ampliar
- Añadir categorías y dificultad.
- Limitar el número de pistas.
- Guardar victorias y derrotas.
- Cargar bancos de palabras externos.
- Crear una versión gráfica con Turtle o Pygame.
- Añadir opciones de terminal para vidas y categoría.
Conclusión
Un juego del ahorcado en Python combina selección aleatoria, cadenas, conjuntos, validación, bucles, funciones y pruebas. Separar la palabra oculta, la condición de victoria y la lógica de la ronda mantiene el programa claro y fácil de ampliar.
Lectura relacionada
Para comprender mejor cómo se guardan letras únicas y se detectan intentos repetidos, consulta la guía de conjuntos en Python.
