पायथन में if __name__ == "__main__" कंस्ट्रक्ट क्या करता है?

कुछ प्रोग्रामिंग भाषाओं में, मुख्य विधि किसी प्रोग्राम के निष्पादन के लिए एकमात्र प्रवेश बिंदु के रूप में कार्य करती है। अन्य भाषाओं से पायथन में संक्रमण करते समय, मुहावरा यदि __नाम__ == "__मुख्य__" ऐसा प्रतीत हो सकता है कि यह वही कार्य पूरा कर रहा है। पायथन में, यह मामला नहीं है।

यदि __नाम__ == "__मुख्य__" जब फ़ाइल स्क्रिप्ट के रूप में चलती है तो मुहावरा एक विशिष्ट कोड को निष्पादित करने की अनुमति देता है। यह यह भी सुनिश्चित करता है कि जब आप फ़ाइल को मॉड्यूल के रूप में आयात करते हैं तो वही कोड निष्पादित नहीं होता है।

__नाम__ परिवर्तनीय व्यवहार को समझना

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

यह पहली बार में भ्रमित करने वाला हो सकता है, लेकिन निम्नलिखित उदाहरण पर एक नज़र डालें:

एक स्क्रिप्ट बनाएं और उसे नाम दें शुभकामनाएँ.py. इस स्क्रिप्ट में एक फ़ंक्शन होगा जो उपयोगकर्ता का स्वागत करता है और उसका मान प्रिंट करता है __नाम__ चर। यह उपयोगकर्ता से अपना नाम दर्ज करने के लिए भी कहेगा।

डीईएफ़अभिवादन(नाम):
 प्रिंट(च"हैलो, {नाम}!")
प्रिंट("__नाम__ का मान:", __नाम__)
अगर __नाम__ == "__मुख्य__":
 उपयोगकर्ता_नाम = इनपुट("कृपया अपना नाम दर्ज करें: ")
 नमस्कार (उपयोगकर्ता_नाम)
अन्य:
 प्रिंट("मॉड्यूल 'अभिवादन' आयात किया गया है।")

चला रहा हूँ शुभकामनाएँ.py स्क्रिप्ट निम्नलिखित आउटपुट प्रदर्शित करेगी:

का मूल्य __नाम__ वैरिएबल रिटर्न के रूप में __मुख्य__ क्योंकि स्क्रिप्ट सीधे निष्पादित होती है।

अब एक और स्क्रिप्ट बनाएं और उसे नाम दें स्क्रिप्ट2.py. फिर, आयात करें अभिवादन एक मॉड्यूल के रूप में स्क्रिप्ट।

आयात अभिवादन
प्रिंट("अभिवादन स्क्रिप्ट निष्पादित कर रहा हूँ...")
नमस्कार.नमस्कार("ऐलिस")

को कॉल कर रहा हूँ अभिवादन से कार्य करें अभिवादन मॉड्यूल निम्नलिखित आउटपुट देता है।

का मूल्य __नाम__ आयातित मॉड्यूल के वास्तविक नाम में परिवर्तन। इस मामले में, अभिवादन.

यह मान ही मुहावरा है यदि __नाम__ == "__मुख्य__" यह निर्धारित करने के लिए देखता है कि कोई फ़ाइल स्क्रिप्ट के रूप में चल रही है या मॉड्यूल के रूप में आयात की गई है।

if __name__ == "__main__" निर्माण का उपयोग कब करें?

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

# कैलकुलेटर.py
डीईएफ़जोड़ना(ए, बी):
वापस करना ए + बी
डीईएफ़घटाना(ए, बी):
वापस करना ए - बी
डीईएफ़गुणा(ए, बी):
वापस करना ए * बी
डीईएफ़विभाजित करना(ए, बी):
अगर बी != 0:
वापस करना ए / बी
अन्य:
वापस करना"त्रुटि: शून्य से विभाजन!"
अगर __नाम__ == "__मुख्य__":
 प्रिंट("कैलकुलेटर में आपका स्वागत है!")
 प्रिंट("एक ऑपरेशन चुनें:")
 प्रिंट("1. जोड़ना")
 प्रिंट("2. घटाना")
 प्रिंट("3. गुणा करें")
 प्रिंट("4. विभाजित करना")
 विकल्प = int (इनपुट("अपनी पसंद दर्ज करें (1-4):"))
 num1 = फ़्लोट (इनपुट("पहला नंबर दर्ज करें:"))
 num2 = फ़्लोट (इनपुट("दूसरा नंबर दर्ज करें:"))
अगर विकल्प == 1:
 परिणाम = जोड़ें (संख्या 1, संख्या 2)
 प्रिंट(च"का योग {संख्या1} और {संख्या2} है: {परिणाम}")
एलिफ़ विकल्प == 2:
 परिणाम = घटाएं (संख्या 1, संख्या 2)
 प्रिंट(च"के बीच का अंतर {संख्या1} और {संख्या2} है: {परिणाम}")
एलिफ़ विकल्प == 3:
 परिणाम = गुणा (संख्या 1, संख्या 2)
 प्रिंट(च"का उत्पाद {संख्या1} और {संख्या2} है: {परिणाम}")
एलिफ़ विकल्प == 4:
 परिणाम = विभाजित करें (संख्या 1, संख्या 2)
 प्रिंट(च"का विभाजन {संख्या1} द्वारा {संख्या2} है: {परिणाम}")
अन्य:
 प्रिंट("अमान्य विकल्प!")

