Hangman est un jeu classique de devinettes de mots amusant et un excellent projet pour les programmeurs débutants.

Dans cet article, nous apprendrons comment créer une version simple du jeu Hangman en Python.

À la fin, vous comprendrez comment utiliser les structures de contrôle, les fonctions et les listes de base de Python pour créer ce jeu.

Qu’est-ce que le Pendu ?

Le but de Hangman est de deviner un mot secret en suggérant des lettres une à la fois.

Le joueur ne peut faire qu'un nombre limité de suppositions incorrectes avant la fin du jeu.

Pour chaque supposition incorrecte, une partie de la figure du « bourreau » est tirée, et si la figure complète est tirée avant que le mot ne soit deviné, le joueur perd.

Décomposons cela et construisons le jeu étape par étape.

Étape 1 : Planifier le jeu

Planifions le jeu et ses principales fonctionnalités :

• Le jeu sélectionne un mot au hasard.
• Le joueur devine une lettre à la fois.
• Le joueur a un nombre limité de suppositions incorrectes.
• Le jeu affiche le mot avec les lettres correctement devinées et des espaces pour les lettres restantes.

Le jeu comportera les composants suivants :

• Sélection de mots
• Entrée du joueur (deviner)
• Mettre à jour l'affichage du mot
• Suivez le nombre de suppositions incorrectes

Étape 2 : Importer les bibliothèques requises

Nous utiliserons le module aléatoire pour sélectionner aléatoirement un mot dans une liste.

import random

Étape 3 : Définir la liste de mots

Ensuite, définissez une liste de mots parmi lesquels le jeu choisira aléatoirement.

Vous pouvez ajouter plus de mots pour rendre le jeu plus intéressant.

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

Étape 4 : Définir les fonctions du jeu

Fonction 1 : sélectionner un mot au hasard

Nous avons besoin d'une fonction pour choisir au hasard un mot dans notre liste de mots.

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

Fonction 2 : afficher l'état actuel du mot

Au fur et à mesure que le joueur devine les lettres, nous devons afficher les lettres correctement devinées et des espaces réservés (_) pour les lettres non devinées.

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

Fonction 3 : Vérifiez si le joueur a gagné

Cette fonction vérifie si toutes les lettres du mot ont été devinées.

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

Fonction 4 : Afficher le pendu

Pour afficher une figure de bourreau dans un jeu textuel, vous pouvez utiliser l'art ASCII pour représenter les différentes étapes du bourreau.

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]

Étape 5 : La boucle principale du jeu

Nous pouvons maintenant constituer la boucle principale du jeu. Cette boucle :

• Gardez une trace des lettres devinées et des suppositions incorrectes.
• Autorisez le joueur à deviner.
• Mettez à jour l'état du jeu en fonction de la supposition.
• Terminez le jeu lorsque le joueur gagne ou perd.

Exemple de code complet :

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 

  
  
  Explication

• get_random_word() : sélectionne aléatoirement un mot dans la liste des mots.
• display_word() : crée une chaîne qui représente l'état actuel du mot, affichant les lettres correctement devinées et des espaces réservés pour celles non devinées.
• is_word_guessed() : Vérifie si le joueur a deviné toutes les lettres du mot.
• display_hangman(wrong_guesses) : cette fonction prend le nombre de suppositions incorrectes comme argument et renvoie l'art ASCII correspondant pour cette étape.
• play_hangman() : La fonction principale qui contrôle le jeu. Il gère les entrées de l'utilisateur, garde une trace des suppositions du joueur et détermine si le joueur a gagné ou perdu.

Variables clés :

• guessed_letters : Une liste pour stocker les lettres que le joueur a devinées.
• wrong_guesses : suit le nombre de suppositions incorrectes faites par le joueur. tentatives : le nombre maximum de suppositions incorrectes autorisées.
• étapes : cette liste contient des représentations artistiques ASCII de la figure du pendu à différentes étapes d'achèvement. Chaque étape correspond à un nombre différent de suppositions incorrectes.

Étape 6 : Lancer le jeu

Pour exécuter le jeu, exécutez simplement le script Python, en supposant que vous ayez créé un fichier main.py :

python main.py

Le jeu vous demandera de saisir des lettres et affichera le mot avec les lettres correctement devinées au fur et à mesure de votre progression.

Si vous manquez de tentatives, la partie se termine et vous perdez, comme ceci :

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

Game over! The word was: programming

Si vous devinez correctement le mot, vous gagnez, comme ceci :

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

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

Conclusion

Ce jeu simple du Pendu démontre l'utilisation de structures de contrôle, de fonctions, de listes et d'entrées/sorties de base en Python.

Au fur et à mesure que vous construisez ce projet, vous pouvez ajouter des fonctionnalités supplémentaires telles que :

• Ajout de catégories de mots.
• Donner des conseils.
• Ajout d'un système de notation.

C'est un excellent projet à développer à mesure que vous apprenez des concepts Python plus avancés.