%: ഊഹക്കച്ചവടത്തിലെ 'ഗണിതവും' 'ട്യൂപ്പിളും': പിന്തുണയ്ക്കാത്ത പ്രവർത്തന തരം(കൾ): ഇത് എങ്ങനെ പരിഹരിക്കാം

ഒരു സംവേദനാത്മക ഊഹിക്കൽ ഗെയിം നിർമ്മിക്കുമ്പോൾ സാധാരണ പൈത്തൺ പിശക്

പൈത്തൺ പഠിക്കുമ്പോൾ, ഏറ്റവും ആവേശകരമായ പ്രോജക്റ്റുകളിൽ ഒന്ന് നമ്പർ ഊഹിക്കുന്ന ഗെയിം പോലെയുള്ള ഇൻ്ററാക്ടീവ് ഗെയിമുകൾ നിർമ്മിക്കുന്നതാണ്. ഉപയോക്തൃ ഇൻപുട്ടുമായി പൈത്തൺ എങ്ങനെ സംവദിക്കുന്നുവെന്നും പ്രോഗ്രാമിൻ്റെ പെരുമാറ്റം നയിക്കാൻ നിയന്ത്രണ ഫ്ലോ ഉപയോഗിക്കുന്നത് എങ്ങനെയെന്നും മനസ്സിലാക്കാൻ ഇത്തരം പ്രോജക്റ്റുകൾ നിങ്ങളെ സഹായിക്കുന്നു. ഈ സാഹചര്യത്തിൽ, 1 നും 100 നും ഇടയിലുള്ള ഒരു സംഖ്യ ഊഹിക്കാൻ പൈത്തൺ ഉപയോക്താവിനെ പ്രേരിപ്പിക്കുകയും ഉയർന്നതോ കുറവോ ഊഹിക്കാൻ ഫീഡ്‌ബാക്ക് നൽകുകയും ഒടുവിൽ ശരിയായ ഊഹം എപ്പോഴാണെന്ന് സ്ഥിരീകരിക്കുകയും ചെയ്യുക എന്നതാണ് ലക്ഷ്യം.

എന്നിരുന്നാലും, നിരവധി പ്രോഗ്രാമിംഗ് വ്യായാമങ്ങൾ പോലെ, പെട്ടെന്ന് വ്യക്തമല്ലാത്ത പിശകുകൾ ഉണ്ടാകാം. നിങ്ങൾ പ്രവർത്തിക്കുന്നതുപോലെ, ഒരു പൈത്തൺ ട്യൂട്ടോറിയൽ പിന്തുടരുമ്പോൾ നിങ്ങൾക്ക് നേരിട്ടേക്കാവുന്ന ഒരു പിശക്, %: 'മാത്ത്', 'ട്യൂപ്പിൾ' എന്നിവയ്‌ക്കായുള്ള പിന്തുണയ്‌ക്കാത്ത ഓപ്പറണ്ട് തരം(കൾ) ആണ്. ഇത് നിരാശാജനകമായിരിക്കും, പ്രത്യേകിച്ചും വാക്യഘടന ഒറ്റനോട്ടത്തിൽ ശരിയാണെന്ന് തോന്നുമ്പോൾ.

ഈ ഊഹക്കച്ചവട ഗെയിമിൽ, നിങ്ങൾ അഭിമുഖീകരിക്കുന്ന പിശക് സാധാരണയായി സംഭവിക്കുന്നത് നിങ്ങൾ ഉപയോഗിക്കുമ്പോൾ തെറ്റായി ഒരു സ്ട്രിംഗ് ഫോർമാറ്റ് ചെയ്യാൻ ശ്രമിക്കുമ്പോഴാണ് ഗണിതം ഫംഗ്‌ഷൻ IPython.display ലൈബ്രറി. ഇത് ഒരു സാധാരണ തെറ്റാണ്, പക്ഷേ തിരിച്ചറിഞ്ഞുകഴിഞ്ഞാൽ പരിഹാരം നേരായതാണ്.

പിശക് എന്താണ് അർത്ഥമാക്കുന്നത്, എന്തുകൊണ്ടാണ് ഇത് സംഭവിക്കുന്നത്, അത് പരിഹരിക്കുന്നതിന് നിങ്ങളുടെ പൈത്തൺ കോഡ് എങ്ങനെ പരിഷ്കരിക്കാം എന്നിവയിലൂടെ ഈ ഗൈഡ് നിങ്ങളെ നയിക്കും. അവസാനത്തോടെ, ആശയക്കുഴപ്പമുണ്ടാക്കുന്ന പിശക് സന്ദേശമില്ലാതെ പൂർണ്ണമായി പ്രവർത്തിക്കുന്ന ഊഹക്കച്ചവട ഗെയിം നിങ്ങൾക്ക് ലഭിക്കും!

