Erstellen Sie ein Python -Wort Ratenspiel

https://www.youtube.com/watch?v=1A4AZBBCNGK

In diesem Tutorial werde ich Sie durch das Erstellen eines ähnlichen Phrase-Töner-Spiels führen Wurm mit Python. Während sich viele Codierungsprojekte auf die Datenanalyse konzentrieren, ist das Erstellen eines Spiels nicht nur Spaß, sondern hilft auch, grundlegende Programmierkonzepte in einem kreativen Kontext zu verstärken. Die Spieleentwicklung eignet sich besonders hervorragend für das Üben von objektorientiertem Programmieren, logischem Denken und Erstellen interaktiver Benutzererlebnisse.

Am Ende dieses Tutorials haben Sie ein voll funktionsfähiges Phrase -Erraten -Spiel erstellt, bei dem:

• Spieler versuchen, ein mysteriöses Wort innerhalb einer begrenzten Anzahl von Versuchen zu erraten
• Richtige Buchstaben in der richtigen Place werden aufgedeckt
• Spieler erhalten Suggestions zu verleumden und falschen Buchstaben
• Die Spielspuren gewinnen und Verlustbedingungen

Was du lernen wirst

Durch dieses Projekt werden Sie üben:

• Arbeiten mit Pythons eingebauten Modulen wie wie random
• Verwenden der Datei -E/A zum Lesen externer Daten
• Sport -Loops erstellen und verwalten
• Implementierung der bedingten Logik für Spielregeln
• Umgang mit Benutzereingaben und Suggestions bereitzustellen
• Erstellen einer textbasierten Benutzeroberfläche

Bevor Sie beginnen: Vorabstrukturierung

Folgen Sie diese vorbereitenden Schritte, um das Beste aus diesem Projekt zu machen:

1. Überprüfen Sie das Projekt
   Greifen Sie auf das Projekt zu und machen Sie sich mit den Zielen und Struktur vertraut: Wort Ratenspielprojekt.
2. Bereiten Sie Ihre Umgebung vor
   • Wenn Sie die verwenden Dataquest -PlattformAlles ist schon für Sie eingerichtet.
   • Wenn Sie vor Ort arbeiten, stellen Sie sicher, dass Sie Python und Jupyter Pocket book installiert haben.
3. Machen Sie sich mit Jupyter wohl
   • Neu im Markdown? Wir empfehlen, die Grundlagen zu lernen, um Header zu formatieren und Ihrem Jupyter -Notizbuch Kontext hinzuzufügen: Markdown -Handbuch.
   • Für Dateifreigabe und Projekt -Uploads erstellen Sie vor dem Webinar ein Github -Konto: Melden Sie sich bei Github an.

Einrichten Ihrer Umgebung

Arbeiten mit Jupyter Pocket book

Für dieses Projekt verwenden wir Jupyter Pocket book, mit dem wir Python -Code in einer interaktiven Umgebung schreiben und ausführen können. Wenn Sie neu bei Jupyter sind, finden Sie hier einen kurzen Überblick:

• Zellen: Jupyter -Notizbücher bestehen aus Zellen, die entweder Code oder Markdown (formatierter Textual content) enthalten können.
• Laufzellen: Um eine Zelle auszuführen, wählen Sie sie aus und drücken Sie die Eingabetaste von SHIRT+.
• Zelltypen:
  • Codezellen: Wo Sie den Python -Code schreiben und ausführen
  • Markdown -Zellen: Wo Sie einen formatierten Textual content schreiben (wie dieses Tutorial)

Projektressourcen

Für dieses Projekt brauchen Sie:

• Eine Textdatei mit Wörtern für Ihr Spiel (wir werden eine einfache Model angeben)
• Das Jupyter -Notizbuch zum Schreiben Ihres Spielcodes

Erstellen wir die erforderlichen Dateien:

1. Erstellen Sie eine neue Datei mit dem Namen phrases.txt und fügen Sie Wörter hinzu (eine professional Zeile). Hier ist die Beispielliste, die wir in dieser Vorgehensweise verwenden werden:

   bears
   kings
   helps
   be taught
   queen
   twist
   joyful
   

