%: „Matematika“ ir „kortelės“ atspėjimo žaidime: nepalaikomas (-i) operando tipas (-ai): kaip tai ištaisyti

Dažna Python klaida kuriant interaktyvų spėjimo žaidimą

Mokant Python, vienas įdomiausių projektų yra interaktyvių žaidimų, pavyzdžiui, skaičių atspėjimo, kūrimas. Tokie projektai padeda suprasti, kaip Python sąveikauja su vartotojo įvestimi ir naudoja valdymo srautą, kad vadovautų programos elgesiui. Šiuo atveju siekiama, kad „Python“ paragintų vartotoją atspėti skaičių nuo 1 iki 100, duodamas grįžtamąjį ryšį atspėti didesnį ar mažesnį ir galiausiai patvirtinti, kada atliktas teisingas spėjimas.

Tačiau, kaip ir atliekant daugelį programavimo pratimų, gali atsirasti klaidų, kurios nėra iš karto aiškios. Viena klaida, su kuria galite susidurti vykdydami Python mokymo programą, pvz., tą, su kuria dirbate, yra nepalaikomas (-i) % operandų tipas (-ai): „Math“ ir „tuple“. Tai gali būti nelinksma, ypač kai iš pirmo žvilgsnio sintaksė atrodo teisinga.

Šiame spėliojimo žaidime klaida, su kuria susiduriate, paprastai nutinka, kai bandote neteisingai suformatuoti eilutę, kai naudojate funkcija biblioteka. Tai dažna klaida, tačiau sprendimas yra paprastas, kai tik nustatoma.

Šiame vadove sužinosite, ką reiškia klaida, kodėl ji atsiranda ir kaip galite pakeisti Python kodą, kad ją ištaisytumėte. Pabaigoje turėsite visiškai veikiantį atspėjimo žaidimą be klaidinančio klaidos pranešimo!

komandą	Naudojimo pavyzdys
random.randint()	Ši funkcija iš biblioteka sugeneruoja atsitiktinį sveikąjį skaičių nurodytame diapazone. Spėjimo žaidime jis naudojamas atsitiktiniam skaičiui nuo 1 iki 100 generuoti, kad vartotojas galėtų atspėti. Pavyzdys: random.randint(1, 100).
IPython.display.Math()	Ši komanda iš modulis naudojamas matematinėms išraiškoms pateikti suformatuotu būdu. Sprendime jis padeda suformatuoti išvestį, kad būtų rodomas teisingas skaičius ir vartotojo spėjimas. Pavyzdys: Math(f'Sveikiname! Teisingas skaičius buvo {a}').
unittest.mock.patch()	Ši funkcija naudojama norint pakeisti funkciją arba objektą kode bandomąja versija. Tai ypač naudinga atliekant vienetų testus, kad būtų galima imituoti vartotojo įvestį be rankinio veiksmų. Pavyzdys: @patch('builtins.input', side_effect=[50, 75, 85, 95, 100]).
unittest.TestCase	Bazinė klasė modulis, naudojamas vienetų testams kurti. Tai suteikia pagrindą atskiroms funkcijoms išbandyti, siekiant užtikrinti, kad jos veiktų taip, kaip tikėtasi. Pavyzdys: klasė TestGuessingGame(unittest.TestCase).
continue	Ši valdymo srauto komanda naudojama kilpose norint praleisti dabartinę iteraciją ir pereiti prie kitos. Scenarijuje jis užtikrina, kad programa tęstųsi po to, kai užfiksavo ValueError dėl netinkamos įvesties. Pavyzdys: tęsti.
try-except	Naudojama klaidų tvarkymui, ši struktūra leidžia programai tęsti veikimą net ir tada, kai daroma išimtis. Spėliojimo žaidime jis apdoroja neteisingus vartotojų, kurie neįveda sveikųjų skaičių, įvestį. Pavyzdys: try: ... išskyrus ValueError:.
input()	Ši funkcija užfiksuoja vartotojo įvestį kaip eilutę. Spėliojimo žaidime jis naudojamas paraginti vartotoją įvesti savo spėjimą. Vėliau įvestis konvertuojama į sveikąjį skaičių. Pavyzdys: user_guess = int(input('Atspėk skaičių nuo 1 iki 100:')).
f-string	Pristatyta Python 3.6, leidžia lengviau formatuoti eilutes įterpiant išraiškas tiesiai į eilutę. Sprendime jie naudojami galutinio pranešimo išvesties formatavimui. Pavyzdys: f'Sveikiname! Teisingas skaičius buvo {a}'.
unittest.main()	Ši komanda paleidžia bandomąjį rinkinį Python's pagrindą. Jis naudojamas automatiškai atrasti ir vykdyti programai parašytus testus. Pavyzdys: if __name__ == '__main__': unittest.main().