പൈത്തണിൻ്റെ ഗസ്സിംഗ് ഗെയിം കോഡിൻ്റെ പിന്നിലെ മെക്കാനിക്സ് മനസ്സിലാക്കുന്നു

1 നും 100 നും ഇടയിൽ ക്രമരഹിതമായി ജനറേറ്റുചെയ്‌ത ഒരു സംഖ്യ ഊഹിക്കാൻ ഉപയോക്താവിനെ അനുവദിക്കുന്നതിനാണ് പൈത്തൺ ഗസ്സിംഗ് ഗെയിം സ്‌ക്രിപ്റ്റ് രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നത്. ഈ പ്രോഗ്രാമിലെ ആദ്യത്തെ പ്രധാന ഘടകം ഇതിൻ്റെ ഉപയോഗമാണ്. random.randint() ഫംഗ്ഷൻ, ഇത് നിർദ്ദിഷ്ട ശ്രേണിയിൽ (1 മുതൽ 100 ​​വരെ) ഒരു റാൻഡം പൂർണ്ണസംഖ്യ സൃഷ്ടിക്കുന്നു. ഇത് ഗെയിമിൻ്റെ പിന്നിലെ പ്രധാന യുക്തിയെ രൂപപ്പെടുത്തുന്നു, കാരണം ഇത് ഉപയോക്താവിന് ഊഹിക്കേണ്ട രഹസ്യ നമ്പർ നൽകുന്നു. പ്രോഗ്രാം ഉപയോഗിച്ച്, അവരുടെ ഊഹം ഇൻപുട്ട് ചെയ്യാൻ ഉപയോക്താവിനെ പ്രേരിപ്പിക്കുന്നു ഇൻപുട്ട്() ഫംഗ്‌ഷൻ, ഉപയോക്തൃ ഇൻപുട്ട് ഒരു സ്ട്രിംഗായി ക്യാപ്‌ചർ ചെയ്യുകയും പിന്നീട് താരതമ്യ ആവശ്യങ്ങൾക്കായി ഒരു പൂർണ്ണസംഖ്യയാക്കി മാറ്റുകയും ചെയ്യുന്നു.

ഗെയിമിൻ്റെ ഒഴുക്ക് നിയന്ത്രിക്കുന്നതിൽ ലൂപ്പ് ഘടന നിർണായക പങ്ക് വഹിക്കുന്നു. എ സമയത്ത് ക്രമരഹിതമായി ജനറേറ്റുചെയ്‌ത സംഖ്യയ്‌ക്കെതിരായ ഉപയോക്താവിൻ്റെ ഊഹങ്ങൾ തുടർച്ചയായി പരിശോധിക്കാൻ ലൂപ്പ് ഉപയോഗിക്കുന്നു. ഉപയോക്താവിൻ്റെ അനുമാനം തെറ്റാണെങ്കിൽ, ലൂപ്പ് കളിക്കാരനെ "ഉയർന്നതായി ഊഹിക്കുക" അല്ലെങ്കിൽ "താഴ്ന്ന ഊഹിക്കുക" എന്നതിലേക്ക് പ്രേരിപ്പിക്കുന്നത് തുടരുന്നു. ലൂപ്പിനുള്ളിലെ അവസ്ഥ ഉപയോക്താവിൻ്റെ ഊഹത്തെ രഹസ്യ നമ്പറുമായി താരതമ്യം ചെയ്യുന്നു, ഗെയിം അകാലത്തിൽ അവസാനിക്കാതെ ഉചിതമായ ഫീഡ്‌ബാക്ക് നൽകുന്നു. ഈ രീതിയിൽ ഉപയോക്തൃ ഇൻപുട്ട് കൈകാര്യം ചെയ്യുന്നതിലൂടെ, ഗെയിം ഇൻ്ററാക്ടീവ് ആയിത്തീരുന്നു, ശരിയായ ഉത്തരത്തിലേക്ക് കളിക്കാരനെ നയിക്കുന്നു.

