%: "Math" och "tuple" i ett gissningsspel: Operandtyper som inte stöds: Hur man fixar det

Vanligt Python-fel när du bygger ett interaktivt gissningsspel

När du lär dig Python är ett av de mest spännande projekten att bygga interaktiva spel som ett gissningsspel. Sådana projekt hjälper dig att förstå hur Python interagerar med användarinput och använder kontrollflödet för att styra programmets beteende. I det här fallet är målet att få Python att uppmana användaren att gissa ett tal mellan 1 och 100, ge feedback för att gissa högre eller lägre, och slutligen bekräfta när rätt gissning är gjord.

Men som med många programmeringsövningar kan fel uppstå som inte är omedelbart tydliga. Ett fel du kan stöta på när du följer en Python-handledning, som den du arbetar med, är de operandtyper som inte stöds för %: 'Math' och 'tuple'. Detta kan vara frustrerande, särskilt när syntaxen verkar korrekt vid första anblicken.

I det här gissningsspelet inträffar vanligtvis felet du står inför när du försöker formatera en sträng felaktigt medan du använder Matematik funktion i IPython.display bibliotek. Detta är ett vanligt misstag, men lösningen är enkel när den väl har identifierats.

Den här guiden går igenom vad felet betyder, varför det uppstår och hur du kan ändra din Python-kod för att fixa det. I slutet kommer du att ha ett fullt fungerande gissningsspel utan det förvirrande felmeddelandet!

Förstå mekaniken bakom Pythons gissningsspelkod

Python gissningsspelsskriptet är utformat för att låta användaren gissa ett slumpmässigt genererat tal mellan 1 och 100. Det första viktiga elementet i detta program är användningen av random.randint() funktion, som genererar ett slumpmässigt heltal inom det angivna intervallet (1 till 100). Detta utgör kärnlogiken bakom spelet, eftersom det ger det hemliga numret som användaren måste gissa. Programmet uppmanar sedan användaren att mata in sin gissning med hjälp av input() funktion, som fångar användarinmatning som en sträng och senare omvandlas till ett heltal för jämförelseändamål.

Slingstrukturen spelar en avgörande roll för att kontrollera spelets flöde. A medan loop används för att kontinuerligt kontrollera användarens gissningar mot det slumpmässigt genererade numret. Så länge användarens gissning är felaktig, fortsätter loopen att uppmana spelaren att antingen "Gissa högre" eller "Gissa lägre." Tillståndet inuti slingan jämför användarens gissning med det hemliga numret, vilket säkerställer att spelet ger lämplig feedback utan att ta slut i förtid. Genom att hantera användarinmatning på detta sätt blir spelet interaktivt och vägleder spelaren mot rätt svar.

I det andra skriptet använder du IPython.display, introducerar vi ett mer sofistikerat utdataformat med Matematik(), en funktion som används för att visa meddelanden i matematisk notation. Den initiala användningen av procentsymbolen (%) för att formatera meddelandet med flera variabler orsakade dock ett fel: operandtyp(er) som inte stöds för %: 'Math' och 'tuple'. Detta fel uppstår pga Matematik stöder inte denna form av stränginterpolation. Istället löser det här problemet att använda Pythons moderna f-strängsformatering, som är mer intuitivt, och visar ett korrekt formaterat meddelande i slutet av spelet när användaren gissar rätt.

Dessutom integrerar det tredje skriptet en uppsättning av enhetstester skriven med Python's enhetstest ram. Syftet med dessa tester är att automatisera valideringen av spelets funktionalitet, för att säkerställa att spelet beter sig som förväntat i olika scenarier. Genom att håna input() funktion med hjälp av unittest.mock.patch, simulerar vi användarinmatningar under testning utan att kräva manuell inmatning. Detta tillvägagångssätt förbättrar kodens robusthet, vilket gör att utvecklare kan verifiera spelets logik under olika förhållanden. Enhetstest hjälper till att fånga upp potentiella buggar tidigt, vilket säkerställer att eventuella ändringar i programmet inte bryter mot befintlig funktionalitet.

