Python Hangman spēles izveide: rakstzīmju ievades cilpu apgūšana

Hangman spēles izveide programmā Python: efektīva ievades validācija

Šī pieeja izmanto Python aizmugursistēmas ieviešanai, koncentrējoties uz ievades validāciju un spēles loģiku ar modulāru struktūru.

# Hangman Game: Using nested loops and clear input validation
def hangman_game():
    print("Let's Play Hangman Game!")
    # Prompt user for a valid English word
    while True:
        vocab = input("Please enter an English word: ")
        if vocab.isalpha():
            uppercase_vocab = vocab.upper()
            break
        else:
            print(f"Your input '{vocab}' is not a valid English word.")
    # Initialize display for the word
    display = ["_" for _ in range(len(uppercase_vocab))]
    print(" ".join(display))
    # Start guessing loop
    while True:
        word = input("Please enter an alphabetic character: ")
        if len(word) == 1 and word.isalpha():
            uppercase_word = word.upper()
            # Update display if the guessed letter is correct
            for i in range(len(uppercase_vocab)):
                if uppercase_vocab[i] == uppercase_word:
                    display[i] = uppercase_word
            print(" ".join(display))
            # Check if the game is won
            if "_" not in display:
                print("Congratulations! You've guessed the word!")
                break
        else:
            print(f"Your input '{word}' is not valid.")
# Run the game
hangman_game()

Uzlabota Hangman spēle ar OOP pieeju

Šis risinājums izmanto Python objektorientētās programmēšanas (OOP) paradigmu, lai nodrošinātu labāku modularitāti un koda atkārtotu izmantošanu.

class Hangman:
    def __init__(self, word):
        self.word = word.upper()
        self.display = ["_" for _ in self.word]
        self.guessed = set()
    def is_valid_guess(self, guess):
        return len(guess) == 1 and guess.isalpha()
    def update_display(self, guess):
        for i, letter in enumerate(self.word):
            if letter == guess:
                self.display[i] = guess
    def play(self):
        print("Welcome to OOP Hangman!")
        while "_" in self.display:
            print(" ".join(self.display))
            guess = input("Guess a letter: ").upper()
            if not self.is_valid_guess(guess):
                print("Invalid input. Please try again.")
                continue
            if guess in self.guessed:
                print(f"You've already guessed '{guess}'. Try another.")
                continue
            self.guessed.add(guess)
            self.update_display(guess)
        print(f"Congratulations! You've guessed the word: {self.word}")
# Example usage
if __name__ == "__main__":
    vocab = input("Enter a word for the Hangman game: ").strip()
    if vocab.isalpha():
        game = Hangman(vocab)
        game.play()
    else:
        print("Please provide a valid word.")

Vienības testi bendes spēlei

Šajā sadaļā ir iekļauti vienību testi, izmantojot Python moduli “unittest”, lai apstiprinātu Hangman spēles komponentu funkcionalitāti.

import unittest
from hangman_game import Hangman
class TestHangman(unittest.TestCase):
    def test_is_valid_guess(self):
        game = Hangman("Python")
        self.assertTrue(game.is_valid_guess("p"))
        self.assertFalse(game.is_valid_guess("Py"))
        self.assertFalse(game.is_valid_guess("1"))
    def test_update_display(self):
        game = Hangman("Python")
        game.update_display("P")
        self.assertEqual(game.display[0], "P")
    def test_game_winning_condition(self):
        game = Hangman("Hi")
        game.update_display("H")
        game.update_display("I")
        self.assertNotIn("_", game.display)
if __name__ == "__main__":
    unittest.main()

Bieži uzdotie jautājumi par Python Hangman spēli

1. Kā nodrošināt, ka spēlētāji ievada tikai derīgus minējumus?
2. Izmantot isalpha() lai atļautu tikai alfabēta rakstzīmes un len() lai ierobežotu ievadi līdz vienai rakstzīmei.
3. Vai varu padarīt spēli nejutīgu pret reģistru?
4. Jā, konvertējiet visas ievades un iepriekš iestatīto vārdu uz lielajiem burtiem, izmantojot upper() konsekventai saskaņošanai.
5. Kā izsekot jau uzminētos burtus?
6. Jūs varat izmantot a set() lai saglabātu uzminētos burtus. Pirms pieņemat to kā jaunu minējumu, pārbaudiet, vai komplektā ir burts.
7. Kā rīkoties ar nederīgām ievadēm?
8. Izmantojiet cilpu ar nosacījumu priekšrakstiem, lai atkārtoti prasītu atskaņotāju, līdz tie nodrošina derīgu ievadi. Piemēram, pārbaudiet ar if len(word) == 1 and word.isalpha().
9. Vai es varu pievienot spēlei punktu skaitīšanas sistēmu?
10. Jā, uzturiet skaitītāju par nepareiziem minējumiem vai kopējo mēģinājumu skaitu un parādiet to spēlētājam pēc katra minējuma.

Pilnīgs bendes spēles noslēgums

Spēle Hangman programmā Python māca tādas vērtīgas prasmes kā ievades validācija un lietotāja mijiedarbības dizains. Izveidojot efektīvu cilpu ar kamēr True, spēlētāji var baudīt nevainojamu minēšanas pieredzi. Vizuāla atgriezeniskā saite un beigu apstākļi uzlabo spēles iesaistīšanos. 🧩

Sākot ar nederīgu minējumu apstrādi un beidzot ar burtu izsekošanu, šī spēle piedāvā praktiskus Python iespēju piemērus. Šos ieskatus var izmantot citās interaktīvās lietojumprogrammās, nodrošinot spēlētājiem motivāciju un atalgojumu visā pieredzes laikā. Hangman joprojām ir klasisks veids, kā efektīvi apgūt programmēšanu. 🚀