ഉപയോഗിക്കുന്ന രണ്ടാമത്തെ സ്ക്രിപ്റ്റിൽ IPython.display, ഞങ്ങൾ കൂടുതൽ സങ്കീർണ്ണമായ ഔട്ട്പുട്ട് ഫോർമാറ്റ് അവതരിപ്പിക്കുന്നു ഗണിതം(), ഗണിതശാസ്ത്ര നൊട്ടേഷനിൽ സന്ദേശങ്ങൾ പ്രദർശിപ്പിക്കാൻ ഉപയോഗിക്കുന്ന ഒരു ഫംഗ്ഷൻ. എന്നിരുന്നാലും, ഒന്നിലധികം വേരിയബിളുകൾ ഉപയോഗിച്ച് സന്ദേശം ഫോർമാറ്റ് ചെയ്യുന്നതിനുള്ള ശതമാനം ചിഹ്നത്തിൻ്റെ (%) പ്രാരംഭ ഉപയോഗം ഒരു പിശകിന് കാരണമായി: %-നുള്ള പിന്തുണയില്ലാത്ത ഓപ്പറാൻഡ് തരം(കൾ): 'മാത്ത്', 'ട്യൂപ്പിൾ'. കാരണം ഈ പിശക് ഉണ്ടാകുന്നു ഗണിതം സ്ട്രിംഗ് ഇൻ്റർപോളേഷൻ്റെ ഈ രൂപത്തെ പിന്തുണയ്ക്കുന്നില്ല. പകരം, കൂടുതൽ അവബോധജന്യമായ പൈത്തണിൻ്റെ ആധുനിക എഫ്-സ്ട്രിംഗ് ഫോർമാറ്റിംഗ് ഉപയോഗിച്ച്, ഈ പ്രശ്നം പരിഹരിക്കുകയും ഉപയോക്താവ് ശരിയായി ഊഹിക്കുമ്പോൾ ഗെയിമിൻ്റെ അവസാനം ശരിയായി ഫോർമാറ്റ് ചെയ്ത സന്ദേശം പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു.

കൂടാതെ, മൂന്നാമത്തെ സ്ക്രിപ്റ്റ് ഒരു കൂട്ടം സംയോജിപ്പിക്കുന്നു യൂണിറ്റ് ടെസ്റ്റുകൾ പൈത്തൺ ഉപയോഗിച്ചാണ് എഴുതിയത് യൂണിറ്റ് ടെസ്റ്റ് ചട്ടക്കൂട്. ഈ ടെസ്റ്റുകളുടെ ഉദ്ദേശ്യം ഗെയിമിൻ്റെ പ്രവർത്തനക്ഷമതയുടെ മൂല്യനിർണ്ണയം ഓട്ടോമേറ്റ് ചെയ്യുകയാണ്, വിവിധ സാഹചര്യങ്ങളിൽ ഗെയിം പ്രതീക്ഷിക്കുന്നത് പോലെ പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കുക. പരിഹസിച്ചുകൊണ്ട് ഇൻപുട്ട്() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നത് unittest.mock.patch, ടെസ്റ്റിംഗ് സമയത്ത് മാനുവൽ ഇൻപുട്ട് ആവശ്യമില്ലാതെ ഞങ്ങൾ ഉപയോക്തൃ ഇൻപുട്ടുകൾ അനുകരിക്കുന്നു. ഈ സമീപനം കോഡിൻ്റെ ദൃഢത വർദ്ധിപ്പിക്കുന്നു, വ്യത്യസ്ത സാഹചര്യങ്ങളിൽ ഗെയിമിൻ്റെ ലോജിക് പരിശോധിക്കാൻ ഡെവലപ്പർമാരെ അനുവദിക്കുന്നു. യൂണിറ്റ് ടെസ്റ്റുകൾ സാധ്യതയുള്ള ബഗുകൾ നേരത്തേ കണ്ടുപിടിക്കാൻ സഹായിക്കുന്നു, പ്രോഗ്രാമിലെ മാറ്റങ്ങളൊന്നും നിലവിലുള്ള പ്രവർത്തനത്തെ തകർക്കുന്നില്ലെന്ന് ഉറപ്പാക്കുന്നു.

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

ഇൻ്ററാക്ടീവ് പ്രോഗ്രാമുകളിൽ ഡിസ്പ്ലേയ്ക്കായി പൈത്തൺ സ്ട്രിംഗ് ഫോർമാറ്റിംഗ് ഒപ്റ്റിമൈസ് ചെയ്യുന്നു

പൈത്തണിൽ ഒരു നമ്പർ ഊഹിക്കുന്ന ഗെയിം വികസിപ്പിക്കുന്നതിൻ്റെ ഒരു പ്രധാന വശം പ്രോഗ്രാം ഉപയോക്താവുമായി എങ്ങനെ സംവദിക്കുന്നു എന്നതാണ്. പ്രത്യേകിച്ചും, "ഉയർന്നതായി ഊഹിക്കുക" അല്ലെങ്കിൽ "താഴ്ന്നതായി ഊഹിക്കുക" പോലുള്ള സന്ദേശങ്ങൾ പ്രദർശിപ്പിക്കുമ്പോൾ, വ്യക്തവും കൃത്യവുമായ ഫോർമാറ്റിംഗ് ഉറപ്പാക്കേണ്ടത് അത്യാവശ്യമാണ്. ലൈബ്രറികൾ ഉപയോഗിക്കുമ്പോൾ ഒരു സാധാരണ വെല്ലുവിളി IPython.display ഔട്ട്പുട്ട് സ്ട്രിംഗുകൾ ശരിയായി ഫോർമാറ്റ് ചെയ്യുന്നു. സ്ട്രിംഗ് ഇൻ്റർപോളേഷനായി ശതമാനം ചിഹ്നം (%) ഉപയോഗിക്കുന്നത് പരമ്പരാഗതമാണെങ്കിലും, %: 'ഗണിതം', 'ട്യൂപ്പിൾ' എന്നിവയ്‌ക്കായി പിന്തുണയ്ക്കാത്ത ഓപ്പറാൻഡ് തരം(കൾ) പോലുള്ള പിശകുകളിലേക്ക് ഇത് നയിച്ചേക്കാം. പോലുള്ള ചില ലൈബ്രറികൾ കാരണം ഈ പ്രശ്നം സംഭവിക്കുന്നു ഗണിതം(), എഫ്-സ്ട്രിംഗ് ഫോർമാറ്റിംഗ് പോലുള്ള ബദൽ സമീപനങ്ങൾ ആവശ്യമാണ്.

