%: „Matematyka” i „krotka” w grze w zgadywanie: Nieobsługiwane typy argumentów: Jak to naprawić

Typowy błąd Pythona podczas tworzenia interaktywnej gry w zgadywanie

Jednym z najbardziej ekscytujących projektów podczas nauki języka Python jest tworzenie interaktywnych gier, takich jak gra polegająca na zgadywaniu liczb. Takie projekty pomagają zrozumieć, w jaki sposób Python wchodzi w interakcję z danymi wprowadzanymi przez użytkownika i wykorzystuje przepływ sterowania do kierowania zachowaniem programu. W tym przypadku celem jest, aby Python podpowiadał użytkownikowi odgadnięcie liczby z zakresu od 1 do 100, dając informację zwrotną, aby odgadł wyższą lub niższą wartość, a na koniec potwierdził, kiedy dokonano prawidłowego odgadnięcia.

Jednakże, podobnie jak w przypadku wielu ćwiczeń z programowania, mogą pojawić się błędy, które nie są od razu jasne. Jednym z błędów, jakie możesz napotkać podczas korzystania z samouczka dotyczącego języka Python, takiego jak ten, nad którym pracujesz, są nieobsługiwane typy operandów dla %: „Math” i „Tuple”. Może to być frustrujące, zwłaszcza gdy składnia wydaje się na pierwszy rzut oka poprawna.

W tej grze w zgadywanie błąd, na który napotykasz, zwykle pojawia się, gdy próbujesz niepoprawnie sformatować ciąg znaków podczas korzystania z metody Matematyka pełnić funkcję w IPython.display biblioteka. Jest to częsty błąd, ale rozwiązanie jest proste po zidentyfikowaniu.

W tym przewodniku dowiesz się, co oznacza błąd, dlaczego występuje i jak zmodyfikować kod Pythona, aby go naprawić. Na koniec będziesz mieć w pełni funkcjonalną grę w zgadywanie bez mylącego komunikatu o błędzie!

Zrozumienie mechaniki kodu gry w zgadywanie w języku Python

Skrypt gry w zgadywanie w Pythonie został zaprojektowany tak, aby umożliwić użytkownikowi odgadnięcie losowo wygenerowanej liczby z zakresu od 1 do 100. Pierwszym ważnym elementem w tym programie jest użycie losowy.randint() funkcja, która generuje losową liczbę całkowitą z określonego zakresu (od 1 do 100). Stanowi to podstawową logikę gry, ponieważ zapewnia tajny numer, który użytkownik musi odgadnąć. Następnie program prosi użytkownika o podanie swojego przypuszczenia za pomocą przycisku wejście() funkcja, która przechwytuje dane wprowadzone przez użytkownika jako ciąg znaków i jest później konwertowana na liczbę całkowitą w celach porównawczych.

Struktura pętli odgrywa kluczową rolę w kontrolowaniu przebiegu gry. A chwila pętla służy do ciągłego sprawdzania domysłów użytkownika względem losowo wygenerowanej liczby. Dopóki użytkownik nie zgadnie, pętla w dalszym ciągu podpowiada graczowi, aby „Zgadł wyższą” lub „Zgadnij niższą”. Warunek wewnątrz pętli porównuje przypuszczenie użytkownika z tajnym numerem, zapewniając, że gra dostarczy odpowiednią informację zwrotną bez przedwczesnego zakończenia. Obsługując w ten sposób dane wejściowe użytkownika, gra staje się interaktywna, prowadząc gracza w kierunku prawidłowej odpowiedzi.

W drugim skrypcie za pomocą IPython.display, wprowadzamy bardziej wyrafinowany format wyjściowy za pomocą Matematyka(), funkcja używana do wyświetlania komunikatów w notacji matematycznej. Jednak początkowe użycie symbolu procentu (%) do formatowania wiadomości z wieloma zmiennymi spowodowało błąd: nieobsługiwane typy argumentów dla %: „Math” i „Tuple”. Ten błąd pojawia się, ponieważ Matematyka nie obsługuje tej formy interpolacji ciągów. Zamiast tego użycie nowoczesnego formatowania f-stringu w Pythonie, które jest bardziej intuicyjne, rozwiązuje ten problem i wyświetla odpowiednio sformatowany komunikat na koniec gry, gdy użytkownik poprawnie zgadnie.

Dodatkowo trzeci skrypt integruje zestaw testy jednostkowe napisany przy użyciu języka Python test jednostkowy struktura. Celem tych testów jest zautomatyzowanie sprawdzania funkcjonalności gry i upewnienie się, że gra zachowuje się zgodnie z oczekiwaniami w różnych scenariuszach. Wyśmiewając wejście() za pomocą funkcji unittest.mock.patch, symulujemy dane wejściowe użytkownika podczas testowania bez konieczności ręcznego wprowadzania danych. Takie podejście zwiększa niezawodność kodu, umożliwiając programistom weryfikację logiki gry w różnych warunkach. Testy jednostkowe pomagają wcześnie wykryć potencjalne błędy, zapewniając, że wszelkie zmiany w programie nie psują istniejącej funkcjonalności.

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

Optymalizacja formatowania ciągów w języku Python do wyświetlania w programach interaktywnych

Jednym z kluczowych aspektów tworzenia gry polegającej na zgadywaniu liczb w Pythonie jest sposób interakcji programu z użytkownikiem. W szczególności w przypadku wyświetlania komunikatów typu „Zgadnij wyżej” lub „Zgadnij niżej” istotne jest zapewnienie jasnego i precyzyjnego formatowania. Częstym wyzwaniem podczas korzystania z bibliotek takich jak IPython.display poprawnie formatuje ciągi wyjściowe. Chociaż użycie symbolu procentu (%) do interpolacji ciągów jest tradycyjne, może prowadzić do błędów, takich jak nieobsługiwane typy argumentów dla %: „Math” i „Tuple”. Ten problem występuje, ponieważ niektóre biblioteki, takie jak Matematyka(), wymagają alternatywnych podejść, takich jak formatowanie ciągu f.

We współczesnym programowaniu w Pythonie f-stringi oferują bardziej wydajny i czytelny sposób wstawiania zmiennych do ciągów. Na przykład zamiast pisać „Gratulacje! Poprawna liczba to %g”, możesz użyć ciągu f, takiego jak f'Congratulations! The correct number was {number}'. Ciągi F umożliwiają bezpośrednie osadzanie wyrażeń, czyniąc kod bardziej zwięzłym i eliminując ryzyko związane z tradycyjną interpolacją ciągów. To nie tylko zwiększa czytelność, ale także zapobiega typowym błędom formatowania.

Oprócz używania ciągów f, kolejnym ważnym czynnikiem przy tworzeniu programów interaktywnych jest sprawdzanie poprawności danych wejściowych użytkownika. Przy akceptowaniu danych wejściowych od użytkowników, szczególnie w grze, w której wielokrotnie wprowadza się domysły, niezwykle istotna jest obsługa potencjalnych wyjątków, takich jak dane wejściowe niecałkowite. Realizowanie try-except bloków zapewnia, że ​​program nie ulegnie awarii z powodu nieprawidłowych danych wejściowych. Zamiast tego może w elegancki sposób poprosić użytkownika o wprowadzenie prawidłowych danych, poprawiając w ten sposób ogólne doświadczenie użytkownika. To połączenie zoptymalizowanego formatowania ciągów i sprawdzania poprawności danych wejściowych prowadzi do bardziej niezawodnych i przyjaznych dla użytkownika aplikacji Python.