2. Erstellen Sie ein neues Jupyter -Notizbuch mit dem Namen Word_Raider.ipynb

Mit unserer Umgebung sind wir quick bereit, unser Spiel aufzubauen, aber zuerst verstehen wir einige wichtige Konzepte.

Spielschleifen verstehen

Eines der Schlüsselkonzepte in diesem Projekt ist die Spielschleife, die für die meisten interaktiven Anwendungen und Spiele von grundlegender Bedeutung ist. Lassen Sie uns aufschlüsseln, wie es funktioniert:

1. Die Schleifenbedingung: Unsere Schleife geht so lange fort wie used_turns < max_turnsum sicherzustellen, dass das Spiel aufhört, wenn der Spieler die Kurven mehr hat.
2. Eingabephase: Wir sammeln und validieren zu Beginn jeder Schleifen -Iteration die Spielereingabe.
3. Aktualisieren Sie die Section: Wir verarbeiten die Vermutung, aktualisieren unseren Spielstatus (verfolgen Sie korrekt, falsch und verlegt Buchstaben).
4. Section rendern: Wir zeigen den aktuellen Stand des Spiels an (das teilweise enthüllte Wort, verfolgte Buchstaben und verbleibende Wendungen).
5. Gewinn/Verlustprüfung: Nachdem wir eine Vermutung bearbeitet haben, überprüfen wir, ob der Spieler gewonnen oder verloren hat, und brechen die Schleife, wenn eine Bedingung erfüllt ist.

Dieses Muster der Enter → Replace → Render → Überprüfen Sie das Spielstatus in vielen Arten von Spielen, von einfachen textbasierten Spielen wie unseren bis hin zu komplexen 3D-Videospielen.

Jetzt, da wir diese Schlüsselkonzepte verstehen, beginnen wir mit dem Projekt.

Projektumsetzung

Schritt 1: Importieren der erforderlichen Bibliotheken

Beginnen wir mit dem Importieren der random Modul, mit dem wir zufällig ein Wort aus unserer Wortbank auswählen können:

import random

Erkenntnis zu lernen: Stellen Sie Ihre Importanweisungen immer ganz oben in Ihrem Code. Dies macht Ihre Abhängigkeiten jedem klar, der Ihren Code liest, und stellt sicher, dass sie während Ihres gesamten Programms verfügbar sind.

Schritt 2: Erstellen globaler Variablen

Lassen Sie uns als nächstes einige globale Variablen definieren, die während unseres Spiels verwendet werden:

game_name = "Phrase Raider"
word_bank = ()

Hier sind wir:

• Setzen Sie den Namen unseres Spiels in „Phrase Raider“ (Wählen Sie Ihren eigenen Namen aus!)
• Erstellen einer leeren Liste, die alle möglichen Wörter für unser Spiel speichert

Schritt 3: Laden der Wortbank

Laden wir nun unsere Wortliste aus der zuvor erstellten Textdatei:

with open("phrases.txt") as word_file:
    for line in word_file:
        word_bank.append(line.rstrip().decrease())

# Confirm our phrase financial institution loaded appropriately
word_bank

Ausgabe:

('bears', 'kings', 'helps', 'be taught', 'queen', 'twist', 'joyful')

Erkenntnis lernen: Verwenden eines Kontextmanagers (with Anweisung) ist die empfohlene Möglichkeit, Dateien in Python zu öffnen. Es stellt sicher, dass die Datei nach dem Gebrauch ordnungsgemäß geschlossen ist, auch wenn ein Fehler auftritt. Der .rstrip() Die Methode entfernt nachdenkliche Weißespace (wie neue Charaktere) und .decrease() standardisiert alle Wörter für Konsistenz auf Kleinbuchstaben.

Schritt 4: Auswählen des Zielworts

Mit unserer Phrase -Financial institution können wir zufällig ein Wort auswählen, damit der Spieler erraten kann:

selected_word = random.selection(word_bank)