ആധുനിക പൈത്തൺ പ്രോഗ്രാമിംഗിൽ, സ്ട്രിംഗുകളിലേക്ക് വേരിയബിളുകൾ തിരുകുന്നതിന് എഫ്-സ്ട്രിംഗുകൾ കൂടുതൽ കാര്യക്ഷമവും വായിക്കാവുന്നതുമായ മാർഗ്ഗം വാഗ്ദാനം ചെയ്യുന്നു. ഉദാഹരണത്തിന്, "അഭിനന്ദനങ്ങൾ! ശരിയായ സംഖ്യ %g ആയിരുന്നു" എന്ന് എഴുതുന്നതിനുപകരം, നിങ്ങൾക്ക് ഒരു f-സ്ട്രിംഗ് ഉപയോഗിക്കാം f'Congratulations! The correct number was {number}'. എഫ്-സ്ട്രിംഗുകൾ നിങ്ങളെ എക്സ്പ്രഷനുകൾ നേരിട്ട് ഉൾച്ചേർക്കാൻ അനുവദിക്കുന്നു, കോഡ് കൂടുതൽ സംക്ഷിപ്തമാക്കുകയും പരമ്പരാഗത സ്ട്രിംഗ് ഇൻ്റർപോളേഷനുമായി ബന്ധപ്പെട്ട അപകടസാധ്യതകൾ ഇല്ലാതാക്കുകയും ചെയ്യുന്നു. ഇത് വായനാക്ഷമത വർദ്ധിപ്പിക്കുക മാത്രമല്ല സാധാരണ ഫോർമാറ്റിംഗ് പിശകുകൾ തടയുകയും ചെയ്യുന്നു.

എഫ്-സ്ട്രിംഗുകൾ ഉപയോഗിക്കുന്നതിനു പുറമേ, സംവേദനാത്മക പ്രോഗ്രാമുകൾ നിർമ്മിക്കുമ്പോൾ മറ്റൊരു പ്രധാന പരിഗണന ഉപയോക്തൃ ഇൻപുട്ട് മൂല്യനിർണ്ണയമാണ്. ഉപയോക്താക്കളിൽ നിന്ന് ഇൻപുട്ട് സ്വീകരിക്കുമ്പോൾ, പ്രത്യേകിച്ച് ഊഹങ്ങൾ ആവർത്തിച്ച് നൽകുന്ന ഒരു ഗെയിമിൽ, നോൺ-ഇൻ്റേജർ ഇൻപുട്ടുകൾ പോലുള്ള സാധ്യതയുള്ള ഒഴിവാക്കലുകൾ കൈകാര്യം ചെയ്യുന്നത് പ്രധാനമാണ്. നടപ്പിലാക്കുന്നത് try-except അസാധുവായ ഇൻപുട്ട് കാരണം പ്രോഗ്രാം ക്രാഷ് ചെയ്യുന്നില്ലെന്ന് ബ്ലോക്കുകൾ ഉറപ്പാക്കുന്നു. പകരം, സാധുതയുള്ള ഡാറ്റ നൽകാൻ ഉപയോക്താവിനെ അത് മനോഹരമായി പ്രേരിപ്പിക്കുകയും അതുവഴി മൊത്തത്തിലുള്ള ഉപയോക്തൃ അനുഭവം മെച്ചപ്പെടുത്തുകയും ചെയ്യും. ഒപ്റ്റിമൈസ് ചെയ്ത സ്ട്രിംഗ് ഫോർമാറ്റിംഗിൻ്റെയും ഇൻപുട്ട് മൂല്യനിർണ്ണയത്തിൻ്റെയും ഈ സംയോജനം കൂടുതൽ കരുത്തുറ്റതും ഉപയോക്തൃ-സൗഹൃദവുമായ പൈത്തൺ ആപ്ലിക്കേഷനുകളിലേക്ക് നയിക്കുന്നു.