%: “matemātika” un “korekts” minēšanas spēlē: neatbalstīts(-i) operanda veids(-i): kā to labot

Izplatīta Python kļūda, veidojot interaktīvu minēšanas spēli

Apgūstot Python, viens no aizraujošākajiem projektiem ir veidot interaktīvas spēles, piemēram, skaitļu minēšanas spēli. Šādi projekti palīdz saprast, kā Python mijiedarbojas ar lietotāja ievadi un izmanto vadības plūsmu, lai vadītu programmas darbību. Šādā gadījumā Python mērķis ir likt lietotājam uzminēt skaitli no 1 līdz 100, sniedzot atgriezenisko saiti, lai uzminētu lielāku vai mazāku, un, visbeidzot, apstiprinātu, kad ir izdarīts pareizais minējums.

Tomēr, tāpat kā daudzos programmēšanas vingrinājumos, var rasties kļūdas, kas nav uzreiz skaidras. Viena kļūda, kas var rasties, sekojot Python apmācībai, piemēram, tai, pie kuras strādājat, ir neatbalstītais(-ie) operanda veids(-i) %: “Math” un “tuple”. Tas var būt apgrūtinoši, it īpaši, ja no pirmā acu uzmetiena sintakse šķiet pareiza.

Šajā minēšanas spēlē kļūda, ar kuru saskaraties, parasti rodas, ja mēģināt nepareizi formatēt virkni, izmantojot Matemātika funkcija IPython.displejs bibliotēka. Tā ir izplatīta kļūda, taču risinājums ir vienkāršs, tiklīdz ir identificēts.

Šajā rokasgrāmatā ir paskaidrots, ko nozīmē kļūda, kāpēc tā rodas un kā varat modificēt Python kodu, lai to labotu. Beigās jums būs pilnībā funkcionējoša minēšanas spēle bez mulsinoša kļūdas ziņojuma!

Izpratne par Python spēles koda mehāniku

Python minēšanas spēles skripts ir izstrādāts, lai ļautu lietotājam uzminēt nejauši ģenerētu skaitli no 1 līdz 100. Pirmais svarīgais elements šajā programmā ir izmantot random.randint() funkcija, kas ģenerē nejaušu veselu skaitli norādītajā diapazonā (no 1 līdz 100). Tas veido spēles galveno loģiku, jo nodrošina slepeno numuru, kas lietotājam ir jāuzmin. Pēc tam programma liek lietotājam ievadīt savu minējumu, izmantojot ievade () funkcija, kas uztver lietotāja ievadi kā virkni un vēlāk tiek pārveidota par veselu skaitli salīdzināšanas nolūkos.

Cilpas struktūrai ir izšķiroša nozīme spēles plūsmas kontrolē. A kamēr cilpa tiek izmantota, lai nepārtraukti pārbaudītu lietotāja minējumus pret nejauši ģenerētu skaitli. Kamēr lietotāja minējums ir nepareizs, cilpa turpina prasīt spēlētājam “Uzmini augstāk” vai “Uzmini zemāk”. Nosacījums cilpas iekšpusē salīdzina lietotāja minējumu ar slepeno numuru, nodrošinot, ka spēle nodrošina atbilstošu atgriezenisko saiti bez priekšlaicīgas beigām. Šādi rīkojoties ar lietotāja ievadi, spēle kļūst interaktīva, virzot spēlētāju uz pareizo atbildi.

Otrajā skriptā, izmantojot IPython.displejs, mēs ieviešam sarežģītāku izvades formātu ar Matemātika (), funkcija, ko izmanto, lai parādītu ziņojumus matemātiskā apzīmējumā. Tomēr sākotnējā procentuālā simbola (%) izmantošana, lai formatētu ziņojumu ar vairākiem mainīgajiem, radīja kļūdu: neatbalstīts(-i) operanda veids(-i) %: 'Math' un 'koreja'. Šī kļūda rodas tāpēc, Matemātika neatbalsta šo virknes interpolācijas veidu. Tā vietā, izmantojot Python moderno f-string formatējumu, kas ir intuitīvāks, šī problēma tiek atrisināta un spēles beigās tiek parādīts pareizi formatēts ziņojums, kad lietotājs pareizi uzminē.

Turklāt trešais skripts integrē kopu vienību testi rakstīts, izmantojot Python's vienības tests ietvaros. Šo testu mērķis ir automatizēt spēles funkcionalitātes apstiprināšanu, nodrošinot, ka spēle dažādos scenārijos darbojas tā, kā paredzēts. Izsmejot ievade () funkciju izmantojot unittest.mock.patch, mēs modelējam lietotāja ievadi testēšanas laikā, neprasot manuālu ievadi. Šī pieeja uzlabo koda noturību, ļaujot izstrādātājiem pārbaudīt spēles loģiku dažādos apstākļos. Vienību testi palīdz agrīni atklāt iespējamās kļūdas, nodrošinot, ka programmas izmaiņas nepārkāpj esošo funkcionalitāti.

# 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 virkņu formatēšanas optimizēšana displejam interaktīvās programmās

Viens no galvenajiem aspektiem, veidojot skaitļu minēšanas spēli Python, ir tas, kā programma mijiedarbojas ar lietotāju. Konkrēti, parādot ziņojumus, piemēram, “Uzmini augstāk” vai “Uzmini zemāk”, ir svarīgi nodrošināt skaidru un precīzu formatējumu. Izplatīts izaicinājums, izmantojot tādas bibliotēkas kā IPython.displejs pareizi formatē izvades virknes. Lai gan procentuālā simbola (%) izmantošana virknes interpolācijai ir tradicionāla, tas var izraisīt kļūdas, piemēram, neatbalstītu(-us) operanda veidu(-us) %: “matemātika” un “koreja”. Šī problēma rodas tāpēc, ka noteiktas bibliotēkas, piemēram, Matemātika (), nepieciešamas alternatīvas pieejas, piemēram, f-string formatēšana.

Mūsdienu Python programmēšanā f-strings piedāvā efektīvāku un lasāmāku veidu, kā virknēs ievietot mainīgos. Piemēram, tā vietā, lai rakstītu "Apsveicam! Pareizais skaitlis bija %g", varat izmantot f-virkni, piemēram, f'Congratulations! The correct number was {number}'. F-virknes ļauj tieši iegult izteiksmes, padarot kodu kodolīgāku un novēršot riskus, kas saistīti ar tradicionālo virkņu interpolāciju. Tas ne tikai uzlabo lasāmību, bet arī novērš bieži sastopamas formatēšanas kļūdas.

Papildus f-string izmantošanai vēl viens svarīgs apsvērums, veidojot interaktīvas programmas, ir lietotāja ievades validācija. Pieņemot ievadi no lietotājiem, it īpaši spēlē, kur minējumi tiek ievadīti atkārtoti, ir ļoti svarīgi rīkoties ar iespējamiem izņēmumiem, piemēram, ievadi, kas nav veseli skaitļi. Īstenošana try-except bloki nodrošina, ka programma neavārē nederīgas ievades dēļ. Tā vietā tas var eleganti mudināt lietotāju ievadīt derīgus datus, tādējādi uzlabojot kopējo lietotāja pieredzi. Šī optimizētā virkņu formatējuma un ievades validācijas kombinācija nodrošina stabilākas un lietotājam draudzīgākas Python lietojumprogrammas.