„Python“ spėliojamo žaidimo kodo mechanikos supratimas

Python spėjimo žaidimo scenarijus sukurtas taip, kad vartotojas galėtų atspėti atsitiktinai sugeneruotą skaičių nuo 1 iki 100. Pirmas svarbus elementas šioje programoje yra naudoti funkcija, kuri sugeneruoja atsitiktinį sveikąjį skaičių nurodytame diapazone (nuo 1 iki 100). Tai sudaro pagrindinę žaidimo logiką, nes suteikia slaptą numerį, kurį vartotojas turi atspėti. Tada programa paragins vartotoją įvesti savo spėjimą, naudojant funkcija, kuri užfiksuoja vartotojo įvestį kaip eilutę ir vėliau palyginimo tikslais konvertuojama į sveikąjį skaičių.

Kilpos struktūra vaidina lemiamą vaidmenį kontroliuojant žaidimo eigą. A ciklas naudojamas nuolat tikrinti vartotojo spėjimus pagal atsitiktinai sugeneruotą skaičių. Kol naudotojo spėjimas yra neteisingas, ciklas ir toliau ragina žaidėją pasirinkti „Atspėk aukščiau“ arba „Atspėk žemiau“. Būklė ciklo viduje lygina vartotojo spėjimą su slaptu skaičiumi, užtikrindama, kad žaidimas suteiktų tinkamą grįžtamąjį ryšį be išankstinio pabaigos. Taip apdorojus vartotojo įvestį, žaidimas tampa interaktyvus, nukreipiantis žaidėją teisingo atsakymo link.

Antrame scenarijuje naudojant , pristatome sudėtingesnį išvesties formatą su , funkcija, naudojama pranešimams rodyti matematiniu užrašu. Tačiau pradinis procentinio simbolio (%) naudojimas formatuojant pranešimą su keliais kintamaisiais sukėlė klaidą: nepalaikomas (-i) % operando tipas (-ai): „Math“ ir „tuple“. Ši klaida atsiranda dėl to nepalaiko šios eilutės interpoliacijos formos. Vietoj to, naudojant Python modernų f-string formatavimą, kuris yra intuityvesnis, ši problema išsprendžiama ir žaidimo pabaigoje rodomas tinkamai suformatuotas pranešimas, kai vartotojas atspėja teisingai.

Be to, trečiasis scenarijus integruoja rinkinį parašyta naudojant Python's pagrindą. Šių testų tikslas – automatizuoti žaidimo funkcionalumo patvirtinimą, užtikrinant, kad žaidimas įvairiuose scenarijuose elgtųsi taip, kaip tikimasi. Šaipydamasis iš naudojant funkciją unittest.mock.patch, testavimo metu imituojame naudotojo įvestis, nereikalaujant rankinio įvesties. Šis metodas padidina kodo tvirtumą, todėl kūrėjai gali patikrinti žaidimo logiką skirtingomis sąlygomis. Įrenginių testai padeda anksti pastebėti galimas klaidas ir užtikrina, kad bet kokie programos pakeitimai nepažeis esamų funkcijų.

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

„Python“ eilutės formatavimo optimizavimas interaktyviosiose programose

