%: अनुमान लगाने वाले खेल में 'गणित' और 'टुपल': असमर्थित ऑपरेंड प्रकार: इसे कैसे ठीक करें

इंटरैक्टिव अनुमान लगाने वाला गेम बनाते समय सामान्य पायथन त्रुटि

पायथन सीखते समय, सबसे रोमांचक परियोजनाओं में से एक संख्या अनुमान लगाने वाले गेम जैसे इंटरैक्टिव गेम बनाना है। ऐसी परियोजनाएं आपको यह समझने में मदद करती हैं कि पायथन उपयोगकर्ता इनपुट के साथ कैसे इंटरैक्ट करता है और प्रोग्राम के व्यवहार को निर्देशित करने के लिए नियंत्रण प्रवाह का उपयोग करता है। इस मामले में, लक्ष्य यह है कि पायथन उपयोगकर्ता को 1 और 100 के बीच की संख्या का अनुमान लगाने के लिए प्रेरित करे, अधिक या कम का अनुमान लगाने के लिए प्रतिक्रिया दे, और अंत में, पुष्टि करें कि सही अनुमान कब लगाया गया है।

हालाँकि, कई प्रोग्रामिंग अभ्यासों की तरह, त्रुटियाँ उत्पन्न हो सकती हैं जो तुरंत स्पष्ट नहीं होती हैं। पाइथन ट्यूटोरियल का अनुसरण करते समय आपको एक त्रुटि का सामना करना पड़ सकता है, जैसे कि जिस पर आप काम कर रहे हैं, वह % के लिए असमर्थित ऑपरेंड प्रकार है: 'मैथ' और 'ट्यूपल'। यह निराशाजनक हो सकता है, खासकर जब वाक्यविन्यास पहली नज़र में सही लगता है।

अनुमान लगाने के इस खेल में, आपको जिस त्रुटि का सामना करना पड़ रहा है वह आम तौर पर तब होती है जब आप इसका उपयोग करते समय एक स्ट्रिंग को गलत तरीके से प्रारूपित करने का प्रयास कर रहे होते हैं गणित में कार्य करें आईपीथॉन.डिस्प्ले पुस्तकालय। यह एक सामान्य गलती है, लेकिन एक बार पहचान लेने पर समाधान सीधा हो जाता है।

यह मार्गदर्शिका आपको बताएगी कि त्रुटि का क्या अर्थ है, यह क्यों होती है, और आप इसे ठीक करने के लिए अपने पायथन कोड को कैसे संशोधित कर सकते हैं। अंत तक, आपके पास भ्रमित करने वाले त्रुटि संदेश के बिना पूरी तरह से काम करने वाला अनुमान लगाने वाला गेम होगा!

पायथन के अनुमान लगाने वाले गेम कोड के पीछे के यांत्रिकी को समझना

पायथन अनुमान लगाने वाली गेम स्क्रिप्ट को उपयोगकर्ता को 1 और 100 के बीच यादृच्छिक रूप से उत्पन्न संख्या का अनुमान लगाने की अनुमति देने के लिए डिज़ाइन किया गया है। इस कार्यक्रम में पहला महत्वपूर्ण तत्व का उपयोग है रैंडम.रैंडिंट() फ़ंक्शन, जो निर्दिष्ट सीमा (1 से 100) के भीतर एक यादृच्छिक पूर्णांक उत्पन्न करता है। यह गेम के पीछे मुख्य तर्क बनाता है, क्योंकि यह वह गुप्त संख्या प्रदान करता है जिसका उपयोगकर्ता को अनुमान लगाना होता है। इसके बाद प्रोग्राम उपयोगकर्ता को इसका उपयोग करके अपना अनुमान इनपुट करने के लिए प्रेरित करता है इनपुट() फ़ंक्शन, जो उपयोगकर्ता इनपुट को एक स्ट्रिंग के रूप में कैप्चर करता है और बाद में तुलना उद्देश्यों के लिए पूर्णांक में परिवर्तित किया जाता है।

लूप संरचना गेम के प्रवाह को नियंत्रित करने में महत्वपूर्ण भूमिका निभाती है। ए जबकि लूप का उपयोग यादृच्छिक रूप से उत्पन्न संख्या के विरुद्ध उपयोगकर्ता के अनुमानों को लगातार जांचने के लिए किया जाता है। जब तक उपयोगकर्ता का अनुमान गलत है, लूप खिलाड़ी को या तो "अधिक अनुमान लगाएं" या "कम अनुमान लगाएं" के लिए प्रेरित करता रहता है। लूप के अंदर की स्थिति उपयोगकर्ता के अनुमान की तुलना गुप्त संख्या से करती है, यह सुनिश्चित करती है कि गेम समय से पहले समाप्त हुए बिना उचित प्रतिक्रिया प्रदान करता है। उपयोगकर्ता इनपुट को इस तरह से संभालने से, गेम इंटरैक्टिव हो जाता है, जिससे खिलाड़ी को सही उत्तर की ओर मार्गदर्शन मिलता है।