Erkenntnis lernen: die random.selection() Die Funktion wählt ein zufälliges Component aus einer Sequenz aus (in diesem Fall unsere Liste der Wörter). Dies führt zu einer Variabilität in unser Spiel, um sicherzustellen, dass jedes Mal, wenn das Spiel gespielt wird, ein zufälliges Wort ausgewählt wird, wodurch der Wiederholungswert erhöht wird.

Schritt 5: Spieleninformationen einrichten

Bevor wir die Hauptspielschleife beginnen, definieren wir einige Variablen, um den Spielstatus zu verfolgen:

# Defining recreation info
incorrect_letters = ()
misplaced_letters = ()
max_turns = 6
used_turns = 0

Diese Variablen helfen uns, nachzuverfolgen:

• Briefe vermutet, die nicht im Wort sind (incorrect_letters)
• Buchstaben vermutet, die im Wort sind, aber in der falschen Place (misplaced_letters)
• Die maximale Anzahl von Vermutungen erlaubt (max_turns)
• Wie viele Vermutungen der Spieler hat bisher verwendet (used_turns)

Schritt 6: Erstellen der Benutzeroberfläche

Lassen Sie uns dem Spieler einige erste Informationen zur Verfügung stellen:

print(f"Welcome to {game_name}!")
print(f"The phrase to guess has {len(selected_word)} letters.")
print(f"You may have {max_turns} turns to guess the phrase!")

Ausgabe:

Welcome to Phrase Raider!
The phrase to guess has 5 letters.
You may have 6 turns to guess the phrase!

Lernerkenntnisse: F-Strings (formatierte String-Literale) sind eine bequeme Möglichkeit, Ausdrücke in String-Literale einzubetten. Sie beginnen mit einem ‚f‘ und verwenden lockige Zahnspangen {} Um variable Werte oder Ausdrücke in Ihre Saiten einzubeziehen. F-Sader wurden in Python 3.6 eingeführt und sind lesbarer und im Allgemeinen schneller als ältere String-Formatierungsmethoden.

Schritt 7: Erstellen der Hauptspielschleife

Jetzt sind wir bereit, den Kern unseres Spiels aufzubauen: die Hauptschleife, mit der die Participant -Enter-, Spiellogik- und Gewinn-/Verlustbedingungen behandelt werden.

Beginnen wir mit der Grundstruktur, die die Benutzereingabe behandelt:

# Fundamental recreation loop
whereas used_turns < max_turns:
    guess = enter("Guess a phrase (or kind 'cease' to finish recreation):").decrease().strip()

    if guess == "cease":
        break

Dies stellt eine Schleife ein, die fortgesetzt wird, bis der Spieler alle Kurven genutzt hat. Wir bieten auch eine Escape -Choice, indem wir dem Spieler jederzeit „Cease“ eingeben können, um das Spiel zu beenden.

Erkenntnis lernen: Wenn Sie verwendet werden whereas Schleifen, es ist wichtig, eine klare Erkrankung zu haben, die irgendwann werden wird False (in diesem Fall, used_turns < max_turns). Es ist auch eine gute Praxis, eine Möglichkeit aufzunehmen, manuell aus der Schleife auszubrechen (wie unser „Cease“ -Befehl), um zu verhindern, dass das Spiel unbegrenzt läuft.

Schritt 8: Validierung der Benutzereingabe

Lassen Sie uns als nächstes die Validierung hinzufügen, um sicherzustellen, dass die Vermutung des Spielers ein gültiges Wort der richtigen Länge ist:

# Fundamental recreation loop with enter validation
whereas used_turns < max_turns:
    guess = enter("Guess a phrase (or kind 'cease' to finish recreation):").decrease().strip()

    if guess == "cease":
        break

    if len(guess) != len(selected_word) or not guess.isalpha():
        print(f"Please enter a {len(selected_word)} letter phrase.")
        proceed

