%: 'Matek' és 'rekord' egy találgatási játékban: Nem támogatott operandustípus(ok): Hogyan javítsuk ki

Gyakori Python-hiba interaktív találgatási játék készítése során

A Python tanulása során az egyik legizgalmasabb projekt az interaktív játékok, például egy számkitaláló játék készítése. Az ilyen projektek segítenek megérteni, hogy a Python hogyan kommunikál a felhasználói bevitellel, és hogyan irányítja a vezérlőfolyamatokat a program viselkedésének irányítására. Ebben az esetben a cél az, hogy a Python felszólítsa a felhasználót, hogy tippeljen ki egy 1 és 100 közötti számot, visszajelzést adva a magasabb vagy alacsonyabb tippeléshez, és végül megerősíti a helyes tippelést.

Azonban, mint sok programozási gyakorlatnál, előfordulhatnak olyan hibák, amelyek nem egyértelműek azonnal. Az egyik hiba, amely egy Python oktatóanyag követése során előfordulhat, például az, amelyen éppen dolgozik, a % nem támogatott operandustípusa(i): 'Math' és 'tuple'. Ez frusztráló lehet, különösen, ha a szintaxis első pillantásra helyesnek tűnik.

Ebben a találgatási játékban a hiba jellemzően akkor fordul elő, amikor egy karakterláncot helytelenül próbál meg formázni a Math funkció a IPython.display könyvtár. Ez egy gyakori hiba, de a megoldás egyértelmű, ha azonosítják.

Ez az útmutató végigvezeti Önt, mit jelent a hiba, miért fordul elő, és hogyan módosíthatja a Python-kódot a javítás érdekében. A végére egy teljesen működőképes találgatási játékban lesz részed a zavaró hibaüzenet nélkül!

A Python kitalálós játékkódja mögötti mechanika megértése

A Python kitalálós játék szkriptje lehetővé teszi a felhasználó számára, hogy véletlenszerűen generált számot 1 és 100 között találjon ki. A program első fontos eleme a random.randint() függvény, amely egy véletlenszerű egész számot generál a megadott tartományon belül (1-től 100-ig). Ez alkotja a játék alapvető logikáját, mivel ez adja meg a titkos számot, amelyet a felhasználónak ki kell találnia. A program ezután felkéri a felhasználót, hogy adja meg a tippjét a bemenet() függvény, amely karakterláncként rögzíti a felhasználói bevitelt, majd összehasonlítás céljából egész számmá konvertálja.

A hurokstruktúra döntő szerepet játszik a játék áramlásának szabályozásában. A míg A hurok folyamatosan ellenőrzi a felhasználó találgatásait a véletlenszerűen generált számokkal. Mindaddig, amíg a felhasználó hibás a tippje, a hurok továbbra is a „Találd meg magasabbra” vagy a „Találd meg alacsonyabbra” parancsot küldi. A hurkon belüli feltétel összehasonlítja a felhasználó találgatását a titkos számmal, így biztosítva, hogy a játék megfelelő visszajelzést adjon anélkül, hogy idő előtt véget érne. A felhasználói bevitel ilyen módon történő kezelésével a játék interaktívvá válik, és a játékost a helyes válasz felé tereli.

A második szkriptben használja IPython.display, egy kifinomultabb kimeneti formátumot vezetünk be matematika(), az üzenetek matematikai jelöléssel történő megjelenítésére szolgáló függvény. Azonban a százalékszimbólum (%) kezdeti használata az üzenet több változós formázásához hibát okozott: nem támogatott operandustípus(ok) a % esetén: 'Math' és 'tuple'. Ez a hiba azért merül fel, mert Math nem támogatja a karakterlánc-interpoláció ezen formáját. Ehelyett a Python modern f-string formázása, amely sokkal intuitívabb, megoldja ezt a problémát, és egy megfelelően formázott üzenetet jelenít meg a játék végén, amikor a felhasználó helyesen tippel.

Ezenkívül a harmadik szkript integrálja a egységtesztek Python segítségével írva egységteszt keretrendszer. Ezeknek a teszteknek az a célja, hogy automatizálják a játék funkcionalitásának ellenőrzését, biztosítva, hogy a játék a különböző forgatókönyvekben elvárt módon viselkedjen. Azzal, hogy kigúnyolja a bemenet() funkció használatával unittest.mock.patch, szimuláljuk a felhasználói beviteleket a tesztelés során anélkül, hogy kézi bevitelre lenne szükség. Ez a megközelítés fokozza a kód robusztusságát, lehetővé téve a fejlesztők számára, hogy különböző feltételek mellett ellenőrizzék a játék logikáját. Az egységtesztek segítenek a potenciális hibák korai felismerésében, biztosítva, hogy a program módosításai ne sértsék meg a meglévő funkciókat.

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

A Python karakterlánc formázásának optimalizálása interaktív programokban való megjelenítéshez

A számkitaláló játék Pythonban való fejlesztésének egyik kulcsfontosságú szempontja az, hogy a program hogyan kommunikál a felhasználóval. Pontosabban, amikor olyan üzeneteket jelenít meg, mint a "Találd meg magasabbra" vagy "Találd meg alacsonyabbra", a tiszta és pontos formázás biztosítása elengedhetetlen. Gyakori kihívás olyan könyvtárak használatakor, mint pl IPython.display megfelelően formázza a kimeneti karakterláncokat. Míg a százalékos szimbólum (%) használata a karakterlánc-interpolációhoz hagyományos, hibákhoz vezethet, például nem támogatott operandustípus(ok) a % esetében: 'Math' és 'tuple'. Ez a probléma azért fordul elő, mert bizonyos könyvtárak, mint pl matematika(), alternatív megközelítéseket, például f-string formázást igényelnek.

A modern Python programozásban az f-stringek hatékonyabb és olvashatóbb módot kínálnak a változók karakterláncokba történő beszúrására. Például a "Gratulálunk! A helyes szám %g" beírása helyett használhat egy f-karakterláncot, például f'Congratulations! The correct number was {number}'. Az F-karakterláncok lehetővé teszik a kifejezések közvetlen beágyazását, ami tömörebbé teszi a kódot, és kiküszöböli a hagyományos karakterlánc-interpolációval járó kockázatokat. Ez nemcsak javítja az olvashatóságot, hanem megelőzi a gyakori formázási hibákat is.

Az f-stringek használata mellett egy másik fontos szempont az interaktív programok készítésekor a felhasználói bevitel érvényesítése. Amikor elfogadjuk a felhasználóktól származó inputokat, különösen egy olyan játékban, ahol ismétlődő tippeket adnak meg, létfontosságú a lehetséges kivételek, például a nem egész számok kezelése. Végrehajtás try-except blokkok biztosítja, hogy a program ne omoljon össze érvénytelen bevitel miatt. Ehelyett kecsesen felszólíthatja a felhasználót érvényes adatok megadására, ezáltal javítva az általános felhasználói élményt. Az optimalizált karakterlánc-formázás és a bemenet-ellenőrzés kombinációja robusztusabb és felhasználóbarátabb Python-alkalmazásokhoz vezet.