%: अंदाज लावण्याच्या खेळात 'गणित' आणि 'टपल': असमर्थित ऑपरेंड प्रकार: ते कसे सोडवायचे

इंटरएक्टिव्ह गेसिंग गेम तयार करताना सामान्य पायथन त्रुटी

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

तथापि, अनेक प्रोग्रामिंग व्यायामांप्रमाणे, त्रुटी उद्भवू शकतात ज्या त्वरित स्पष्ट होत नाहीत. पायथन ट्यूटोरियल फॉलो करताना तुम्हाला एक त्रुटी येऊ शकते, जसे की तुम्ही ज्यावर काम करत आहात, ती म्हणजे %: 'Math' आणि 'tuple' साठी असमर्थित ऑपरेंड प्रकार. हे निराशाजनक असू शकते, विशेषतः जेव्हा वाक्यरचना पहिल्या दृष्टीक्षेपात योग्य दिसते.

या अंदाज लावण्याच्या गेममध्ये, आपण वापरत असताना स्ट्रिंग चुकीचे स्वरूपित करण्याचा प्रयत्न करत असताना आपणास सामोरे जाण्याची त्रुटी सामान्यत: घडते. गणित मध्ये कार्य IPython.display लायब्ररी ही एक सामान्य चूक आहे, परंतु उपाय ओळखल्यानंतर सरळ आहे.

हे मार्गदर्शक तुम्हाला त्रुटीचा अर्थ काय, ती का उद्भवते आणि ती दुरुस्त करण्यासाठी तुम्ही तुमचा पायथन कोड कसा बदलू शकता याविषयी मार्गदर्शन करेल. अखेरीस, तुमच्याकडे गोंधळात टाकणाऱ्या एरर मेसेजशिवाय अंदाज लावणारा गेम असेल!

पायथनच्या अंदाज लावण्याच्या गेम कोडमागील यांत्रिकी समजून घेणे

पायथन अंदाज लावणारी गेम स्क्रिप्ट वापरकर्त्याला 1 आणि 100 मधील यादृच्छिकपणे व्युत्पन्न केलेल्या संख्येचा अंदाज लावण्यासाठी डिझाइन केली आहे. या प्रोग्राममधील पहिला महत्त्वाचा घटक म्हणजे random.randint() फंक्शन, जे निर्दिष्ट श्रेणीमध्ये (1 ते 100) यादृच्छिक पूर्णांक तयार करते. हे गेममागील मुख्य तर्क तयार करते, कारण ते वापरकर्त्याने अंदाज लावलेला गुप्त क्रमांक प्रदान करते. प्रोग्राम नंतर वापरकर्त्यास त्यांचा अंदाज इनपुट करण्यास प्रॉम्प्ट करतो इनपुट() फंक्शन, जे वापरकर्ता इनपुट स्ट्रिंग म्हणून कॅप्चर करते आणि नंतर तुलना करण्याच्या हेतूने पूर्णांक मध्ये रूपांतरित केले जाते.

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

वापरून दुसऱ्या स्क्रिप्ट मध्ये IPython.display, आम्ही यासह अधिक परिष्कृत आउटपुट स्वरूप सादर करतो गणित(), गणितीय नोटेशनमध्ये संदेश प्रदर्शित करण्यासाठी वापरलेले कार्य. तथापि, एकाधिक व्हेरिएबल्ससह संदेश स्वरूपित करण्यासाठी टक्केवारी चिन्ह (%) च्या प्रारंभिक वापरामुळे त्रुटी उद्भवली: %: 'Math' आणि 'tuple' साठी असमर्थित ऑपरेंड प्रकार(s). ही त्रुटी उद्भवली कारण गणित स्ट्रिंग इंटरपोलेशन या स्वरूपाचे समर्थन करत नाही. त्याऐवजी, पायथनचे आधुनिक एफ-स्ट्रिंग फॉरमॅटिंग वापरणे, जे अधिक अंतर्ज्ञानी आहे, या समस्येचे निराकरण करते आणि जेव्हा वापरकर्ता योग्य अंदाज लावतो तेव्हा गेमच्या शेवटी योग्यरित्या स्वरूपित संदेश प्रदर्शित करतो.

याव्यतिरिक्त, तिसरी स्क्रिप्ट एक संच समाकलित करते युनिट चाचण्या पायथन वापरून लिहिले एकक चाचणी फ्रेमवर्क या चाचण्यांचा उद्देश गेमच्या कार्यक्षमतेचे प्रमाणीकरण स्वयंचलित करणे हा आहे, हे सुनिश्चित करणे की गेम विविध परिस्थितींमध्ये अपेक्षेप्रमाणे वागतो. थट्टा करून इनपुट() फंक्शन वापरून 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()

१

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

इंटरएक्टिव्ह प्रोग्राममध्ये डिस्प्लेसाठी पायथन स्ट्रिंग फॉरमॅटिंग ऑप्टिमाइझ करणे

पायथनमध्ये नंबर अंदाज लावणारा गेम विकसित करण्याचा एक महत्त्वाचा पैलू म्हणजे प्रोग्राम वापरकर्त्याशी कसा संवाद साधतो. विशेषतः, "Guess High" किंवा "Guess Low" असे संदेश प्रदर्शित करताना स्पष्ट आणि अचूक स्वरूपन सुनिश्चित करणे आवश्यक आहे. सारख्या लायब्ररी वापरताना एक सामान्य आव्हान IPython.display आउटपुट स्ट्रिंग्स योग्यरित्या फॉरमॅट करत आहे. स्ट्रिंग इंटरपोलेशनसाठी टक्केवारी चिन्ह (%) वापरणे हे पारंपारिक असले तरी, यामुळे %: 'Math' आणि 'tuple' साठी असमर्थित ऑपरेंड प्रकार(s) सारख्या त्रुटी येऊ शकतात. ही समस्या उद्भवते कारण काही लायब्ररी, जसे की गणित(), f-स्ट्रिंग फॉरमॅटिंग सारख्या पर्यायी पध्दतींची आवश्यकता आहे.

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

एफ-स्ट्रिंग्स वापरण्याव्यतिरिक्त, परस्परसंवादी प्रोग्राम तयार करताना आणखी एक महत्त्वाचा विचार म्हणजे वापरकर्ता इनपुट प्रमाणीकरण. वापरकर्त्यांकडून इनपुट स्वीकारताना, विशेषत: एखाद्या गेममध्ये जेथे अंदाज वारंवार एंटर केला जातो, संभाव्य अपवाद हाताळणे, जसे की पूर्णांक नसलेले इनपुट, महत्वाचे आहे. अंमलबजावणी करत आहे १ ब्लॉक्स हे सुनिश्चित करतात की अवैध इनपुटमुळे प्रोग्राम क्रॅश होणार नाही. त्याऐवजी, ते वापरकर्त्याला वैध डेटा प्रविष्ट करण्यास प्रवृत्त करू शकते, ज्यामुळे एकूण वापरकर्ता अनुभव सुधारतो. ऑप्टिमाइझ्ड स्ट्रिंग फॉरमॅटिंग आणि इनपुट व्हॅलिडेशनचे हे संयोजन अधिक मजबूत आणि वापरकर्ता-अनुकूल पायथन ऍप्लिकेशन्सकडे नेत आहे.