Erkenntnis lernen: die isalpha() Methodenprüfungen, wenn eine Zeichenfolge nur alphabetische Zeichen (AZ oder AZ) enthält. Diese Validierung stellt sicher, dass die Spieler tatsächliche Wörter (keine Zahlen, Räume oder Sonderzeichen) der richtigen Länge eingeben. Der proceed Die Erklärung überspringt den Relaxation der aktuellen Schleife -Iteration und startet den nächsten und fordert effektiv nach einer neuen Vermutung.

Schritt 9: Erstbriefverarbeitung

Fügen wir nun die grundlegende Logik hinzu, um die Vermutung des Spielers an das Zielwort zu bewerten:

# Fundamental recreation loop with fundamental letter processing
whereas used_turns < max_turns:
    guess = enter("Guess a phrase (or kind 'cease' to finish recreation):").decrease().strip()

    if guess == "cease":
        break

    if len(guess) != len(selected_word) or not guess.isalpha():
        print(f"Please enter a {len(selected_word)} letter phrase.")
        proceed

    index = 0

    for letter in guess:
        if letter == selected_word(index):
            print(letter, finish=' ')
        elif letter in selected_word:
            misplaced_letters.append(letter)
            print("_", finish=' ')
        else:
            incorrect_letters.append(letter)
            print("_", finish=' ')
        index += 1

    print("n")
    print(f"Misplaced letters: {misplaced_letters}")
    print(f"Incorrect letters: {incorrect_letters}")

Diese grundlegende Implementierung überprüft jeden Temporary in der Vermutung und:

1. Zeigt den Buchstaben an, wenn er sich in der richtigen Place befindet
2. Fügt es hinzu, verlegt Buchstaben und zeigt einen Unterstrich an, wenn es im Wort ist, aber in der falschen Place
3. Fügt es falsche Buchstaben hinzu und zeigt einen Unterstrich an, wenn es überhaupt nicht im Wort ist

Lerneinblick: Wir verwenden die Indexierung, um Zeichen an derselben Place in beiden Zeichenfolgen zu vergleichen. Die Indexvariable verfolgt unsere Place im Zielwort, während wir die Vermutung iterieren. Dies ist eine gemeinsame Technik zum Vergleich von Elementen an entsprechenden Positionen in verschiedenen Sequenzen.

Sie können jedoch ein Drawback beim Ausführen dieses Codes bemerken. Wenn ein Temporary mehrmals in der Vermutung eines Spielers erscheint, wird er mehrmals zu unseren Monitoring -Pay attention hinzugefügt. Lassen Sie uns das als nächstes beheben.

Schritt 10: Umgang mit doppelten Buchstaben

Um das Suggestions -System unseres Spiels zu verbessern, müssen wir intelligenter mit doppelten Buchstaben umgehen:

# Accounting for duplicates in misplaced/incorrect letter lists
whereas used_turns < max_turns:
    guess = enter("Guess a phrase (or kind 'cease' to finish recreation):").decrease().strip()

    if guess == "cease":
        break

    if len(guess) != len(selected_word) or not guess.isalpha():
        print(f"Please enter a {len(selected_word)} letter phrase.")
        proceed

    index = 0

    for letter in guess:
        if letter == selected_word(index):
            print(letter, finish=' ')
            if letter in misplaced_letters:
                misplaced_letters.take away(letter)
        elif letter in selected_word:
            if letter not in misplaced_letters:
                misplaced_letters.append(letter)
            print("_", finish=' ')
        else:
            if letter not in incorrect_letters:
                incorrect_letters.append(letter)
            print("_", finish=' ')
        index += 1

    print("n")
    print(f"Misplaced letters: {misplaced_letters}")
    print(f"Incorrect letters: {incorrect_letters}")

Die wichtigsten Verbesserungen hier sind:

1. Briefe von misplaced Wenn sie in der richtigen Place gefunden werden:
   Wenn ein Spieler zum ersten Mal einen Buchstaben in der falschen Place und später in der richtigen Place erraten, entfernen wir ihn aus dem misplaced_letters Liste, da es nicht mehr verlegt ist.

   if letter == selected_word(index):
       print(letter, finish=' ')
       if letter in misplaced_letters:
           misplaced_letters.take away(letter)