पहला परिदृश्य तब होता है जब आप किसी स्क्रिप्ट को स्वतंत्र रूप से चलाना और विशिष्ट क्रियाएं करना चाहते हैं। यह स्क्रिप्ट को एक स्टैंडअलोन प्रोग्राम के रूप में कार्य करने की अनुमति देता है। यदि __नाम__ == "__मुख्य__" कंस्ट्रक्शन उपयोगकर्ताओं को कमांड लाइन इंटरफ़ेस का उपयोग करके कैलकुलेटर के साथ इंटरैक्ट करने की अनुमति देता है। यह उपयोगकर्ताओं को अंतर्निहित कोड को समझने या संशोधित किए बिना प्रोग्राम की कार्यक्षमता का उपयोग करने की क्षमता देता है।

इसके बिना प्रोग्राम चलाना अभी भी संभव है यदि __नाम__ == "__मुख्य__" निर्माण करें और समान परिणाम प्राप्त करें, लेकिन आपका कोड मॉड्यूलर कोड संगठन खो देगा।

दूसरा परिदृश्य वह है जब आप अपना चाहते हैं मॉड्यूलर डिज़ाइन वाला कोड. यह अन्य प्रोग्रामों को आपकी स्क्रिप्ट को एक मॉड्यूल के रूप में आयात करने और अनावश्यक कार्यक्षमताओं को ट्रिगर किए बिना इसके कार्यों का उपयोग करने की अनुमति देता है।

कैलकुलेटर प्रोग्राम के मामले में, अन्य प्रोग्राम आयात कर सकते हैं कैलकुलेटर सीएलआई इंटरफ़ेस और उपयोगकर्ता इनपुट संकेतों को ट्रिगर किए बिना मॉड्यूल। यह कोड पुन: प्रयोज्यता और मॉड्यूलर डिज़ाइन सुनिश्चित करता है। इसलिए, कैलकुलेटर को बड़े अनुप्रयोगों में निर्बाध रूप से एकीकृत करने में सक्षम बनाया गया है।

आयात कैलकुलेटर
# कैलकुलेटर मॉड्यूल से फ़ंक्शंस का उपयोग करना
परिणाम_जोड़ें = कैलकुलेटर.जोड़ें(5, 3)
प्रिंट("अतिरिक्त परिणाम:", परिणाम_जोड़ें)
परिणाम_घटाना = कैलकुलेटर.घटाना(10, 4)
प्रिंट("घटाव परिणाम:", परिणाम_घटाना)

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

आयात कैलकुलेटर
# कैलकुलेटर कार्यों का परीक्षण
अगर __नाम__ == "__मुख्य__":
# परीक्षण जोड़
 परिणाम = कैलकुलेटर.जोड़ें(5, 3)
 प्रिंट("अतिरिक्त परिणाम:", परिणाम)
# घटाव का परीक्षण करें
 परिणाम = कैलकुलेटर.घटाना(8, 4)
 प्रिंट("घटाव परिणाम:", परिणाम)
# गुणन परीक्षण
 परिणाम = कैलकुलेटर.गुणा(2, 6)
 प्रिंट("गुणा परिणाम:", परिणाम)

उपरोक्त कोड दर्शाता है कि कैलकुलेटर स्क्रिप्ट को स्वतंत्र रूप से कैसे डीबग किया जाए।

if __name__ == "__main__" कंस्ट्रक्ट का उपयोग करना कब अनावश्यक है?

जैसा कि आपने उपरोक्त परिदृश्यों में देखा है, का उपयोग यदि __नाम__ == "__मुख्य__" निर्माण का उद्देश्य उस स्क्रिप्ट को अलग करना है जिसे आप मुख्य प्रोग्राम के रूप में चला रहे हैं और जिसे आप मॉड्यूल के रूप में आयात कर रहे हैं। हालाँकि कुछ मामले ऐसे भी हैं जहाँ इसका उपयोग अनावश्यक है।

पहला मामला तब होता है जब आपकी स्क्रिप्ट सरल होती है और इसमें कोई पुन: प्रयोज्य फ़ंक्शन या मॉड्यूल नहीं होता है और आप इसे आयात करने का इरादा नहीं रखते हैं। इस मामले में, आपको इस निर्माण को छोड़ देना चाहिए क्योंकि चलाने पर पूरी स्क्रिप्ट निष्पादित होती है। यह एक बार की स्क्रिप्ट के लिए सामान्य है जो एक विशिष्ट उद्देश्य पूरा करती है और पुन: उपयोग या आयात के लिए नहीं होती है।

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

इन इंटरैक्टिव वातावरणों में, मुख्य प्रोग्राम के रूप में चलने वाली या मॉड्यूल के रूप में आयातित स्क्रिप्ट की अवधारणा लागू नहीं होती है। आप पारंपरिक स्क्रिप्ट प्रविष्टि बिंदु की आवश्यकता के बिना सीधे कोड स्निपेट निष्पादित कर रहे हैं।

आप पायथन में मास्टर कैसे बनें?

किसी भी प्रोग्रामिंग भाषा में मास्टर बनने के लिए, आपको यह समझना होगा कि फ़ंक्शन या टूल की अंतर्निहित अवधारणाएं कैसे काम करती हैं। ठीक वैसे ही जैसे आपने इस आलेख में if __name__ == "__main__" निर्माण के बारे में सीखा।

अंतर्निहित अवधारणाओं को समझने से आपको यह जानने में मदद मिलेगी कि जब आप उनका उपयोग करेंगे तो आपका प्रोग्राम कैसा व्यवहार करेगा। कोई जल्दी नहीं है, एक-एक करके अवधारणाओं को सीखने से आपको उनमें से प्रत्येक में गहराई से उतरने में मदद मिलेगी।