单词猜谜游戏重玩功能异常：猜测次数未重置致直接失败

问题现象 #

开发的单词猜谜游戏支持玩家在获胜或失败后选择切换模式或重玩当前模式，菜单选项为：1重玩普通模式、2无限次数模式、3硬核1次猜测模式、Q退出。但输入1重玩普通模式时，游戏重启后直接判定失败，原因是全局变量guesses未重置为初始值5。

错误日志 #

(1) Play guessing game
(2) Infinite mode
(3) Hardcore mode
(Q) Quit
Enter your choice: 1
Your word is one of these: ['ant', 'baboon', 'badger', 'bat', 'bear', 'beaver', 'camel', 'cat', 'clam', 'cobra', 'cougar', 'coyote', 'crow', 'deer', 'dog', 'donkey', 'duck', 'eagle', 'ferret', 'fox', 'frog', 'goat', 'goose', 'hawk', 'lion', 'lizard', 'llama', 'mole', 'monkey', 'moose', 'mouse', 'mule', 'newt', 'otter', 'owl', 'panda', 'parrot', 'pigeon', 'python', 'rabbit', 'ram', 'rat', 'raven', 'rhino', 'salmon', 'seal', 'shark', 'sheep', 'skunk', 'sloth', 'snake', 'spider', 'stork', 'swan', 'tiger', 'toad', 'trout', 'turkey', 'turtle', 'weasel', 'whale', 'wolf', 'wombat', 'zebra']
You have chosen a/an 3-letter word.
Enter a letter: m
Bad guess :(
---
Guesses left: 4
Available letters: A B C D E F G H I J K L N O P Q R S T U V W X Y Z.
Enter a letter: k
Bad guess :(
---
Guesses left: 3
Available letters: A B C D E F G H I J L N O P Q R S T U V W X Y Z.
Enter a letter: u
Bad guess :(
---
Guesses left: 2
Available letters: A B C D E F G H I J L N O P Q R S T V W X Y Z.
Enter a letter: r
Bad guess :(
---
Guesses left: 1
Available letters: A B C D E F G H I J L N O P Q S T V W X Y Z.
Enter a letter: o
Bad guess :(
---
Guesses left: 0
Available letters: A B C D E F G H I J L N P Q S T V W X Y Z.
You ran out of guesses. YOU LOST! The answer is BAT
(1) Play guessing game
(2) Infinite mode
(3) Hardcore mode
(Q) Quit
Enter your choice: 1
Your word is one of these: ['ant', 'baboon', 'badger', 'bat', 'bear', 'beaver', 'camel', 'cat', 'clam', 'cobra', 'cougar', 'coyote', 'crow', 'deer', 'dog', 'donkey', 'duck', 'eagle', 'ferret', 'fox', 'frog', 'goat', 'goose', 'hawk', 'lion', 'lizard', 'llama', 'mole', 'monkey', 'moose', 'mouse', 'mule', 'newt', 'otter', 'owl', 'panda', 'parrot', 'pigeon', 'python', 'rabbit', 'ram', 'rat', 'raven', 'rhino', 'salmon', 'seal', 'shark', 'sheep', 'skunk', 'sloth', 'snake', 'spider', 'stork', 'swan', 'tiger', 'toad', 'trout', 'turkey', 'turtle', 'weasel', 'whale', 'wolf', 'wombat', 'zebra']
You have chosen a/an 5-letter word.
You ran out of guesses. YOU LOST! The answer is WHALE
(1) Play guessing game
(2) Infinite mode
(3) Hardcore mode
(Q) Quit
Enter your choice: 

原代码 #

import random as r
import math
from time import sleep

guesses = 5
guesses_inf = ("infinite")
guesses_hard = 1
letters = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')


def format_word(guessed_letters, word):
    formatted_string = ''
    for letter in word:
        if letter in guessed_letters:
            formatted_string += letter
        else:
            formatted_string += '-'
    return formatted_string

#display guessing game
def display_info(guessed_letters, word):
    available_letters = ' '.join([
        letter for letter in letters if letter not in guessed_letters
    ])
    print(format_word(guessed_letters, word))
    print(f"Guesses left: {guesses}")
    print(f"Available letters: {available_letters}.")

#check guess 
def check_guess(guess, word, guessed_letters):
    global guesses
    if guess in letters and len(guess) == 1 and guess not in guessed_letters:
        guessed_letters.append(guess)
        if guess in word:
            print("Good guess!")
        else:
            print("Bad guess :(")
            guesses -= 1
    else:
        if len(guess) != 1:
            print("You can only enter one letter at a time!")
        elif guess.upper() not in letters:
            print("Your guess has to be a letter!")
        elif guess in guessed_letters:
            print("You have already tried this!")
    display_info(guessed_letters, word)

def can_be_formed_from(letters, word):
    for letter in word:
        if letter not in letters:
            return False
    return True

#play game
def play_game():
    word_list = 'ant baboon badger bat bear beaver camel cat clam cobra cougar coyote crow deer dog donkey duck eagle ferret fox frog goat goose hawk lion lizard llama mole monkey moose mouse mule newt otter owl panda parrot pigeon python rabbit ram rat raven rhino salmon seal shark sheep skunk sloth snake spider stork swan tiger toad trout turkey turtle weasel whale wolf wombat zebra'.split()
    secret_word = r.choice(word_list).upper()
    word_length = len(secret_word)
    guessed = []
    print(f"Your word is one of these: {word_list}")
    print(f"You have chosen a/an {word_length}-letter word.")
    while guesses > 0:
        guess = input("Enter a letter: ")
        guess = guess.upper()
        check_guess(guess, secret_word, guessed)
        if can_be_formed_from(guessed, secret_word):
            return print("YOU WON!")
    print(f"You ran out of guesses. YOU LOST! The answer is {secret_word}")

#INFINITE GAMEMODE

#display info infinite
def display_info_inf(guessed_letters, word):
    available_letters = ' '.join([
        letter for letter in letters if letter not in guessed_letters
    ])
    print(format_word(guessed_letters, word))
    print("Guesses left: infinite")
    print(f"Available letters: {available_letters}.")

    
#check guesses infinite
def check_guess_inf(guess, word, guessed_letters):
    global guesses_inf
    if guess in letters and len(guess) == 1 and guess not in guessed_letters:
        guessed_letters.append(guess)
        if guess in word:
            print("Good guess!")
        else:
            print("Bad guess :(")
    else:
        if len(guess) != 1:
            print("You can only enter one letter at a time!")
        elif guess.upper() not in letters:
            print("Your guess has to be a letter!")
        elif guess in guessed_letters:
            print("You have already tried this!")
    display_info_inf(guessed_letters, word)

def can_be_formed_from(letters, word):
    for letter in word:
        if letter not in letters:
            return False
    return True
    
    
    
#play_game infinite
def play_game_infinite():
    word_list = 'ant baboon badger bat bear beaver camel cat clam cobra cougar coyote crow deer dog donkey duck eagle ferret fox frog goat goose hawk lion lizard llama mole monkey moose mouse mule newt otter owl panda parrot pigeon python rabbit ram rat raven rhino salmon seal shark sheep skunk sloth snake spider stork swan tiger toad trout turkey turtle weasel whale wolf wombat zebra'.split()
    secret_word = r.choice(word_list).upper()
    word_length = len(secret_word)
    guessed = []
    print(f"You have chosen a/an {word_length}-letter word.")
    while guesses_inf:
        guess = input("Enter a letter: ")
        guess = guess.upper()
        check_guess_inf(guess, secret_word, guessed)
        if can_be_formed_from(guessed, secret_word):
            return print("YOU WON!")

#Hardcore game start here

#display info hard
def display_info_hard(guessed_letters, word):
    available_letters = ' '.join([
        letter for letter in letters if letter not in guessed_letters
    ])
    print(format_word(guessed_letters, word))
    print(f"Guesses left: {guesses_hard}")

    
#check guesses infinite
def check_guess_hard(guess, word, guessed_letters):
    global guesses_hard
    if guess in letters and len(guess) == 1 and guess not in guessed_letters:
        guessed_letters.append(guess)
        if guess in word:
            ask = input("Is this your final answer?(y/n): ")
            if ask == "y":
                print("Good guess!")
            else:
                return play_game_hard()
        else:
            ask = input("Is this your final answer?(y/n): ")
            if ask == "y":
                print("Oops :(")
                guesses_hard -= 1
    else:
        if len(guess) != 1:
            print("You can only enter one letter at a time!")
        elif guess.upper() not in letters:
            print("Your guess has to be a letter!")
        elif guess in guessed_letters:
            print("You have already tried this!")
    display_info_hard(guessed_letters, word)

def can_be_formed_from(letters, word):
    for letter in word:
        if letter not in letters:
            return False
    return True

    
#play_game hard
def play_game_hard():
    word_list = 'ant baboon badger bat bear beaver camel cat clam cobra cougar coyote crow deer dog donkey duck eagle ferret fox frog goat goose hawk lion lizard llama mole monkey moose mouse mule newt otter owl panda parrot pigeon python rabbit ram rat raven rhino salmon seal shark sheep skunk sloth snake spider stork swan tiger toad trout turkey turtle weasel whale wolf wombat zebra'.split()
    secret_word = r.choice(word_list).upper()
    word_length = len(secret_word)
    guessed = []
    print(f"You have chosen a/an {word_length}-letter word.")
    while guesses_hard:
        guess = input("Enter a letter: ")
        guess = guess.upper()
        check_guess_hard(guess, secret_word, guessed)
        if can_be_formed_from(guessed, secret_word):
            return print("YOU'RE A GENIUS or is it luck?")
    print(f"YOU LOST! The answer is {secret_word}")
    
    
def menu():
    while True:
        print("(1) Play guessing game")
        print("(2) Infinite mode")
        print("(3) Hardcore mode")
        print("(Q) Quit")
        choice = input("Enter your choice: ").lower()
        if choice == "1":
            play_game()
        elif choice == "2":
            print("IN BETA")
            sleep(1.00)
            play_game_infinite()
        elif choice == "3":
            print("IN BETA")
            sleep(1.00)
            play_game_hard()
        elif choice == "q":
            return False
        else:
            print(f"Not a correct choice: {choice}")
            

    
if __name__ == "__main__":
    menu()

修复方案 #

方案1：重置全局变量（快速修复） #

在play_game函数开头添加全局变量声明并重置guesses为初始值5，确保每次重玩时猜测次数回到初始状态：

def play_game():
    global guesses
    guesses = 5  # 重置猜测次数
    word_list = 'ant baboon badger bat bear beaver camel cat clam cobra cougar coyote crow deer dog donkey duck eagle ferret fox frog goat goose hawk lion lizard llama mole monkey moose mouse mule newt otter owl panda parrot pigeon python rabbit ram rat raven rhino salmon seal shark sheep skunk sloth snake spider stork swan tiger toad trout turkey turtle weasel whale wolf wombat zebra'.split()
    # 原函数剩余代码不变

方案2：使用局部变量（推荐，避免全局变量副作用） #

将guesses改为play_game的局部变量，修改相关函数传递并更新该值，彻底消除全局变量带来的状态残留问题：

1. 删除全局变量guesses = 5
2. 修改play_game函数，将guesses作为局部变量管理：

def play_game():
    guesses = 5  # 局部变量存储猜测次数
    word_list = 'ant baboon badger bat bear beaver camel cat clam cobra cougar coyote crow deer dog donkey duck eagle ferret fox frog goat goose hawk lion lizard llama mole monkey moose mouse mule newt otter owl panda parrot pigeon python rabbit ram rat raven rhino salmon seal shark sheep skunk sloth snake spider stork swan tiger toad trout turkey turtle weasel whale wolf wombat zebra'.split()
    secret_word = r.choice(word_list).upper()
    word_length = len(secret_word)
    guessed = []
    print(f"Your word is one of these: {word_list}")
    print(f"You have chosen a/an {word_length}-letter word.")
    while guesses > 0:
        guess = input("Enter a letter: ")
        guess = guess.upper()
        # 接收check_guess返回的更新后猜测次数
        guesses = check_guess(guess, secret_word, guessed, guesses)
        if can_be_formed_from(guessed, secret_word):
            return print("YOU WON!")
    print(f"You ran out of guesses. YOU LOST! The answer is {secret_word}")

3. 修改check_guess函数，添加guesses参数并返回更新后的值：

def check_guess(guess, word, guessed_letters, guesses):
    if guess in letters and len(guess) == 1 and guess not in guessed_letters:
        guessed_letters.append(guess)
        if guess in word:
            print("Good guess!")
        else:
            print("Bad guess :(")
            guesses -= 1
    else:
        if len(guess) != 1:
            print("You can only enter one letter at a time!")
        elif guess.upper() not in letters:
            print("Your guess has to be a letter!")
        elif guess in guessed_letters:
            print("You have already tried this!")
    display_info(guessed_letters, word, guesses)  # 传递guesses给display_info
    return guesses  # 返回更新后的猜测次数

4. 修改display_info函数，添加guesses参数：

def display_info(guessed_letters, word, guesses):
    available_letters = ' '.join([
        letter for letter in letters if letter not in guessed_letters
    ])
    print(format_word(guessed_letters, word))
    print(f"Guesses left: {guesses}")
    print(f"Available letters: {available_letters}.")

同理，硬核模式的guesses_hard也存在相同的全局变量状态残留问题，建议采用相同逻辑改为局部变量，避免后续重玩时出现同类BUG。

内容的提问来源于stack exchange，提问作者Clacky