Cloud Híbrida
Ciberseguridad & NaaS
AI & Data
IoT y Conectividad
Business Applications
Intelligent Workplace
Consultoría y Servicios Profesionales
Pequeña y Mediana Empresa
Sanidad y Social
Industria
Retail
Turismo y Ocio
Transporte y Logística
Energía y Utilities
Python para todos: programa tu juego del Ahorcado edición Halloween
Aprender a programar es aprender un nuevo idioma. Entre los lenguajes de programación, uno de los más utilizados es Python, como ya te contamos en algunos posts anteriores. En esta ocasión te proponemos el popular juego del ahorcado edición Halloween, con palabras relacionadas con esta celebración.
¿Y por qué un juego? Porque aprender de manera lúdica nos ayuda a comprender y retener conceptos complejos, así como a desarrollar habilidades de resolución de problemas, pensamiento crítico y toma de decisiones. También fomenta nuestra creatividad e imaginación, ya que podemos experimentar con diferentes ideas y soluciones a un mismo reto.
Y, en el caso de la programación, especialmente con lenguajes como Python (uno de los más utilizados para desarrollar modelos de Inteligencia Artificial), aprender a programar jugando es una magnífica excusa para perder el miedo al código. ¡Ponte manos a la obra y crea tu propio juego del Ahorcado edición Halloween!
1. Preparativos iniciales
¡Muy sencillo! Para crear tu juego solo tienes que iniciar sesión con tu cuenta de Gmail en Google Colab, la plataforma en línea de Google para escribir, acceder a bibliotecas y ejecutar código Python en un entorno Cloud, de manera gratuita y con la colaboración entre usuarios en notebooks Jupyter.
2. Conceptos fundamentales de Python
Para crear nuestro juego del Ahorcado debemos entender el funcionamiento de algunas estructuras del lenguaje Python que nos servirán como base: if y else, for y while.
Estructuras if, elif y else
Vamos a utilizar esta estructura de control de selección para ejecutar un bloque de código basado en condiciones. En nuestro Ahorcado, nos servirá para determinar si la letra introducida por el usuario se encuentra o no en nuestra palabra oculta, o si ya ha sido utilizada.
En if (la primera condición) y elif (las siguientes condiciones añadidas) incluiremos los casos en los que queremos que nuestro Ahorcado de una respuesta específica, considerando que la letra introducida no es válida (false). En else, que nos sirve para todas aquellas casuísticas no mencionadas en if y elif daremos la letra como válida (true).
Bucle for
Ya hablamos en este post sobre la estructura de control for en Python, que será otra de las bases de nuestro juego, y nos permitirá iterar sobre una secuencia de elementos.
En nuestro juego del Ahorcado, los elementos serán las letras que componen la palabra oculta, y los guiones que mostramos al usuario, correspondientes a la palabra a adivinar. Como cada vez que el usuario introduce una letra debemos comprobar que se encuentra en la palabra, el bucle for nos servirá para recorrer dichos elementos uno a uno y ejecutar las instrucciones que le indiquemos.
Bucle while
Por último, necesitamos el bucle while para controlar la lógica principal del juego. Permite que este continúe mientras el jugador tenga intentos restantes y mientras queden letras por adivinar en la palabra oculta. Una vez que la condición se vuelve falsa, el bucle se detiene y se muestra un mensaje de victoria o derrota.
3. Diseño del juego del Ahorcado
Comenzaremos creando la estructura del juego a partir de una serie de variables, que nos permitirá hacer el código más eficiente. En primer lugar, la representación visual del Ahorcado y después las variables:
- La palabra oculta tendrá exactamente la misma longitud (guiones bajos) que los elementos de palabra. Para ello, utilizamos la función
len. - El número de intentos en el juego. Más adelante, indicaremos al programa que por cada fallo, se restará un intento (intentos – 1).
- Determinamos el abecedario en forma de lista. Posteriormente, indicaremos que solo son válidas las letras incluidas en dicho listado.
- Por último, la variable letras descartadas, ya que durante el juego iremos mostrando al usuario las palabras incorrectas ya utilizadas:
dibujo_ahorcado = [
'''
+---+
| |
|
|
|
|
=========
''',
'''
+---+
| |
O |
|
|
|
=========
''',
'''
+---+
| |
O |
| |
|
|
=========
''',
'''
+---+
| |
O |
/| |
|
|
=========
''',
'''
+---+
| |
O |
/|\ |
|
|
=========
''',
'''
+---+
| |
O |
/|\ |
/ |
|
=========
''',
]
palabra = list('calavera')
palabra_oculta =['_']*len(palabra)
intentos = 6
lista_abecedario = list('abcdefghijklmnñopqrstuvwxyz')
letras_descartadas = []
4. Programando la interacción del usuario
Vamos a bucear en las ‘tripas’ del Ahorcado, para traducir a código cómo permitimos que el usuario adivine letras y cómo llevar un registro de las letras correctas e incorrectas.
Lo primero de todo, vamos a mostrar el estado actual del juego: el nº de intentos restantes, letras descartadas y cómo se van adivinando las letras correspondientes a los guiones de la palabra oculta
Estado del juego
Vamos a utilizar el método join para unir elementos en una lista y que la representación visual sea más legible. Nos sirve para formatear la salida de las letras descartadas y la palabra oculta:
def mostrar_estado():
print(f'Intentos restantes: {intentos}')
print(f'Letras descartadas: {", ".join(letras_descartadas)}\n')
print(f'Palabra: {" ".join(palabra_oculta)}\n')
print(dibujo_ahorcado[6 - intentos])
Verificación de la letra válida
Cuando el usuario juegue, hay diferentes escenarios que debemos reflejar en el código, ya que puede que la letra introducida ya se haya utilizado, el usuario introduzca un símbolo que no sea letra o introduzca más de una.
Para elaborar el código de verificación de si la letra ingresada es válida o no, crearemos estructuras condicionales (if, elif, else) Vamos a definir la función de letra válida a partir del parámetro letra.
def letra_valida(letra):
if len(letra) != 1 :
print('Has puesto más de una letra, inténtalo de nuevo.')
return False
elif letra not in lista_abecedario:
print('No has introducido una letra del abecedario')
return False
elif letra in palabra_oculta:
print('La letra que has introducido ya la has acertado, inténtalo de nuevo.')
return False
elif letra in letras_descartadas:
print('Esa letra ya la habías dicho, inténtalo de nuevo.')
return False
else:
return True
Gestión de letra
Ahora vamos a definir la función de gestión de letra con el bucle for , y así actualizar la representación de la palabra oculta cuando el usuario adivine una letra.
Vamos a combinar el bucle for con range(len(palabra)), y así recorrerá cada posición en la lista 'palabra', asignando una secuencia de índices para cada elemento de la lista. Cuando el juego encuentre una coincidencia, actualizará tanto palabra_oculta como palabra.
En cada iteración del bucle i, toma el valor de uno de dichos índices. En el caso de la palabra, identificará la posición de la letra adivinada, que tomará y sustituirá el guion bajo en su misma posición en palabra oculta:
def gestion_letra(letra):
for i in range(len(palabra)):
if palabra[i] == letra:
palabra_oculta[i] = letra
palabra[i] = '_'
Ahora vamos a imprimir (print) lo que es usuario verá en la pantalla al inicio del juego de nuestro Ahorcado, así como las condiciones que deben cumplirse en nuestro bucle while para que siga jugando.
Utilizaremos lower para que el programa siempre tome las letras en minúscula, independientemente de cómo las introduzca el usuario. Por otro lado, utilizaremos el método .append para ir agregando el valor de las letras no válidas a la lista de letras descartadas.
Y, por último, la sentencia if y el método join para determinar si el usuario ha ganado o perdido.
print('BIENVENIDO AL JUEGO DEL AHORCADO 🎃 EDICIÓN HALLOWEEN 🎃\n')
print('Reglas del juego: Introduce letras para adivinar la palabra oculta .')
print(f'Tienes {intentos} intentos. ¡Buena suerte!')
while intentos > 0 and '_' in palabra_oculta:
mostrar_estado()
print('-'*50)
letra = input('INTRODUCE LETRA: ').lower()
while not letra_valida(letra):
letra = input('INTRODUCE OTRA LETRA: ').lower()
if letra in palabra:
gestion_letra(letra)
print('-'*50)
print('¡Has acertado la letra! Sigue así.')
else:
print('-'*50)
print('¡Has fallado la letra!')
letras_descartadas.append(letra)
intentos -= 1
if '_' not in palabra_oculta:
print('\n\n🏆🎃¡ENHORABUENA! ¡HAS GANADO EL JUEGO!🎃🏆')
else:
print(f'\nOh!😞 Lo siento, ¡has perdido!'
'''\n
+---+
| |
💀 |
/|\ |
/ \ |
|
=========
''')
¡Y lo tenemos! Ejecutando todo el código en Google Colab ya tendrás tu juego del Ahorcado. También puedes ver el código completo en este notebook.
Ahora es tu turno para practicar Python con palabras fantasmagóricas de Halloween. Te retamos a incluir mejoras en el código que enriquecerán la experiencia. Por ejemplo, el módulo random, comúnmente utilizado en Python para generar números pseudoaleatorios, permitirá que cada juego sea diferente, al elegir aleatoriamente una palabra de una lista de varias palabras previamente definidas.
Recuerda que puedes modificar el código a tu gusto, añadiendo más palabras, gráficos, sonidos o lo que se te ocurra. Además, al darle un toque de Halloween puedes hacerlo más divertido y temático. ¡No te limites y explora las posibilidades que te ofrece Python!