2. Verhindern Sie doppelte Einträge in unseren Monitoring -Pay attention:
   Wir fügen nur einen Temporary zu unseren Monitoring -Pay attention hinzu, wenn es noch nicht vorhanden ist, und halten unser Suggestions sauber und leicht zu lesen.

   elif letter in selected_word:
       if letter not in misplaced_letters:
           misplaced_letters.append(letter)

Lerneinblick: Das Verwalten von Standing ist eine Schlüsselkomponente interaktiver Anwendungen. Im Laufe unseres Spiels müssen wir sicherstellen, dass unsere Monitoring -Daten genau und hilfreich bleiben. Diese Artwork von Staatsmanagement ist eine wertvolle Praxis für komplexere Programmieraufgaben, bei denen die Aufrechterhaltung konsistenter Daten erforderlich ist.

Schritt 11: Gewinn- und Verlustbedingungen hinzufügen

Schließlich vervollständigen wir unser Spiel, indem wir Gewinn- und Verlustbedingungen hinzufügen:

# Full recreation loop with win/loss situations
whereas used_turns < max_turns:
    guess = enter("Guess a phrase (or kind 'cease' to finish recreation):").decrease().strip()

    if guess == "cease":
        break

    if len(guess) != len(selected_word) or not guess.isalpha():
        print(f"Please enter a {len(selected_word)} letter phrase.")
        proceed

    index = 0

    for letter in guess:
        if letter == selected_word(index):
            print(letter, finish=' ')
            if letter in misplaced_letters:
                misplaced_letters.take away(letter)
        elif letter in selected_word:
            if letter not in misplaced_letters:
                misplaced_letters.append(letter)
            print("_", finish=' ')
        else:
            if letter not in incorrect_letters:
                incorrect_letters.append(letter)
            print("_", finish=' ')
        index += 1
    print("n")

    # Win situation
    if guess == selected_word:
        print("nCongratulations you guessed the phrase!")
        break

    used_turns += 1

    # Loss situation
    if used_turns == max_turns:
        print(f"nGame over, you misplaced. The phrase was: {selected_word}")
        break

    print(f"Misplaced letters: {misplaced_letters}")
    print(f"Incorrect letters: {incorrect_letters}")
    print(f"You may have {max_turns - used_turns} turns left.")

Erkenntnis Erkenntnis: Es ist wichtig, den Gewinnzustand vor dem Inkrementieren zu überprüfen used_turns. Dies stellt sicher, dass der Spieler sofort gewinnt, wenn er richtig erraten, ohne diese Vermutung als gebrauchte Wende unnötig zu zählen.

Das komplette Spiel

Lassen Sie uns alles zusammen in einen einzelnen Codeblock einfügen, um eine einfache Implementierung zu erhalten:

import random

# Arrange recreation variables
game_name = "Phrase Raider"
word_bank = ()

# Load phrases from file
with open("phrases.txt") as word_file:
    for line in word_file:
        word_bank.append(line.rstrip().decrease())

# Choose goal phrase
selected_word = random.selection(word_bank)

# Initialize recreation state
incorrect_letters = ()
misplaced_letters = ()
max_turns = 6
used_turns = 0

# Show recreation introduction
print(f"Welcome to {game_name}!")
print(f"The phrase to guess has {len(selected_word)} letters.")
print(f"You may have {max_turns} turns to guess the phrase!")

# Fundamental recreation loop
whereas used_turns < max_turns:
    guess = enter("Guess a phrase (or kind 'cease' to finish recreation):").decrease().strip()

    if guess == "cease":
        break

    if len(guess) != len(selected_word) or not guess.isalpha():
        print(f"Please enter a {len(selected_word)} letter phrase.")
        proceed

    index = 0

    for letter in guess:
        if letter == selected_word(index):
            print(letter, finish=' ')
            if letter in misplaced_letters:
                misplaced_letters.take away(letter)
        elif letter in selected_word:
            if letter not in misplaced_letters:
                misplaced_letters.append(letter)
            print("_", finish=' ')
        else:
            if letter not in incorrect_letters:
                incorrect_letters.append(letter)
            print("_", finish=' ')
        index += 1
    print("n")

    # Win situation
    if guess == selected_word:
        print("nCongratulations you guessed the phrase!")
        break

    used_turns += 1

    # Loss situation
    if used_turns == max_turns:
        print(f"nGame over, you misplaced. The phrase was: {selected_word}")
        break

    print(f"Misplaced letters: {misplaced_letters}")
    print(f"Incorrect letters: {incorrect_letters}")
    print(f"You may have {max_turns - used_turns} turns left.")

