%: 'Matematik' og 'tuple' i et gættespil: Ikke-understøttede operandtyper: Sådan rettes det

Almindelig Python-fejl ved opbygning af et interaktivt gættespil

Når du lærer Python, er et af de mest spændende projekter at bygge interaktive spil som et talgættespil. Sådanne projekter hjælper dig med at forstå, hvordan Python interagerer med brugerinput og bruger kontrolflow til at guide programmets adfærd. I dette tilfælde er målet at få Python til at bede brugeren om at gætte et tal mellem 1 og 100, give feedback til at gætte højere eller lavere, og endelig bekræfte, hvornår det korrekte gæt er lavet.

Men som med mange programmeringsøvelser kan der opstå fejl, som ikke umiddelbart er klare. En fejl du kan støde på, mens du følger en Python-tutorial, som den du arbejder på, er de ikke-understøttede operandtyper for %: 'Math' og 'tuple'. Dette kan være frustrerende, især når syntaksen virker korrekt ved første øjekast.

I dette gættespil sker den fejl, du står over for, typisk, når du forsøger at formatere en streng forkert, mens du bruger Matematik funktion i IPython.display bibliotek. Dette er en almindelig fejl, men løsningen er ligetil, når først den er identificeret.

Denne guide vil lede dig gennem, hvad fejlen betyder, hvorfor den opstår, og hvordan du kan ændre din Python-kode for at rette den. Til sidst vil du have et fuldt fungerende gættespil uden den forvirrende fejlmeddelelse!

Forstå mekanikken bag Pythons gættespilkode

Python gættespilsscriptet er designet til at give brugeren mulighed for at gætte et tilfældigt genereret tal mellem 1 og 100. Det første vigtige element i dette program er brugen af random.randint() funktion, som genererer et tilfældigt heltal inden for det angivne interval (1 til 100). Dette danner kernelogikken bag spillet, da det giver det hemmelige nummer, som brugeren skal gætte. Programmet beder derefter brugeren om at indtaste deres gæt ved hjælp af input() funktion, som fanger brugerinput som en streng og senere konverteres til et heltal til sammenligningsformål.

Løkkestrukturen spiller en afgørende rolle i styringen af ​​spillets flow. EN mens loop bruges til løbende at kontrollere brugerens gæt mod det tilfældigt genererede tal. Så længe brugerens gæt er forkert, fortsætter løkken med at bede spilleren om at enten "Gæt højere" eller "Gæt lavere". Betingelsen inde i løkken sammenligner brugerens gæt med det hemmelige nummer, hvilket sikrer, at spillet giver passende feedback uden at afslutte for tidligt. Ved at håndtere brugerinput på denne måde bliver spillet interaktivt og guider spilleren mod det rigtige svar.

I det andet script ved hjælp af IPython.display, introducerer vi et mere sofistikeret outputformat med Matematik(), en funktion, der bruges til at vise meddelelser i matematisk notation. Den første brug af procentsymbolet (%) til at formatere meddelelsen med flere variabler forårsagede dog en fejl: ikke-understøttede operandtyper for %: 'Math' og 'tuple'. Denne fejl opstår pga Matematik understøtter ikke denne form for strenginterpolation. I stedet løses dette problem ved at bruge Pythons moderne f-streng-formatering, som er mere intuitivt, og viser en korrekt formateret besked i slutningen af ​​spillet, når brugeren gætter rigtigt.

Derudover integrerer det tredje script et sæt af enhedstest skrevet ved hjælp af Python's enhedstest rammer. Formålet med disse test er at automatisere valideringen af ​​spillets funktionalitet og sikre, at spillet opfører sig som forventet i forskellige scenarier. Ved at håne input() funktion ved hjælp af unittest.mock.patch, simulerer vi brugerinput under test uden at kræve manuel input. Denne tilgang forbedrer kodens robusthed, hvilket giver udviklere mulighed for at verificere spillets logik under forskellige forhold. Enhedstest hjælper med at fange potentielle fejl tidligt og sikrer, at eventuelle ændringer i programmet ikke bryder eksisterende 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()

Optimering af Python-strengformatering til visning i interaktive programmer

Et nøgleaspekt ved at udvikle et talgættespil i Python er, hvordan programmet interagerer med brugeren. Specifikt, når du viser meddelelser som "Gæt højere" eller "Gæt lavere", er det vigtigt at sikre klar og præcis formatering. En almindelig udfordring ved brug af biblioteker som f.eks IPython.display formaterer outputstrenge korrekt. Selvom det er traditionelt at bruge procentsymbolet (%) til strenginterpolation, kan det føre til fejl som ikke-understøttede operandtyper for %: 'Math' og 'tuple'. Dette problem opstår, fordi visse biblioteker, som f.eks Matematik(), kræver alternative tilgange som f-streng formatering.

I moderne Python-programmering tilbyder f-strenge en mere effektiv og læsbar måde at indsætte variabler i strenge på. For eksempel, i stedet for at skrive "Tillykke! Det korrekte tal var %g," kan du bruge en f-streng som f.eks. f'Congratulations! The correct number was {number}'. F-strenge giver dig mulighed for direkte at indlejre udtryk, hvilket gør koden mere kortfattet og eliminerer de risici, der er forbundet med traditionel strenginterpolation. Dette forbedrer ikke kun læsbarheden, men forhindrer også almindelige formateringsfejl.

Ud over at bruge f-strenge er en anden vigtig overvejelse, når du bygger interaktive programmer, validering af brugerinput. Når man accepterer input fra brugere, især i et spil, hvor gæt gentagne gange indtastes, er håndtering af potentielle undtagelser, såsom ikke-heltal input, afgørende. Implementering try-except blokke sikrer, at programmet ikke går ned på grund af ugyldig input. I stedet kan det på en yndefuld måde bede brugeren om at indtaste gyldige data og derved forbedre den overordnede brugeroplevelse. Denne kombination af optimeret strengformatering og inputvalidering fører til mere robuste og brugervenlige Python-applikationer.