En este post te mostraré el juego del ahorcado programado en Python. Voy a poner la demostración y la explicación de cómo fue programado.
Las características de El ahorcado en Python, también conocido como hangman, son:
- Juega con 6 intentos
- Coloca la letra y trata de adivinar la palabra antes de que se acaben los intentos
- Distintas categorías de palabras
- Gestión de bancos o grupos de palabras con archivos. Es decir, se tiene una base de datos de las palabras
- Ajustes del juego, para agregar, eliminar o editar palabras y grupos de palabras
- Selección del grupo de palabras para jugar. Al iniciar, se selecciona una palabra al azar.
- Muestra las instrucciones para jugar al ahorcado
Veamos ahora el código, la demostración y explicación de este programa en Python.
Categorías o grupos de palabras
Como lo dije, el programa soporta que los bancos de palabras sean guardados en archivos de texto. Por lo tanto, se necesitan funciones para gestionar estas operaciones.
Los grupos de palabras están en un archivo de texto cuyo nombre está definido en una variable del programa. Para obtener los grupos tenemos la siguiente función:
def obtenerGrupos():
grupos = []
with open(nombreArchivoGrupos) as archivo:
for linea in archivo:
linea = linea.rstrip()
grupos.append(linea)
return grupos
Lo que hace es leer el archivo línea por línea, remover el salto de línea y agregar el elemento a la lista de grupos. Al final regresará la lista con todos los grupos que están en el archivo.
De manera similar, existe la función para que a partir de una lista de categorías se genere el archivo de texto:
def escribirGrupos(grupos):
with open(nombreArchivoGrupos, "w") as archivo:
for grupo in grupos:
archivo.write(grupo + "\n")
Gestión de palabras para el ahorcado
Las palabras están en un archivo de texto cuyo nombre es el nombre del grupo o categoría, y en su contenido encontramos la lista de palabras. La función es similar:
def obtenerPalabrasDeGrupo(grupo):
palabras = []
with open(grupo + ".txt") as archivo:
for linea in archivo:
linea = linea.rstrip()
palabras.append(linea)
return palabras
Y también para guardarlas:
def escribirPalabrasDeGrupo(palabras, grupo):
with open(grupo + ".txt", "w") as archivo:
for palabra in palabras:
archivo.write(palabra + "\n")
Desarrollo de juego
El juego básicamente consiste en lo siguiente, en donde se comprueba si ha ganado o perdido, además de que se le solicita la letra y se dibuja el muñeco dependiendo de los intentos restantes:
def jugar():
global letrasEscritas
global intentos
intentos = 6
letrasEscritas = []
palabra = obtenerPalabra()
prepararPalabra(palabra)
while True:
imprimirAhorcado()
dibujarIntentos()
imprimirPalabra()
descubrirLetra(input("Ingresa la letra: "))
if intentos <= 0:
print("Perdiste. La palabra era: ")
imprimirPalabraOriginal()
return
if haGanado():
print("Ganaste")
return
Ahora veamos con detalle.
Seleccionar categoría y palabra a adivinar
Al jugar se le muestra al usuario la lista de categorías existentes para que pueda elegir con cuál categoría y palabra juega al juego ahorcado o hangman programado en Python:
def imprimirGruposYSolicitarIndice(grupos):
for i, grupo in enumerate(grupos):
print(f"{i + 1}. {grupo}")
return int(input("Seleccione el grupo: ")) - 1
A partir de ello se selecciona una palabra aleatoria usando random.choice:
def obtenerPalabra():
print("Jugar con: ")
grupos = obtenerGrupos()
indice = imprimirGruposYSolicitarIndice(grupos)
grupo = grupos[indice]
palabras = obtenerPalabrasDeGrupo(grupo)
return random.choice(palabras)
Ocultar palabra original
Una parte importante para ocultar las letras de la palabra es la siguiente, en donde para aprovechar las ventajas del lenguaje he usado un diccionario que tiene la letra y una variable que indica si la letra ha sido descubierta:
def prepararPalabra(original):
global palabraAdivinada
original = original.lower()
palabraAdivinada = []
for letra in original:
palabraAdivinada.append({
"letra": letra,
"adivinada": False,
})
Por defecto, ninguna letra está adivinada. Pero el usuario puede intentar adivinar una letra, lo cual es manejado a continuación:
def descubrirLetra(letraDeUsuario):
global palabraAdivinada
global letrasEscritas
global intentos
letraDeUsuario = letraDeUsuario.lower()
if letraDeUsuario in letrasEscritas:
return
else:
letrasEscritas.append(letraDeUsuario)
if not letraEstaEnPalabra(letraDeUsuario):
intentos -= 1
else:
for letraCompuesta in palabraAdivinada:
if letraCompuesta["letra"] == letraDeUsuario:
letraCompuesta["adivinada"] = True
Como se puede observar, se lleva un registro de las letras que el usuario ha probado. Si vuelve a probar una letra que ya había escrito anteriormente, no pasa nada, se ignora.
Después, en la línea 10 se comprueba si la letra está en la palabra original. En caso de que no esté presente, se resta un intento o vida al jugador.
Finalmente en la línea 12 (lugar al que se llega si la letra está presente, es decir, si el jugador ha acertado) se marcan como adivinadas las letras que coincidan con lo que el usuario eligió.
Imprimir palabra
Además, tenemos otra función que imprime la palabra pero con la peculiaridad de que si la letra no está adivinada, imprime un guión (se puede cambiar por un asterisco o cualquier otra cosa).
def imprimirPalabra():
for letraCompuesta in palabraAdivinada:
if letraCompuesta["adivinada"]:
print(letraCompuesta["letra"], end="")
else:
print("-", end="")
print("")
Saber si ha ganado el juego de El ahorcado
Para saber si el usuario ha adivinado todas las letras de la palabra, se recorre la palabra compuesta y en caso de que no haya letras sin adivinar, se regresa True.
def haGanado():
global palabraAdivinada
for letra in palabraAdivinada:
if not letra["adivinada"]:
return False
return True
Dibujar ahorcado
Para terminar la explicación de las funciones veamos la función que dibuja al muñeco ahorcado en función de los intentos restantes. Queda así:
def imprimirAhorcado():
if intentos == 1:
print("""
___
| |
_O/ |
| |
/ \ |
______|
""")
elif intentos == 2:
print("""
___
| |
_O/ |
| |
\ |
______|
""")
elif intentos == 3:
print("""
___
| |
_O/ |
| |
|
______|
""")
elif intentos == 4:
print("""
___
| |
_O/ |
|
|
______|
""")
elif intentos == 5:
print("""
___
| |
O/ |
|
|
______|
""")
elif intentos == 6:
print("""
___
| |
O |
|
|
______|
""")
Poniendo todo junto
Así que el código completo queda como se ve a continuación. De este modo podemos jugar a hangman en Python. Recuerda que eres libre de modificar el código a tus necesidades.
"""
____ _____ _ _ _
| _ \ | __ \ (_) | | |
| |_) |_ _ | |__) |_ _ _ __ _____| |__ _ _| |_ ___
| _ <| | | | | ___/ _` | '__|_ / | '_ \| | | | __/ _ \
| |_) | |_| | | | | (_| | | / /| | |_) | |_| | || __/
|____/ \__, | |_| \__,_|_| /___|_|_.__/ \__, |\__\___|
__/ | __/ |
|___/ |___/
____________________________________
/ Si necesitas ayuda, contáctame en \
\ https://parzibyte.me /
------------------------------------
\ ^__^
\ (oo)\_______
(__)\ )\/\
||----w |
|| ||
Creado por Parzibyte (https://parzibyte.me). Este encabezado debe mantenerse intacto,
excepto si este es un proyecto de un estudiante.
"""
import os
import random
palabraAdivinada = []
letrasEscritas = []
intentos = 6
palabraSecretaAjustes = "1"
nombreArchivoGrupos = "grupos.txt"
def prepararPalabra(original):
global palabraAdivinada
original = original.lower()
palabraAdivinada = []
for letra in original:
palabraAdivinada.append({
"letra": letra,
"adivinada": False,
})
def imprimirPalabra():
for letraCompuesta in palabraAdivinada:
if letraCompuesta["adivinada"]:
print(letraCompuesta["letra"], end="")
else:
print("-", end="")
print("")
def imprimirPalabraOriginal():
for letraCompuesta in palabraAdivinada:
print(letraCompuesta["letra"], end="")
def descubrirLetra(letraDeUsuario):
global palabraAdivinada
global letrasEscritas
global intentos
letraDeUsuario = letraDeUsuario.lower()
if letraDeUsuario in letrasEscritas:
return
else:
letrasEscritas.append(letraDeUsuario)
if not letraEstaEnPalabra(letraDeUsuario):
intentos -= 1
else:
for letraCompuesta in palabraAdivinada:
if letraCompuesta["letra"] == letraDeUsuario:
letraCompuesta["adivinada"] = True
def letraEstaEnPalabra(letra):
global palabraAdivinada
for letraCompuesta in palabraAdivinada:
if letraCompuesta["letra"] == letra:
return True
return False
def imprimirAhorcado():
if intentos == 1:
print("""
___
| |
_O/ |
| |
/ \ |
______|
""")
elif intentos == 2:
print("""
___
| |
_O/ |
| |
\ |
______|
""")
elif intentos == 3:
print("""
___
| |
_O/ |
| |
|
______|
""")
elif intentos == 4:
print("""
___
| |
_O/ |
|
|
______|
""")
elif intentos == 5:
print("""
___
| |
O/ |
|
|
______|
""")
elif intentos == 6:
print("""
___
| |
O |
|
|
______|
""")
def dibujarIntentos():
print("Intentos restantes: " + str(intentos))
def haGanado():
global palabraAdivinada
for letra in palabraAdivinada:
if not letra["adivinada"]:
return False
return True
def instrucciones():
print("""
INSTRUCCIONES
El objetivo de este juego es descubrir una palabra adivinando las letras que la componen.
1. Debes seleccionar de qué conjunto de palabras quisieras jugar
2. Inicias con """ + str(intentos) + " vidas" +
"""
3. Ingresa una letra que creas vaya en la palabra a adivinar
Suerte con el juego
""")
def obtenerPalabra():
print("Jugar con: ")
grupos = obtenerGrupos()
indice = imprimirGruposYSolicitarIndice(grupos)
grupo = grupos[indice]
palabras = obtenerPalabrasDeGrupo(grupo)
return random.choice(palabras)
def jugar():
global letrasEscritas
global intentos
intentos = 6
letrasEscritas = []
palabra = obtenerPalabra()
prepararPalabra(palabra)
while True:
imprimirAhorcado()
dibujarIntentos()
imprimirPalabra()
descubrirLetra(input("Ingresa la letra: "))
if intentos <= 0:
print("Perdiste. La palabra era: ")
imprimirPalabraOriginal()
return
if haGanado():
print("Ganaste")
return
def ajustes():
if input("Ingrese la contraseña: ") != palabraSecretaAjustes:
print("Contraseña incorrecta")
return
menu = """
1. Eliminar grupo de palabras
2. Crear grupo de palabras
3. Modificar grupo de palabras
"""
grupos = obtenerGrupos()
eleccion = int(input(menu))
if eleccion <= 0 or eleccion > 3:
print("No válido")
return
if eleccion == 1:
eliminarGrupoDePalabras(grupos)
elif eleccion == 2:
crearGrupoDePalabras(grupos)
elif eleccion == 3:
modificarGrupoDePalabras(grupos)
def eliminarGrupoDePalabras(grupos):
indice = imprimirGruposYSolicitarIndice(grupos)
grupoEliminado = grupos[indice]
del grupos[indice]
os.unlink(grupoEliminado + ".txt")
escribirGrupos(grupos)
def imprimirGruposYSolicitarIndice(grupos):
for i, grupo in enumerate(grupos):
print(f"{i + 1}. {grupo}")
return int(input("Seleccione el grupo: ")) - 1
def crearGrupoDePalabras(grupos):
grupo = input("Ingrese el nombre del grupo: ")
palabras = solicitarPalabrasParaNuevoGrupo()
escribirPalabrasDeGrupo(palabras, grupo)
grupos.append(grupo)
escribirGrupos(grupos)
print("Grupo creado correctamente")
def escribirGrupos(grupos):
with open(nombreArchivoGrupos, "w") as archivo:
for grupo in grupos:
archivo.write(grupo + "\n")
def escribirPalabrasDeGrupo(palabras, grupo):
with open(grupo + ".txt", "w") as archivo:
for palabra in palabras:
archivo.write(palabra + "\n")
def solicitarPalabrasParaNuevoGrupo():
palabras = []
while True:
palabra = input("Ingrese la palabra. Deje la cadena vacía si quiere terminar: ")
if palabra == "":
return palabras
palabras.append(palabra)
def modificarGrupoDePalabras(grupos):
indice = imprimirGruposYSolicitarIndice(grupos)
grupoQueSeCambia = grupos[indice]
palabras = obtenerPalabrasDeGrupo(grupoQueSeCambia)
menu = """
1. Cambiar una palabra
2. Agregar una palabra
3. Eliminar una palabra
Seleccione: """
eleccion = int(input(menu))
if eleccion <= 0 or eleccion > 3:
print("No válido")
return
if eleccion == 1:
cambiarUnaPalabra(grupoQueSeCambia, palabras)
elif eleccion == 2:
agregarUnaPalabra(grupoQueSeCambia, palabras)
elif eleccion == 3:
eliminarUnaPalabra(grupoQueSeCambia, palabras)
def cambiarUnaPalabra(grupo, palabras):
indice = imprimirPalabrasYSolicitarIndice(palabras)
palabraCambiada = palabras[indice]
print("Se cambia la palabra " + palabraCambiada)
nuevaPalabra = input("Ingrese la nueva palabra: ")
palabras[indice] = nuevaPalabra
escribirPalabrasDeGrupo(palabras, grupo)
print("Palabra cambiada correctamente")
def agregarUnaPalabra(grupo, palabras):
palabra = input("Ingrese la palabra que se agrega: ")
palabras.append(palabra)
escribirPalabrasDeGrupo(palabras, grupo)
print("Palabra agregada correctamente")
def eliminarUnaPalabra(grupo, palabras):
indice = imprimirPalabrasYSolicitarIndice(palabras)
del palabras[indice]
escribirPalabrasDeGrupo(palabras, grupo)
print("Palabra eliminada correctamente")
def imprimirPalabrasYSolicitarIndice(palabras):
for i, palabra in enumerate(palabras):
print(f"{i + 1}. {palabra}")
return int(input("Seleccione la palabra: ")) - 1
def obtenerGrupos():
grupos = []
with open(nombreArchivoGrupos) as archivo:
for linea in archivo:
linea = linea.rstrip()
grupos.append(linea)
return grupos
def obtenerPalabrasDeGrupo(grupo):
palabras = []
with open(grupo + ".txt") as archivo:
for linea in archivo:
linea = linea.rstrip()
palabras.append(linea)
return palabras
def prepararArchivo():
if not os.path.isfile(nombreArchivoGrupos):
with open(nombreArchivoGrupos, "w") as archivo:
archivo.write("")
def menu_principal():
menu = """
1. Jugar
2. Instrucciones
3. Ajustes
4. Salir
Seleccione: """
eleccion = int(input(menu))
if eleccion <= 0 or eleccion >= 4:
exit()
if eleccion == 1:
jugar()
elif eleccion == 2:
instrucciones()
elif eleccion == 3:
ajustes()
def main():
prepararArchivo()
while True:
menu_principal()
main()
Puedes probar el juego en línea aquí.
Si te ha gustado, te invito a leer más sobre Python o sobre videojuegos.
