Hangman ist ein klassisches Wortratespiel, das Spaß macht und ein großartiges Projekt für Programmieranfänger ist.

In diesem Artikel erfahren wir, wie man eine einfache Version des Hangman-Spiels in Python erstellt.

Am Ende werden Sie verstehen, wie Sie die grundlegenden Kontrollstrukturen, Funktionen und Listen von Python verwenden, um dieses Spiel zu erstellen.

Was ist Henker?

Das Ziel von Hangman ist es, ein geheimes Wort zu erraten, indem man einen Buchstaben nach dem anderen vorschlägt.

Der Spieler kann nur eine begrenzte Anzahl falscher Vermutungen anstellen, bevor das Spiel endet.

Für jede falsche Vermutung wird ein Teil der „Henker“-Figur gezogen, und wenn die gesamte Figur gezogen wird, bevor das Wort erraten wurde, verliert der Spieler.

Lass uns das aufschlüsseln und das Spiel Schritt für Schritt aufbauen.

Schritt 1: Planen Sie das Spiel

Lassen Sie uns das Spiel und seine Hauptfunktionen planen:

• Das Spiel wählt zufällig ein Wort aus.
• Der Spieler errät jeweils einen Buchstaben.
• Der Spieler hat eine begrenzte Anzahl falscher Schätzungen.
• Das Spiel zeigt das Wort mit den richtig erratenen Buchstaben und Leerzeichen für die verbleibenden Buchstaben an.

Das Spiel wird die folgenden Komponenten haben:

• Wortauswahl
• Spielereingabe (Vermutung)
• Anzeige des Wortes aktualisieren
• Verfolgen Sie die Anzahl falscher Schätzungen

Schritt 2: Erforderliche Bibliotheken importieren

Wir verwenden das Zufallsmodul, um ein Wort zufällig aus einer Liste auszuwählen.

import random

Schritt 3: Definieren Sie die Wortliste

Als nächstes definieren Sie eine Liste von Wörtern, aus denen das Spiel zufällig auswählen wird.

Sie können weitere Wörter hinzufügen, um das Spiel interessanter zu machen.

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

Schritt 4: Funktionen für das Spiel definieren

Funktion 1: Wählen Sie zufällig ein Wort aus

Wir benötigen eine Funktion, um zufällig ein Wort aus unserer Wortliste auszuwählen.

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

Funktion 2: Zeigt den aktuellen Status des Wortes an

Während der Spieler Buchstaben errät, müssen wir die richtig erratenen Buchstaben und Platzhalter (_) für die nicht erratenen Buchstaben anzeigen.

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

Funktion 3: Überprüfen Sie, ob der Spieler gewonnen hat

Diese Funktion prüft, ob alle Buchstaben des Wortes erraten wurden.

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

Funktion 4: Hangman anzeigen

Um eine Henkerfigur in einem textbasierten Spiel anzuzeigen, können Sie ASCII-Grafiken verwenden, um die verschiedenen Phasen des Henkers darzustellen.

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]

Schritt 5: Die Hauptspielschleife

Jetzt können wir die Hauptschleife des Spiels zusammenstellen. Diese Schleife wird:

• Behalten Sie den Überblick über die erratenen und falschen Buchstaben.
• Erlauben Sie dem Spieler, Vermutungen einzugeben.
• Aktualisieren Sie den Spielstatus basierend auf der Vermutung.
• Beende das Spiel, wenn der Spieler gewinnt oder verliert.

Vollständiges Codebeispiel:

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 

  
  
  Erläuterung

• get_random_word(): Wählt zufällig ein Wort aus der Wortliste aus.
• display_word(): Erstellt eine Zeichenfolge, die den aktuellen Status des Worts darstellt und die richtig erratenen Buchstaben und Platzhalter für nicht erratene Buchstaben anzeigt.
• is_word_guessed(): Prüft, ob der Spieler alle Buchstaben im Wort erraten hat.
• display_hangman(wrong_guesses): Diese Funktion verwendet die Anzahl der falschen Vermutungen als Argument und gibt die entsprechende ASCII-Grafik für diese Stufe zurück.
• play_hangman(): Die Hauptfunktion, die das Spiel steuert. Es verarbeitet Benutzereingaben, verfolgt die Vermutungen des Spielers und bestimmt, ob der Spieler gewonnen oder verloren hat.

Schlüsselvariablen:

• guessed_letters: Eine Liste zum Speichern der Buchstaben, die der Spieler erraten hat.
• wrong_guesses: Verfolgt, wie viele falsche Vermutungen der Spieler gemacht hat. Versuche: Die maximal zulässige Anzahl falscher Schätzungen.
• Stufen: Diese Liste enthält ASCII-Kunstdarstellungen der Henkerfigur in verschiedenen Stadien der Fertigstellung. Jede Stufe entspricht einer unterschiedlichen Anzahl falscher Schätzungen.

Schritt 6: Ausführen des Spiels

Um das Spiel auszuführen, führen Sie einfach das Python-Skript aus, vorausgesetzt, Sie haben eine Datei main.py erstellt:

python main.py

Das Spiel fordert Sie zur Eingabe von Buchstaben auf und zeigt im weiteren Verlauf das Wort mit den richtig erratenen Buchstaben an.

Wenn Ihnen die Versuche ausgehen, endet das Spiel und Sie verlieren, wie folgt:

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

Game over! The word was: programming

Wenn Sie das Wort richtig erraten, gewinnen Sie, so:

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

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

Abschluss

Dieses einfache Hangman-Spiel demonstriert die Verwendung von Kontrollstrukturen, Funktionen, Listen und grundlegenden Ein-/Ausgaben in Python.

Während Sie dieses Projekt erstellen, können Sie weitere Funktionen hinzufügen, wie zum Beispiel:

• Kategorien von Wörtern hinzufügen.
• Hinweise geben.
• Ein Bewertungssystem hinzufügen.

Dies ist ein großartiges Projekt, das Sie erweitern können, wenn Sie fortgeschrittenere Python-Konzepte erlernen.