指挥行英语汉曼游戏

Question

Introduction

作为一名Python新手，我将刽子手游戏作为一种实践来实现，它对26个英文字母不敏感地操作案例。

我目前最关心的是我使用bytearray来存储这个单词，但是我也可能犯了其他初学者的错误。我想找出它们的位置并进行相应的改进。

码

import itertools


class Hangman:

    def __init__(self, target, guesses):
        assert target.isascii() and target.isalpha()

        self.target = bytearray(target.lower(), 'utf-8')
        self.guesses = guesses
        self.display = bytearray(itertools.repeat(ord('_'), len(target)))

    def run(self):
        while True:
            print()
            print()
            print(''.join(chr(byte) for byte in self.display))
            print()
            print(f'Remaining guesses: {self.guesses}')

            guess = input('Guess a letter: ')

            if len(guess) != 1:
                print('Invalid guess.')
                continue
            elif not guess.isascii() or not guess.isalpha():
                print('Non-letter guessed.')
                continue

            guess = ord(guess)

            if self.display.count(guess) != 0:
                print('Already guessed this letter.')
                continue

            if self.target.count(guess) == 0:
                self.guesses -= 1
            else:
                self.display = bytearray(
                    (
                        guess if target_c == guess else display_c
                    ) for display_c, target_c in zip(self.display, self.target)
                )

            if self.display == self.target:
                print()
                print()
                print(''.join(chr(byte) for byte in self.target))
                print('You won.')
                break
            elif self.guesses == 0:
                print()
                print()
                print(''.join(chr(byte) for byte in self.target))
                print()
                print('You lost.')
                break


if __name__ == '__main__':
    # Merriam-Webster Word of the Day: October 2, 2020
    hangman = Hangman('pachyderm', 6)
    hangman.run()

示例会话

$ python hangman.py


_________

Remaining guesses: 6
Guess a letter: a


_a_______

Remaining guesses: 6
Guess a letter: e


_a____e__

Remaining guesses: 6
Guess a letter: i


_a____e__

Remaining guesses: 5
Guess a letter: o


_a____e__

Remaining guesses: 4
Guess a letter: u


_a____e__

Remaining guesses: 3
Guess a letter: r


_a____er_

Remaining guesses: 3
Guess a letter: y


_a__y_er_

Remaining guesses: 3
Guess a letter: c


_ac_y_er_

Remaining guesses: 3
Guess a letter: h


_achy_er_

Remaining guesses: 3
Guess a letter: p


pachy_er_

Remaining guesses: 3
Guess a letter: d


pachyder_

Remaining guesses: 3
Guess a letter: m


pachyderm
You won.

Answer 1

使用更多的函数

目前，整个绞刑游戏都在run()调用中。您可以将它的某些部分拆分到它们自己的函数中，例如检查win条件、请求字符输入、显示当前状态等。

空prints

使用\n在控制台中获得一个新行，而不是放入空的print语句。

检查猜字符

对于字符串，您可以只检查字符是否在字符串中，因为您不需要对重复次数本身进行计数。

ord，chr和bytearray

它们毫无用处。您不需要序号的字节数组，只需将单词拆分成一个列表就足够了(虽然并不需要)。

类型提示

使用较新的python，类型提示功能也变得可用。使用它们可以帮助您处理变量的值类型。

因此，您的程序也可以重写如下：

class Hangman:
    def __init__(self, target: str, guesses: int):
        assert self.is_ascii_alphabetical(
            target
        ), "Provided secret word is not ascii alphabetical string."
        self.secret_word = target
        self.guesses = guesses
        self.guessed_word = ["_"] * len(target)
        self._finish = False

    def is_ascii_alphabetical(self, value: str) -> bool:
        return value.isascii() and value.isalpha()

    def display(self, real_word: bool = False):
        if not real_word:
            print(f"\n\n{''.join(self.guessed_word)}\n")
        else:
            print(f"\n\n{self.secret_word}\n")

    def read_character(self) -> str:
        while True:
            guess = input("Guess a letter: ")
            if len(guess) != 1:
                print("Invalid guess.")
                continue
            elif not self.is_ascii_alphabetical(guess):
                print("Non-letter guessed.")
                continue
            if self.is_guess_repeat(guess):
                print("Already guessed this letter.")
                continue
        return guess.lower()

    def update_guessed_word(self, character: str) -> None:
        self.guessed_word = [
            new if new == character else old
            for old, new in zip(self.guessed_word, self.secret_word)
        ]

    def is_guess_repeat(self, guess: str) -> bool:
        return guess in self.guessed_word

    def is_guess_valid(self, guess: str) -> bool:
        if guess not in self.secret_word:
            return False
        return True

    def is_game_over(self) -> bool:
        return self.guesses <= 0

    def is_game_won(self) -> bool:
        return "_" not in self.guessed_word

    def run(self):
        while not self._finish:
            self.display()
            print(f"Remaining guesses: {self.guesses}")
            guess = self.read_character()
            if self.is_guess_valid(guess):
                self.update_guessed_word(guess)
            else:
                self.guesses -= 1
            if self.is_game_won():
                self.display(True)
                print("You won.")
                self._finish = True
            elif self.is_game_over():
                self.display(True)
                print("You lost.")
                self._finish = True


if __name__ == "__main__":
    # Merriam-Webster Word of the Day: October 2, 2020
    hangman = Hangman("pachyderm", 6)
    hangman.run()