Vienas iš pagrindinių „Python“ skaičių atspėjimo žaidimo kūrimo aspektų yra tai, kaip programa sąveikauja su vartotoju. Konkrečiai, kai rodomi pranešimai, pvz., „Atspėk aukščiau“ arba „Atspėk žemiau“, labai svarbu užtikrinti aiškų ir tikslų formatavimą. Dažnas iššūkis naudojant tokias bibliotekas kaip tinkamai formatuoja išvesties eilutes. Nors procentinio simbolio (%) naudojimas eilutės interpoliacijai yra tradicinis, dėl to gali atsirasti klaidų, pvz., nepalaikomas (-i) % operando tipas (-ai): „Matematika“ ir „eiga“. Ši problema kyla dėl to, kad tam tikros bibliotekos, pvz , reikalingi alternatyvūs metodai, pvz., f-string formatavimas.

Šiuolaikiniame Python programavime f-stygos siūlo efektyvesnį ir skaitomesnį būdą įterpti kintamuosius į eilutes. Pavyzdžiui, užuot rašę „Sveikiname! Teisingas skaičius buvo %g“, galite naudoti f eilutę, pvz. . F-stygos leidžia tiesiogiai įterpti išraiškas, todėl kodas yra glaustesnis ir pašalinama rizika, susijusi su tradicine eilučių interpoliacija. Tai ne tik pagerina skaitomumą, bet ir apsaugo nuo įprastų formatavimo klaidų.

Be f-stygų naudojimo, dar vienas svarbus aspektas kuriant interaktyvias programas yra vartotojo įvesties patvirtinimas. Priimant naudotojų įvestį, ypač žaidime, kuriame spėjimai įvedami pakartotinai, labai svarbu tvarkyti galimas išimtis, pvz., ne sveikuosius skaičius. Įgyvendinimas blokai užtikrina, kad programa nesustrigtų dėl netinkamos įvesties. Vietoj to, jis gali maloniai paraginti vartotoją įvesti galiojančius duomenis ir taip pagerinti bendrą vartotojo patirtį. Šis optimizuoto eilučių formatavimo ir įvesties patvirtinimo derinys leidžia sukurti patikimesnes ir patogesnes Python programas.

1. Ką reiškia klaida „nepalaikomas (-i) % operando tipas (-ai): „Math“ ir „tuple“?
2. Ši klaida atsiranda, kai funkcija naudojama su netinkamu eilutės formatavimu. Pakeitus procentinį simbolį (%) f eilutėmis, ši problema išsprendžiama.
3. Kodėl „Python“ programoje naudoti f eilutes, o ne procentais (%)?
4. F-stygos siūlo skaitomesnį ir efektyvesnį formatavimą, palyginti su tradiciniu metodas. Jie taip pat sumažina sudėtingų eilučių formatavimo klaidų riziką.
5. Kaip spėliojimo žaidime galiu tvarkyti neteisingą vartotojo įvestį?
6. Galite naudoti a blokuoti, kad užfiksuotų klaidas, pvz., „ValueError“, kai vartotojas įveda ne sveikuosius duomenis, užtikrinant, kad žaidimas tęstųsi sklandžiai.
7. Koks yra vaidmuo šiame žaidime?
8. sugeneruoja atsitiktinį skaičių nurodytame diapazone (nuo 1 iki 100), kad vartotojas galėtų atspėti žaidime.
9. Kaip veikia kilpos pagalba atspėjimo žaidime?
10. The kilpa užtikrina, kad žaidimas tęstųsi tol, kol vartotojas teisingai atspės atsitiktinai sugeneruotą skaičių.

Spėliojimo žaidimas Python gali veikti sklandžiai, kai bus išspręsta eilutės formatavimo problema. Naudojant f eilutes, klaida buvo susijusi su ir sekcija yra išspręsta, užtikrinant sklandesnę vartotojo patirtį. Šį modernų formatavimo metodą lengva įgyvendinti ir išvengiama įprastų spąstų.

Be to, vartotojo įvesties klaidų tvarkymas naudojant blokai užtikrina, kad žaidimas nesuges dėl netinkamos įvesties. Dėl šių pakeitimų žaidimas tampa tvirtesnis ir patogesnis vartotojui, suteikiant reikiamą grįžtamąjį ryšį, kad žaidėjai galėtų mėgautis interaktyvia patirtimi, nepatiriant varginančių klaidų.