दूसरी स्क्रिप्ट का उपयोग करते हुए आईपीथॉन.डिस्प्ले, हम एक अधिक परिष्कृत आउटपुट स्वरूप प्रस्तुत करते हैं गणित(), गणितीय संकेतन में संदेशों को प्रदर्शित करने के लिए उपयोग किया जाने वाला एक फ़ंक्शन। हालाँकि, एकाधिक चर के साथ संदेश को प्रारूपित करने के लिए प्रतिशत प्रतीक (%) के प्रारंभिक उपयोग के कारण एक त्रुटि हुई: % के लिए असमर्थित ऑपरेंड प्रकार: 'गणित' और 'ट्यूपल'। यह त्रुटि इसलिए उत्पन्न होती है क्योंकि गणित स्ट्रिंग इंटरपोलेशन के इस रूप का समर्थन नहीं करता. इसके बजाय, पायथन के आधुनिक एफ-स्ट्रिंग फ़ॉर्मेटिंग का उपयोग करना, जो अधिक सहज है, इस समस्या को हल करता है और उपयोगकर्ता के सही अनुमान लगाने पर गेम के अंत में एक उचित स्वरूपित संदेश प्रदर्शित करता है।

इसके अतिरिक्त, तीसरी स्क्रिप्ट एक सेट को एकीकृत करती है इकाई परीक्षण पायथन का उपयोग करके लिखा गया इकाई परीक्षण रूपरेखा। इन परीक्षणों का उद्देश्य गेम की कार्यक्षमता के सत्यापन को स्वचालित करना है, यह सुनिश्चित करना कि गेम विभिन्न परिदृश्यों में अपेक्षित व्यवहार करता है। का उपहास करके इनपुट() फ़ंक्शन का उपयोग करना यूनिटटेस्ट.मॉक.पैच, हम मैन्युअल इनपुट की आवश्यकता के बिना परीक्षण के दौरान उपयोगकर्ता इनपुट का अनुकरण करते हैं। यह दृष्टिकोण कोड की मजबूती को बढ़ाता है, जिससे डेवलपर्स को विभिन्न परिस्थितियों में गेम के तर्क को सत्यापित करने की अनुमति मिलती है। यूनिट परीक्षण संभावित बग को जल्दी पकड़ने में मदद करते हैं, यह सुनिश्चित करते हुए कि प्रोग्राम में कोई भी बदलाव मौजूदा कार्यक्षमता को नहीं तोड़ता है।

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

इंटरएक्टिव प्रोग्राम में प्रदर्शन के लिए पायथन स्ट्रिंग फ़ॉर्मेटिंग का अनुकूलन

पायथन में संख्या अनुमान लगाने वाले गेम को विकसित करने का एक प्रमुख पहलू यह है कि प्रोग्राम उपयोगकर्ता के साथ कैसे इंटरैक्ट करता है। विशेष रूप से, "अधिक अनुमान लगाएं" या "कम अनुमान लगाएं" जैसे संदेश प्रदर्शित करते समय स्पष्ट और सटीक स्वरूपण सुनिश्चित करना आवश्यक है। जैसे पुस्तकालयों का उपयोग करते समय एक आम चुनौती आईपीथॉन.डिस्प्ले आउटपुट स्ट्रिंग्स को ठीक से फ़ॉर्मेट कर रहा है। जबकि स्ट्रिंग इंटरपोलेशन के लिए प्रतिशत प्रतीक (%) का उपयोग पारंपरिक है, यह % के लिए असमर्थित ऑपरेंड प्रकार (ओं) जैसी त्रुटियों को जन्म दे सकता है: 'गणित' और 'ट्यूपल'। यह समस्या इसलिए होती है क्योंकि कुछ लाइब्रेरी, जैसे गणित(), एफ-स्ट्रिंग फ़ॉर्मेटिंग जैसे वैकल्पिक तरीकों की आवश्यकता है।

आधुनिक पायथन प्रोग्रामिंग में, एफ-स्ट्रिंग्स स्ट्रिंग्स में वेरिएबल्स डालने का एक अधिक कुशल और पठनीय तरीका प्रदान करते हैं। उदाहरण के लिए, "बधाई हो! सही संख्या %g थी" लिखने के बजाय आप एफ-स्ट्रिंग का उपयोग कर सकते हैं f'Congratulations! The correct number was {number}'. एफ-स्ट्रिंग्स आपको अभिव्यक्तियों को सीधे एम्बेड करने की अनुमति देते हैं, जिससे कोड अधिक संक्षिप्त हो जाता है और पारंपरिक स्ट्रिंग इंटरपोलेशन से जुड़े जोखिम समाप्त हो जाते हैं। यह न केवल पठनीयता बढ़ाता है बल्कि सामान्य स्वरूपण त्रुटियों को भी रोकता है।

एफ-स्ट्रिंग्स का उपयोग करने के अलावा, इंटरैक्टिव प्रोग्राम बनाते समय एक और महत्वपूर्ण विचार उपयोगकर्ता इनपुट सत्यापन है। उपयोगकर्ताओं से इनपुट स्वीकार करते समय, विशेष रूप से ऐसे गेम में जहां अनुमान बार-बार दर्ज किए जाते हैं, गैर-पूर्णांक इनपुट जैसे संभावित अपवादों को संभालना महत्वपूर्ण है। कार्यान्वयन try-except ब्लॉक यह सुनिश्चित करता है कि प्रोग्राम अमान्य इनपुट के कारण क्रैश न हो। इसके बजाय, यह उपयोगकर्ता को वैध डेटा दर्ज करने के लिए शालीनता से संकेत दे सकता है, जिससे समग्र उपयोगकर्ता अनुभव में सुधार होगा। अनुकूलित स्ट्रिंग फ़ॉर्मेटिंग और इनपुट सत्यापन का यह संयोजन अधिक मजबूत और उपयोगकर्ता-अनुकूल पायथन अनुप्रयोगों की ओर ले जाता है।