Spiel spielen

Hier ist ein Beispiel für eine Gameplay -Sitzung:

Welcome to Phrase Raider!
The phrase to guess has 5 letters.
You may have 6 turns to guess the phrase!

Guess a phrase (or kind 'cease' to finish recreation): hellooo
Please enter a 5 letter phrase.

Guess a phrase (or kind 'cease' to finish recreation): hi there
h _ l _ _

Misplaced letters: ('l')
Incorrect letters: ('e', 'o')
You may have 5 turns left.

Guess a phrase (or kind 'cease' to finish recreation): helps
h e l p s

Congratulations you guessed the phrase!

Nächste Schritte und Verbesserungen

Nachdem Sie nun ein Arbeitsspiel für das Arbeiten erstellt haben, finden Sie hier einige Ideen, um es zu verbessern und zu erweitern:

1. Variable Wortlänge: Ändern Sie Ihr Spiel, um mit Worten unterschiedlicher Längen zu arbeiten.
2. Hardmodus: Implementieren Sie einen „Arduous-Modus“ im Wurmstil, in dem in nachfolgende Vermutungen Buchstaben, die korrekt erraten wurden, in nachfolgenden Vermutungen verwendet werden müssen.
3. Wörterbuchvalidierung: Akzeptieren Sie nur Vermutungen, die echte Wörter sind, indem sie sich gegen ein Wörterbuch überprüfen.
4. Benutzerdefinierte Wortkategorien: Erlauben Sie den Spielern, Wortkategorien (Tiere, Länder usw.) auszuwählen.
5. Grafische Benutzeroberfläche: Verwenden Sie eine Bibliothek wie Pygame, um eine visuelle Schnittstelle zu erstellen.
6. Bewertungssystem: Fügen Sie ein Bewertungssystem hinzu, das darauf basiert, wie schnell der Spieler das Wort erraten.

Wir haben einige andere Projekte zur Walkthrough -Tutorials, die Sie auch genießen können:

Rezension

In diesem Tutorial haben wir mit Python ein Wortgut von Grund auf neu erstellt. Unterwegs haben wir wichtige Programmierkonzepte geübt, darunter:

• Verwenden von Pythons eingebauten Modulen
• Datei -E/A -Operationen
• Streichmanipulation
• Verwenden von Schleifen und Bedingungen
• Eingabevalidierung und -verarbeitung
• Sport State Administration

Spielentwicklung ist eine hervorragende Möglichkeit, Ihre Programmierkenntnisse zu verbessern und gleichzeitig etwas Spaßes und Interaktives zu schaffen. Die Konzepte, die Sie hier gelernt haben, insbesondere staatliche Administration- und Spielschleifen, bilden die Grundlage vieler anderer Spiele und Anwendungen.

Wenn Sie neu in Python sind oder einige Konzepte in diesem Tutorial herausfordern, unsere Herausforderung, unsere, unsere Python -Grundlagen für die Datenanalyse Der Kurs hilft Ihnen dabei, die für dieses Projekt erforderlichen grundlegenden Fähigkeiten zu erlernen. Der Kurs behandelt wesentliche Themen wie Schleifen, Bedingungen und String -Manipulation, die wir in diesem Spiel ausgiebig verwendet haben. Sobald Sie sich mit diesen Konzepten wohl fühlen, kommen Sie zurück, um Ihr eigenes Wort Raider -Spiel aufzubauen und die Herausforderungen der Verbesserung anzunehmen!