# Importing required libraries
import random
# Function for the guessing game
def guessing_game():
    # Generate a random number between 1 and 100
    number_to_guess = random.randint(1, 100)
    user_guess = None
    # Loop until the user guesses the correct number
    while user_guess != number_to_guess:
        try:
            # Get input from the user
            user_guess = int(input('Guess a number between 1 and 100: '))
        except ValueError:
            print('Please enter a valid number.')
            continue
        # Provide hints for guessing higher or lower
        if user_guess < number_to_guess:
            print('Guess higher!')
        elif user_guess > number_to_guess:
            print('Guess lower!')
    # Congratulate the user when they guess correctly
    print(f'Congratulations! The correct number was {number_to_guess}.')
# Call the function
guessing_game()

# Importing required libraries from IPython
from IPython.display import display, Math
import random
# Function for the guessing game with IPython display
def guessing_game_ipython():
    number_to_guess = random.randint(1, 100)
    user_guess = None
    while user_guess != number_to_guess:
        try:
            user_guess = int(input('Guess a number between 1 and 100: '))
        except ValueError:
            print('Please enter a valid number.')
            continue
        if user_guess < number_to_guess:
            print('Guess higher!')
        elif user_guess > number_to_guess:
            print('Guess lower!')
    # Correctly formatting using the f-string instead of % formatting
    display(Math(f'Congratulations! The correct number was {number_to_guess} and you typed {user_guess}'))
# Call the function
guessing_game_ipython()

import unittest
from unittest.mock import patch
import random
# Function for the guessing game to be tested
def guessing_game_tested():
    number_to_guess = random.randint(1, 100)
    user_guess = None
    while user_guess != number_to_guess:
        user_guess = int(input('Guess a number between 1 and 100: '))
    return number_to_guess, user_guess
# Test class for the guessing game
class TestGuessingGame(unittest.TestCase):
    @patch('builtins.input', side_effect=[50, 75, 85, 95, 100])
    def test_guessing_game(self, mock_input):
        result = guessing_game_tested()
        self.assertEqual(result, (100, 100))
# Run the tests
if __name__ == '__main__':
    unittest.main()

Optimera Python-strängformatering för visning i interaktiva program

En viktig aspekt av att utveckla ett gissningsspel i Python är hur programmet interagerar med användaren. Närmare bestämt, när du visar meddelanden som "Gissa högre" eller "Gissa lägre", är det viktigt att säkerställa tydlig och exakt formatering. En vanlig utmaning när man använder bibliotek som IPython.display formaterar utdatasträngar korrekt. Även om det är traditionellt att använda procentsymbolen (%) för stränginterpolation, kan det leda till fel som operandtyper som inte stöds för %: 'Math' och 'tuple'. Det här problemet uppstår eftersom vissa bibliotek, t.ex Matematik(), kräver alternativa metoder som f-strängsformatering.

I modern Python-programmering erbjuder f-strängar ett mer effektivt och läsbart sätt att infoga variabler i strängar. Till exempel, istället för att skriva "Grattis! Rätt nummer var %g", kan du använda en f-sträng som f'Congratulations! The correct number was {number}'. F-strängar låter dig bädda in uttryck direkt, vilket gör koden mer koncis och eliminerar riskerna förknippade med traditionell stränginterpolation. Detta förbättrar inte bara läsbarheten utan förhindrar också vanliga formateringsfel.

Förutom att använda f-strängar är en annan viktig faktor när man bygger interaktiva program validering av användarinmatning. När man accepterar input från användare, särskilt i ett spel där gissningar upprepas gånger, är hantering av potentiella undantag, såsom icke-heltalsinmatningar, avgörande. Genomförande try-except block ser till att programmet inte kraschar på grund av ogiltig inmatning. Istället kan det på ett elegant sätt uppmana användaren att ange giltig data, och därmed förbättra den övergripande användarupplevelsen. Denna kombination av optimerad strängformatering och indatavalidering leder till mer robusta och användarvänliga Python-applikationer.