%: 'Matemaatika' ja 'korter' arvamismängus: Toetamata operandi tüüp(id): kuidas seda parandada

Levinud Pythoni viga interaktiivse äraarvamismängu loomisel

Pythoni õppimisel on üks põnevamaid projekte interaktiivsete mängude ehitamine nagu numbrite äraarvamise mäng. Sellised projektid aitavad teil mõista, kuidas Python suhtleb kasutaja sisendiga ja kasutab programmi käitumise juhtimiseks juhtimisvoogu. Sel juhul on eesmärk, et Python paluks kasutajal arvata arv vahemikus 1 kuni 100, andes tagasisidet, et arvata suurem või väiksem, ja lõpuks kinnitada, millal on õige oletus tehtud.

Kuid nagu paljude programmeerimisharjutuste puhul, võib tekkida vigu, mis pole kohe selged. Üks tõrge, mis võib Pythoni õpetust järgides ilmneda, nagu see, mille kallal töötate, on % toetamata operandi tüüp(id): 'Math' ja 'tuple'. See võib olla masendav, eriti kui süntaks tundub esmapilgul õige.

Selles äraarvamismängus ilmneb viga tavaliselt siis, kui proovite stringi valesti vormindada, kasutades matemaatika funktsioonis IPython.display raamatukogu. See on tavaline viga, kuid lahendus on pärast tuvastamist lihtne.

Selles juhendis selgitatakse, mida viga tähendab, miks see ilmneb ja kuidas saate Pythoni koodi selle parandamiseks muuta. Lõpuks on teil täiesti toimiv äraarvamismäng ilma segase veateateta!

Pythoni äraarvamismängu koodi taga oleva mehaanika mõistmine

Pythoni äraarvamismängu skript on loodud selleks, et kasutaja saaks arvata juhuslikult genereeritud arvu vahemikus 1 kuni 100. Selle programmi esimene oluline element on random.randint() funktsioon, mis genereerib juhusliku täisarvu määratud vahemikus (1 kuni 100). See moodustab mängu põhiloogika, kuna see annab salanumbri, mille kasutaja peab ära arvama. Seejärel palub programm kasutajal sisestada oma oletus, kasutades nuppu sisend() funktsioon, mis salvestab kasutaja sisendi stringina ja teisendatakse hiljem võrdluse eesmärgil täisarvuks.

Silmuse struktuur mängib mängu voo kontrollimisel otsustavat rolli. A samas tsüklit kasutatakse pidevaks kontrollimiseks kasutaja oletuste ja juhuslikult genereeritud arvuga. Kuni kasutaja oletus on vale, jätkab tsükkel mängijal viipa "Arva kõrgemale" või "Arva madalamale". Silmuse sees olev tingimus võrdleb kasutaja oletust salajase numbriga, tagades, et mäng annab asjakohast tagasisidet ilma enneaegse lõpetamiseta. Kasutaja sisestust sel viisil käsitledes muutub mäng interaktiivseks, suunates mängija õige vastuse poole.

Teises skriptis kasutades IPython.display, tutvustame keerukamat väljundvormingut Matemaatika(), funktsioon, mida kasutatakse sõnumite kuvamiseks matemaatilises vormingus. Protsendisümboli (%) esialgne kasutamine mitme muutujaga sõnumi vormindamiseks põhjustas aga vea: % jaoks ei toetata operandi tüüpe: 'Math' ja 'tuple'. See viga tekib seetõttu matemaatika ei toeta seda stringi interpolatsiooni vormi. Selle asemel lahendab Pythoni kaasaegse f-stringi vormingu kasutamine, mis on intuitiivsem, selle probleemi ja kuvab mängu lõpus õigesti vormindatud sõnumi, kui kasutaja arvab õigesti.

Lisaks integreerib kolmas skript komplekti ühikutestid kirjutatud Pythoni abil ühiktest raamistik. Nende testide eesmärk on automatiseerida mängu funktsionaalsuse valideerimist, tagades, et mäng käitub erinevates stsenaariumides ootuspäraselt. Pilates sisend() funktsiooni kasutades unittest.mock.patch, simuleerime testimise ajal kasutaja sisestusi, ilma et oleks vaja käsitsi sisestada. See lähenemisviis suurendab koodi vastupidavust, võimaldades arendajatel kontrollida mängu loogikat erinevates tingimustes. Seadmetestid aitavad võimalikke vigu varakult tuvastada, tagades, et programmi mis tahes muudatused ei riku olemasolevaid funktsioone.

# 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()

Pythoni stringi vormingu optimeerimine kuvamiseks interaktiivsetes programmides

Pythonis numbrite äraarvamise mängu arendamise üks peamisi aspekte on see, kuidas programm kasutajaga suhtleb. Täpsemalt, kui kuvatakse selliseid sõnumeid nagu "Arva kõrgemale" või "Arva madalamale", on oluline tagada selge ja täpne vormindamine. Levinud väljakutse selliste teekide kasutamisel nagu IPython.display vormindab väljundstringe õigesti. Kuigi protsendisümboli (%) kasutamine stringide interpoleerimiseks on traditsiooniline, võib see põhjustada tõrkeid, nagu näiteks toetamata operandi tüüp(id): 'matemaatika' ja 'korter'. See probleem ilmneb seetõttu, et teatud teegid, nt Matemaatika(), nõuavad alternatiivseid lähenemisviise, nagu f-stringi vormindamine.

Kaasaegses Pythoni programmeerimises pakuvad f-stringid tõhusamat ja loetavamat viisi muutujate stringidesse sisestamiseks. Näiteks selle asemel, et kirjutada "Palju õnne! Õige arv oli %g", võite kasutada f-stringi nagu f'Congratulations! The correct number was {number}'. F-stringid võimaldavad teil avaldisi otse manustada, muutes koodi kokkuvõtlikumaks ja välistades traditsioonilise stringide interpoleerimisega seotud riskid. See mitte ainult ei paranda loetavust, vaid hoiab ära ka tavalised vormindusvead.

Lisaks f-stringide kasutamisele on interaktiivsete programmide loomisel veel üks oluline aspekt kasutaja sisendi valideerimine. Kasutajatelt sisendi vastuvõtmisel, eriti mängus, kus oletusi sisestatakse korduvalt, on võimalike erandite, näiteks mittetäisarvuliste sisestuste käsitlemine ülioluline. Rakendamine try-except plokid tagab, et programm ei jookse vigase sisendi tõttu kokku. Selle asemel võib see paluda kasutajal sisestada kehtivaid andmeid, parandades seeläbi üldist kasutajakogemust. See optimeeritud stringivormingu ja sisendi valideerimise kombinatsioon viib jõulisemate ja kasutajasõbralikumate Pythoni rakendusteni.