%: "Math" ja "tuple" arvauspelissä: Ei tuettu operandityyppi(t): Kuinka korjata se

Yleinen Python-virhe luotaessa interaktiivista arvauspeliä

Pythonia oppiessa yksi jännittävimmistä projekteista on interaktiivisten pelien, kuten numeroiden arvauspelin, rakentaminen. Tällaiset projektit auttavat ymmärtämään, kuinka Python on vuorovaikutuksessa käyttäjän syötteiden kanssa ja ohjaa ohjelman toimintaa ohjausvirran avulla. Tässä tapauksessa tavoitteena on saada Python kehottamaan käyttäjää arvaamaan luku väliltä 1–100, antamalla palautetta arvaamaan suurempi tai pienempi ja lopuksi vahvistaa, milloin oikea arvaus on tehty.

Kuitenkin, kuten monien ohjelmointiharjoitusten yhteydessä, voi syntyä virheitä, jotka eivät ole heti selviä. Eräs virhe, jonka saatat kohdata seuraaessasi Python-oppituntia, kuten käsittelemääsi, on %:n ei-tuetut operandityypit: 'Math' ja 'tuple'. Tämä voi olla turhauttavaa, varsinkin kun syntaksi näyttää oikealta ensi silmäyksellä.

Tässä arvauspelissä kohtaamasi virhe tapahtuu yleensä, kun yrität muotoilla merkkijonoa väärin käyttäessäsi Matematiikka toimintoa IPython.näyttö kirjasto. Tämä on yleinen virhe, mutta ratkaisu on yksinkertainen, kun se on tunnistettu.

Tämä opas opastaa sinut läpi, mitä virhe tarkoittaa, miksi se ilmenee ja kuinka voit muokata Python-koodiasi sen korjaamiseksi. Loppujen lopuksi sinulla on täysin toimiva arvauspeli ilman hämmentävää virheilmoitusta!

Pythonin arvauspelikoodin mekaniikan ymmärtäminen

Python-arvauspelin skripti on suunniteltu antamaan käyttäjälle mahdollisuus arvata satunnaisesti luotu luku väliltä 1-100. Ensimmäinen tärkeä elementti tässä ohjelmassa on käyttää random.randint() funktio, joka luo satunnaisen kokonaisluvun määritetyllä alueella (1-100). Tämä muodostaa pelin ydinlogiikan, sillä se tarjoaa salaisen numeron, joka käyttäjän on arvattava. Ohjelma kehottaa sitten käyttäjää syöttämään arvauksensa käyttämällä input() funktio, joka kaappaa käyttäjän syötteen merkkijonona ja muunnetaan myöhemmin kokonaisluvuksi vertailua varten.

Silmukkarakenteella on ratkaiseva rooli pelin kulun ohjaamisessa. A samalla kun silmukkaa käytetään jatkuvasti tarkistamaan käyttäjän arvauksia satunnaisesti luotujen lukujen perusteella. Niin kauan kuin käyttäjän arvaus on virheellinen, silmukka kehottaa pelaajaa joko "Arvaa korkeammalle" tai "Arvaa pienempi". Silmukan sisällä oleva ehto vertaa käyttäjän arvausta salaiseen numeroon varmistaen, että peli antaa asianmukaista palautetta ilman ennenaikaista päättymistä. Käsittelemällä käyttäjän syötteitä tällä tavalla, pelistä tulee interaktiivinen, joka ohjaa pelaajaa kohti oikeaa vastausta.

Toisessa skriptissä käytetään IPython.näyttö, esittelemme kehittyneemmän tulostusmuodon Matematiikka(), funktio, jota käytetään viestien näyttämiseen matemaattisissa merkinnöissä. Prosenttisymbolin (%) ensimmäinen käyttö usean muuttujan sisältävän viestin muotoiluun aiheutti kuitenkin virheen: %:n operandityyppejä ei tueta: 'Math' ja 'tuple'. Tämä virhe johtuu siitä Matematiikka ei tue tätä merkkijonointerpoloinnin muotoa. Sen sijaan Pythonin nykyaikainen f-merkkijonomuotoilu, joka on intuitiivisempi, ratkaisee tämän ongelman ja näyttää oikein muotoillun viestin pelin lopussa, kun käyttäjä arvaa oikein.

Lisäksi kolmas komentosarja integroi joukon yksikkötestit kirjoitettu Pythonilla yksikkötesti puitteet. Näiden testien tarkoituksena on automatisoida pelin toimivuuden validointi varmistaen, että peli käyttäytyy odotetulla tavalla eri skenaarioissa. Pilkkaamalla input() toimintoa käyttämällä unittest.mock.patch, simuloimme käyttäjän syötteitä testauksen aikana ilman manuaalista syöttöä. Tämä lähestymistapa parantaa koodin kestävyyttä, jolloin kehittäjät voivat tarkistaa pelin logiikan eri olosuhteissa. Yksikkötestit auttavat havaitsemaan mahdollisia vikoja varhaisessa vaiheessa ja varmistamaan, että ohjelman muutokset eivät riko olemassa olevia toimintoja.

# 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-merkkijonomuotoilun optimointi interaktiivisten ohjelmien näyttöä varten

Yksi keskeinen näkökohta lukujen arvauspelin kehittämisessä Pythonissa on, miten ohjelma on vuorovaikutuksessa käyttäjän kanssa. Erityisesti näytettäessä viestejä, kuten "Arvaa korkeampi" tai "Arvaa pienempi", on tärkeää varmistaa selkeä ja tarkka muotoilu. Yleinen haaste käytettäessä kirjastoja, kuten IPython.näyttö muotoilee tulostusjonot oikein. Vaikka prosenttisymbolin (%) käyttö merkkijonointerpoloinnissa on perinteistä, se voi johtaa virheisiin, kuten ei-tuettuihin operandityyppeihin %:lle: 'Math' ja 'tuple'. Tämä ongelma ilmenee, koska tietyt kirjastot, kuten Matematiikka(), vaativat vaihtoehtoisia lähestymistapoja, kuten f-merkkijonomuotoilua.

Nykyaikaisessa Python-ohjelmoinnissa f-merkkijonot tarjoavat tehokkaamman ja luettavamman tavan lisätä muuttujia merkkijonoihin. Esimerkiksi sen sijaan, että kirjoittaisit "Onnittelut! Oikea luku oli %g", voit käyttää f-merkkijonoa, kuten f'Congratulations! The correct number was {number}'. F-merkkijonojen avulla voit upottaa lausekkeita suoraan, mikä tekee koodista tiiviimmän ja eliminoi perinteiseen merkkijonointerpolaatioon liittyvät riskit. Tämä ei vain paranna luettavuutta, vaan myös estää yleisiä muotoiluvirheitä.

F-merkkijonojen käytön lisäksi toinen tärkeä näkökohta vuorovaikutteisten ohjelmien rakentamisessa on käyttäjän syötteiden validointi. Kun hyväksyt syötteitä käyttäjiltä, ​​erityisesti pelissä, jossa arvauksia syötetään toistuvasti, mahdollisten poikkeuksien, kuten ei-kokonaislukujen syötteiden, käsittely on elintärkeää. Toteutus try-except estää, että ohjelma ei kaadu virheellisen syötteen vuoksi. Sen sijaan se voi kehottaa käyttäjää syöttämään kelvollisia tietoja, mikä parantaa yleistä käyttökokemusta. Tämä optimoidun merkkijonomuotoilun ja syötteen tarkistuksen yhdistelmä johtaa tehokkaampiin ja käyttäjäystävällisempiin Python-sovelluksiin.