%: 'Math' in 'tuple' v igri ugibanja: Nepodprte vrste operandov: Kako to popraviti

Pogosta napaka Pythona pri izdelavi interaktivne igre ugibanja

Pri učenju Pythona je eden najbolj vznemirljivih projektov izdelava interaktivnih iger, kot je igra ugibanja številk. Takšni projekti vam pomagajo razumeti, kako Python sodeluje z uporabniškim vnosom in uporablja nadzorni tok za usmerjanje vedenja programa. V tem primeru je cilj, da Python pozove uporabnika, naj ugiba število med 1 in 100, s povratnimi informacijami, da ugiba višje ali nižje, in na koncu potrdi, kdaj je pravilno ugibano.

Vendar, tako kot pri mnogih vajah programiranja, lahko pride do napak, ki niso takoj jasne. Ena napaka, na katero lahko naletite, ko sledite vadnici za Python, kot je ta, na kateri delate, so nepodprte vrste operandov za %: 'Math' in 'tuple'. To je lahko frustrirajoče, še posebej, če se sintaksa na prvi pogled zdi pravilna.

V tej igri ugibanja se napaka, s katero se srečujete, običajno zgodi, ko poskušate nepravilno oblikovati niz, medtem ko uporabljate matematika funkcijo v IPython.display knjižnica. To je pogosta napaka, vendar je rešitev enostavna, ko jo najdete.

Ta vodnik vas bo vodil skozi to, kaj napaka pomeni, zakaj se pojavi in ​​kako lahko spremenite svojo kodo Python, da jo popravite. Na koncu boste imeli popolnoma delujočo igro ugibanja brez zmedenega sporočila o napaki!

Razumevanje mehanike za Pythonovo kodo igre ugibanja

Skript igre ugibanja Python je zasnovan tako, da uporabniku omogoča ugibanje naključno ustvarjenega števila med 1 in 100. Prvi pomemben element v tem programu je uporaba random.randint() funkcijo, ki generira naključno celo število znotraj podanega obsega (1 do 100). To tvori osrednjo logiko igre, saj zagotavlja skrivno številko, ki jo mora uporabnik uganiti. Program nato pozove uporabnika, da vnese svoje ugibanje z uporabo vnos() funkcijo, ki zajame uporabniški vnos kot niz in se kasneje pretvori v celo število za primerjavo.

Struktura zanke igra ključno vlogo pri nadzoru poteka igre. A medtem ko zanka se uporablja za nenehno preverjanje uporabnikovih ugibanj glede na naključno ustvarjeno število. Dokler je ugibanje uporabnika napačno, zanka še naprej poziva igralca, naj »Ugani višje« ali »Ugani nižje«. Pogoj znotraj zanke primerja ugibanje uporabnika s skrivno številko, s čimer zagotovi, da igra zagotovi ustrezne povratne informacije, ne da bi se predčasno končala. S takšnim obravnavanjem uporabniškega vnosa igra postane interaktivna in vodi igralca do pravilnega odgovora.

V drugem scenariju z uporabo IPython.display, uvajamo bolj izpopolnjen izhodni format z matematika(), funkcija, ki se uporablja za prikaz sporočil v matematičnem zapisu. Vendar pa je prvotna uporaba simbola odstotka (%) za oblikovanje sporočila z več spremenljivkami povzročila napako: nepodprte vrste operandov za %: 'Math' in 'tuple'. Ta napaka nastane zaradi matematika ne podpira te oblike interpolacije nizov. Namesto tega z uporabo Pythonovega sodobnega oblikovanja niza f, ki je bolj intuitivno, reši to težavo in prikaže pravilno oblikovano sporočilo na koncu igre, ko uporabnik pravilno ugane.

Poleg tega tretji skript združuje nabor enotni testi napisan z uporabo Pythona test enote ogrodje. Namen teh testov je avtomatizirati preverjanje funkcionalnosti igre in zagotoviti, da se igra v različnih scenarijih obnaša po pričakovanjih. Z norčevanjem iz vnos() uporabo funkcije unittest.mock.patch, simuliramo uporabniške vnose med testiranjem brez ročnega vnosa. Ta pristop poveča robustnost kode in omogoča razvijalcem, da preverijo logiko igre pod različnimi pogoji. Preizkusi enot pomagajo zgodaj odkriti morebitne hrošče in zagotavljajo, da morebitne spremembe programa ne porušijo obstoječe funkcionalnosti.

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

Optimiziranje oblikovanja nizov Python za prikaz v interaktivnih programih

Eden od ključnih vidikov razvoja igre ugibanja številk v Pythonu je, kako program komunicira z uporabnikom. Natančneje, pri prikazovanju sporočil, kot je »Ugibaj višje« ali »Ugibaj nižje«, je nujno zagotoviti jasno in natančno oblikovanje. Pogost izziv pri uporabi knjižnic, kot je IPython.display pravilno oblikuje izhodne nize. Čeprav je uporaba odstotnega simbola (%) za interpolacijo nizov tradicionalna, lahko povzroči napake, kot so nepodprte vrste operandov za %: 'matematika' in 'tuple'. Do te težave pride, ker nekatere knjižnice, kot npr matematika(), zahtevajo alternativne pristope, kot je oblikovanje niza f.

V sodobnem programiranju Python f-nizi ponujajo učinkovitejši in berljiv način za vstavljanje spremenljivk v nize. Na primer, namesto da napišete "Čestitamo! Pravilna številka je bila %g," lahko uporabite f-niz, kot je f'Congratulations! The correct number was {number}'. F-nizi vam omogočajo neposredno vdelavo izrazov, zaradi česar je koda bolj jedrnata in odpravlja tveganja, povezana s tradicionalno interpolacijo nizov. To ne samo izboljša berljivost, ampak tudi prepreči pogoste napake pri oblikovanju.

Poleg uporabe f-nizov je pri izdelavi interaktivnih programov pomemben dejavnik tudi preverjanje vnosa uporabnika. Pri sprejemanju vnosov od uporabnikov, zlasti v igri, kjer se ugibanja vnašajo večkrat, je ravnanje z morebitnimi izjemami, kot so vnosi, ki niso celo število, bistvenega pomena. Izvajanje try-except blokov zagotavlja, da se program ne zruši zaradi neveljavnih vnosov. Namesto tega lahko elegantno pozove uporabnika k vnosu veljavnih podatkov in s tem izboljša celotno uporabniško izkušnjo. Ta kombinacija optimiziranega oblikovanja nizov in preverjanja vnosa vodi do bolj robustnih in uporabniku prijaznejših aplikacij Python.