%: "Matemàtiques" i "tupla" en un joc d'endevinalles: Tipus d'operands no compatibles: Com solucionar-ho

Error comú de Python en crear un joc d'endevinalles interactiu

Quan apreneu Python, un dels projectes més emocionants és crear jocs interactius com un joc d'endevinar números. Aquests projectes us ajuden a entendre com Python interactua amb l'entrada de l'usuari i utilitza el flux de control per guiar el comportament del programa. En aquest cas, l'objectiu és que Python demani a l'usuari que endevini un nombre entre 1 i 100, donant comentaris per endevinar més o menys i, finalment, confirmar quan es fa la suposició correcta.

No obstant això, com passa amb molts exercicis de programació, poden sorgir errors que no són immediatament clars. Un error que podeu trobar mentre seguiu un tutorial de Python, com el que esteu treballant, és el tipus d'operands no compatibles per a %: "Matemàtiques" i "tupla". Això pot ser frustrant, sobretot quan la sintaxi sembla correcta a primera vista.

En aquest joc d'endevinalles, l'error al qual t'enfrontes normalment passa quan intentes formatar una cadena de manera incorrecta mentre fas servir el Matemàtiques funció en el IPython.display biblioteca. Aquest és un error comú, però la solució és senzilla un cop identificada.

Aquesta guia us explicarà què significa l'error, per què es produeix i com podeu modificar el codi de Python per solucionar-lo. Al final, tindreu un joc d'endevinalles completament funcional sense el missatge d'error confús!

Comprensió de la mecànica darrere del codi de joc d'endevinalles de Python

L'script del joc d'endevinalles de Python està dissenyat per permetre a l'usuari endevinar un nombre generat aleatòriament entre 1 i 100. El primer element important d'aquest programa és l'ús del random.randint() funció, que genera un nombre enter aleatori dins de l'interval especificat (1 a 100). Això forma la lògica bàsica darrere del joc, ja que proporciona el número secret que l'usuari ha d'endevinar. Aleshores, el programa demana a l'usuari que introdueixi la seva suposició, utilitzant el entrada() funció, que captura l'entrada de l'usuari com una cadena i després es converteix en un nombre enter amb finalitats de comparació.

L'estructura del bucle té un paper crucial en el control del flux del joc. A mentre bucle s'utilitza per comprovar contínuament les suposicions de l'usuari amb el nombre generat aleatòriament. Mentre la suposició de l'usuari sigui incorrecta, el bucle continua demanant al jugador que "Endevina més alt" o "Endevina més baix". La condició dins del bucle compara l'endevinació de l'usuari amb el número secret, assegurant que el joc proporciona una retroalimentació adequada sense acabar prematurament. En gestionar l'entrada de l'usuari d'aquesta manera, el joc es torna interactiu, guiant el jugador cap a la resposta correcta.

En el segon script utilitzant IPython.display, introduïm un format de sortida més sofisticat amb Matemàtiques (), una funció que s'utilitza per mostrar missatges en notació matemàtica. Tanmateix, l'ús inicial del símbol de percentatge (%) per formatar el missatge amb diverses variables va provocar un error: tipus d'operands no compatibles per a %: "Matemàtiques" i "tupla". Aquest error sorgeix perquè Matemàtiques no admet aquesta forma d'interpolació de cadenes. En canvi, l'ús del format modern de cadena f de Python, que és més intuïtiu, resol aquest problema i mostra un missatge amb el format adequat al final del joc quan l'usuari ho endevina correctament.

A més, el tercer script integra un conjunt de proves unitàries escrit amb Python test unitari marc. L'objectiu d'aquestes proves és automatitzar la validació de la funcionalitat del joc, assegurant que el joc es comporta com s'espera en diversos escenaris. En burlar-se del entrada() utilitzant la funció unittest.mock.patch, simulem les entrades de l'usuari durant les proves sense necessitat d'entrada manual. Aquest enfocament millora la robustesa del codi, permetent als desenvolupadors verificar la lògica del joc en diferents condicions. Les proves d'unitat ajuden a detectar possibles errors d'hora, assegurant-se que qualsevol canvi al programa no trenca la funcionalitat existent.

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

Optimització del format de cadena de Python per a la visualització en programes interactius

Un aspecte clau del desenvolupament d'un joc d'endevinar números a Python és com el programa interactua amb l'usuari. Concretament, quan es mostren missatges com ara "Endevina més alt" o "Endevina més baix", és essencial garantir un format clar i precís. Un repte comú a l'hora d'utilitzar biblioteques com IPython.display està formatant correctament les cadenes de sortida. Tot i que l'ús del símbol de percentatge (%) per a la interpolació de cadenes és tradicional, pot provocar errors com els tipus d'operands no compatibles per a %: "Matemàtiques" i "tupla". Aquest problema es produeix perquè determinades biblioteques, com ara Matemàtiques(), requereixen enfocaments alternatius com el format de cadena f.

A la programació moderna de Python, les cadenes f ofereixen una manera més eficient i llegible d'inserir variables a les cadenes. Per exemple, en comptes d'escriure "Enhorabona! El número correcte era %g", podeu utilitzar una cadena F com f'Congratulations! The correct number was {number}'. Les cadenes F permeten incrustar directament expressions, fent que el codi sigui més concís i eliminant els riscos associats a la interpolació tradicional de cadenes. Això no només millora la llegibilitat, sinó que també evita errors de format habituals.

A més d'utilitzar cadenes f, una altra consideració important a l'hora de crear programes interactius és la validació de l'entrada de l'usuari. Quan s'accepten les aportacions dels usuaris, especialment en un joc on s'introdueixen suposicions repetidament, és vital gestionar possibles excepcions, com ara entrades que no siguin enteres. Implementació try-except blocks assegura que el programa no es bloqueja a causa d'una entrada no vàlida. En canvi, pot demanar amb gràcia a l'usuari que introdueixi dades vàlides, millorant així l'experiència general de l'usuari. Aquesta combinació de format de cadena optimitzat i validació d'entrada condueix a aplicacions Python més robustes i fàcils d'utilitzar.