Hangman es un clásico juego de adivinar palabras que es divertido y un gran proyecto para programadores principiantes.

En este artículo, aprenderemos cómo crear una versión simple del juego Hangman en Python.

Al final, comprenderás cómo utilizar las estructuras de control, funciones y listas básicas de Python para crear este juego.

¿Qué es el ahorcado?

El objetivo de Hangman es adivinar una palabra secreta sugiriendo letras una a la vez.

El jugador solo puede hacer un número limitado de conjeturas incorrectas antes de que termine el juego.

Por cada suposición incorrecta, se extrae una parte de la figura del "verdugo", y si se extrae la figura completa antes de adivinar la palabra, el jugador pierde.

Analicemos esto y construyamos el juego paso a paso.

Paso 1: planifica el juego

Planifiquemos el juego y sus características clave:

• El juego selecciona una palabra aleatoriamente.
• El jugador adivina una letra a la vez.
• El jugador tiene un número limitado de conjeturas incorrectas.
• El juego muestra la palabra con las letras adivinadas correctamente y espacios en blanco para las letras restantes.

El juego tendrá los siguientes componentes:

• Selección de palabras
• Entrada del jugador (adivina)
• Actualizar la visualización de la palabra
• Seguimiento del número de conjeturas incorrectas

Paso 2: importar las bibliotecas necesarias

Usaremos el módulo aleatorio para seleccionar aleatoriamente una palabra de una lista.

import random

Paso 3: definir la lista de palabras

A continuación, define una lista de palabras entre las que el juego elegirá aleatoriamente.

Puedes agregar más palabras para hacer el juego más interesante.

word_list = ['python', 'java', 'hangman', 'programming', 'computer']

Paso 4: definir funciones para el juego

Función 1: seleccionar aleatoriamente una palabra

Necesitamos una función para elegir aleatoriamente una palabra de nuestra lista de palabras.

def get_random_word(word_list):
    return random.choice(word_list)

Función 2: mostrar el estado actual de la palabra

A medida que el jugador adivina letras, debemos mostrar las letras adivinadas correctamente y marcadores de posición (_) para las letras no adivinadas.

def display_word(word, guessed_letters):
    display = ''
    for letter in word:
        if letter in guessed_letters:
            display  = letter   ' '
        else:
            display  = '_ '
    return display.strip()

Función 3: comprobar si el jugador ganó

Esta función comprueba si se han adivinado todas las letras de la palabra.

def is_word_guessed(word, guessed_letters):
    for letter in word:
        if letter not in guessed_letters:
            return False
    return True

Función 4: Mostrar el ahorcado

Para mostrar una figura del ahorcado en un juego basado en texto, puedes usar arte ASCII para representar las diferentes etapas del ahorcado.

def display_hangman(wrong_guesses):
    stages = [
        """
           -----
           |   |
           O   |
          /|\\  |
          / \\  |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|\\  |
          /    |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|\\  |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|   |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
           |   |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
               |
               |
               |
        --------
        """,
        """
           -----
           |   |
               |
               |
               |
               |
        --------
        """
    ]
    # Reverse the list to display the stages in the correct order
    stages.reverse()
    return stages[wrong_guesses]

Paso 5: el bucle principal del juego

Ahora podemos armar el bucle principal del juego. Este bucle:

• Lleva un registro de las letras adivinadas y de las conjeturas incorrectas.
• Permitir que el jugador ingrese conjeturas.
• Actualiza el estado del juego según la suposición.
• Termina el juego cuando el jugador gana o pierde.

Ejemplo de código completo:

import random


# Function to get a random word from the list
def get_random_word(word_list):
    return random.choice(word_list)


# Function to display the current state of the word
def display_word(word, guessed_letters):
    display = ''
    for letter in word:
        if letter in guessed_letters:
            display  = letter   ' '
        else:
            display  = '_ '
    return display.strip()


# Function to check if the word has been guessed
def is_word_guessed(word, guessed_letters):
    for letter in word:
        if letter not in guessed_letters:
            return False
    return True


# Function to display the hangman figure
def display_hangman(wrong_guesses):
    stages = [
        """
           -----
           |   |
           O   |
          /|\\  |
          / \\  |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|\\  |
          /    |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|\\  |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
          /|   |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
           |   |
               |
               |
        --------
        """,
        """
           -----
           |   |
           O   |
               |
               |
               |
        --------
        """,
        """
           -----
           |   |
               |
               |
               |
               |
        --------
        """
    ]
    # Reverse the list to display the stages in the correct order
    stages.reverse()
    return stages[wrong_guesses]


# Main function to play the game
def play_hangman():
    word_list = ['python', 'java', 'hangman', 'programming', 'computer']
    word = get_random_word(word_list)
    guessed_letters = []
    attempts = 6
    wrong_guesses = 0

    print("Welcome to Hangman!")
    print("Guess the word!")

    # Main game loop
    while wrong_guesses 

  
  
  Explicación

• get_random_word(): Selecciona aleatoriamente una palabra de la lista de palabras.
• display_word(): crea una cadena que representa el estado actual de la palabra, mostrando las letras adivinadas correctamente y marcadores de posición para las no adivinadas.
• is_word_guessed(): Comprueba si el jugador ha adivinado todas las letras de la palabra.
• display_hangman(wrong_guesses): esta función toma el número de conjeturas incorrectas como argumento y devuelve el arte ASCII correspondiente para esa etapa.
• play_hangman(): La función principal que controla el juego. Maneja la entrada del usuario, realiza un seguimiento de las conjeturas del jugador y determina si el jugador ganó o perdió.

Variables clave:

• guessed_letters: Una lista para almacenar las letras que el jugador ha adivinado.
• wrong_guesses: rastrea cuántas conjeturas incorrectas ha hecho el jugador. intentos: el número máximo de conjeturas incorrectas permitidas.
• etapas: esta lista contiene representaciones artísticas ASCII de la figura del verdugo en diferentes etapas de finalización. Cada etapa corresponde a un número diferente de conjeturas incorrectas.

Paso 6: ejecutar el juego

Para ejecutar el juego, simplemente ejecuta el script Python, asumiendo que creaste un archivo main.py:

python main.py

El juego te pedirá que ingreses letras y mostrará la palabra con las letras adivinadas correctamente a medida que avanzas.

Si te quedas sin intentos, el juego termina y pierdes, así:

           -----
           |   |
           O   |
          /|\  |
          / \  |
               |
        --------

Game over! The word was: programming

Si adivinas la palabra correctamente, ganas, así:

           -----
           |   |
               |
               |
               |
               |
        --------

j a _ a
Enter a letter: v
Good guess! v is in the word.
Congratulations! You've guessed the word: java

Conclusión

Este sencillo juego del Ahorcado demuestra el uso de estructuras de control, funciones, listas y entradas/salidas básicas en Python.

A medida que creas este proyecto, puedes agregar más funciones como:

• Añadiendo categorías de palabras.
• Dando pistas.
• Agregando un sistema de puntuación.

Este es un gran proyecto que puedes ampliar a medida que aprendes conceptos más avanzados de Python.