[python] क्या होता है यदि __name__ == "__main__": क्या करें?



Answers

जब आपकी स्क्रिप्ट पाइथन दुभाषिया को कमांड के रूप में पास करके चलाया जाता है,

python myscript.py

इंडेंटेशन स्तर 0 पर मौजूद सभी कोड निष्पादित हो जाते हैं। परिभाषित किए गए कार्यों और वर्गों को अच्छी तरह से परिभाषित किया गया है, लेकिन उनमें से कोई भी कोड चलाया नहीं जाता है। अन्य भाषाओं के विपरीत, कोई main() फ़ंक्शन नहीं है जो स्वचालित रूप से चलाया जाता है - main() फ़ंक्शन शीर्ष स्तर पर सभी कोड स्पष्ट रूप से होता है।

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

if __name__ == "__main__":
    ...

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

# file one.py
def func():
    print("func() in one.py")

print("top-level in one.py")

if __name__ == "__main__":
    print("one.py is being run directly")
else:
    print("one.py is being imported into another module")
# file two.py
import one

print("top-level in two.py")
one.func()

if __name__ == "__main__":
    print("two.py is being run directly")
else:
    print("two.py is being imported into another module")

अब, यदि आप दुभाषिया के रूप में आह्वान करते हैं

python one.py

आउटपुट होगा

top-level in one.py
one.py is being run directly

यदि आप इसके बजाय दो. two.py चलाते हैं:

python two.py

आपको मिला

top-level in one.py
one.py is being imported into another module
top-level in two.py
func() in one.py
two.py is being run directly

इस प्रकार, जब मॉड्यूल लोड हो जाता है, तो इसका __name__ "__main__" बजाय "one" बराबर होता है।

Question

if __name__ == "__main__": तो क्या करें?

# Threading example
import time, thread

def myfunction(string, sleeptime, lock, *args):
    while True:
        lock.acquire()
        time.sleep(sleeptime)
        lock.release()
        time.sleep(sleeptime)

if __name__ == "__main__":
    lock = thread.allocate_lock()
    thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
    thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))



if __name__ == '__main__' बारे में कुछ भी समझाए जाने से पहले यह समझना महत्वपूर्ण है कि __name__ क्या है और यह क्या करता है।

__name__ क्या है?

__name__ एक डंडरियास है - जिसे वैश्विक चर (मॉड्यूल से सुलभ) के रूप में माना जा सकता है और वैश्विक रूप से इसी तरह काम करता है।

यह एक स्ट्रिंग (उपर्युक्त जैसा वैश्विक है) जैसा कि type(__name__) द्वारा दर्शाया गया है type(__name__) <class 'str'> ), और दोनों पायथन 3 और पायथन 2 संस्करणों के लिए एक अंतर्निहित मानक है।

कहा पे:

इसका उपयोग न केवल स्क्रिप्ट में किया जा सकता है बल्कि दुभाषिया और मॉड्यूल / पैकेज दोनों में भी पाया जा सकता है।

दुभाषिया:

>>> print(__name__)
__main__
>>>

स्क्रिप्ट:

test_file.py :

print(__name__)

__main__ में __main__

मॉड्यूल या पैकेज:

somefile.py:

def somefunction():
    print(__name__)

test_file.py:

import somefile
somefile.somefunction()

कुछ फाइल में परिणाम

ध्यान दें कि जब पैकेज या मॉड्यूल में उपयोग किया जाता है, तो __name__ फ़ाइल का नाम लेता है। वास्तविक मॉड्यूल या पैकेज पथ का मार्ग नहीं दिया गया है, लेकिन इसका अपना डंडरअलीस __file__ , जो इसके लिए अनुमति देता है।

आपको यह देखना चाहिए कि, जहां __name__ , जहां यह मुख्य फ़ाइल (या प्रोग्राम) है, हमेशा __main__ , और यदि यह एक मॉड्यूल / पैकेज है, या कुछ अन्य पायथन स्क्रिप्ट से चल रहा है, तो फ़ाइल का नाम वापस कर देगा जहां से इसका जन्म हुआ है।

अभ्यास:

एक चर होने का मतलब है कि इसका मान अधिलेखित किया जा सकता है ("कर" का मतलब "नहीं होना चाहिए"), __name__ के मान को ओवरराइट करने से पठनीयता की कमी होगी। तो किसी भी कारण से ऐसा मत करो। यदि आपको एक वैरिएबल की आवश्यकता है तो एक नया वैरिएबल परिभाषित करें।

यह हमेशा माना जाता है कि __name__ का मान __main__ या फ़ाइल का नाम होना चाहिए। एक बार फिर से इस डिफ़ॉल्ट मान को बदलने से अधिक भ्रम पैदा होगा कि यह अच्छा होगा, जिससे लाइनें और नीचे की समस्याएं पैदा कर सकती हैं।

उदाहरण:

>>> __name__ = 'Horrify' # Change default from __main__
>>> if __name__ == 'Horrify': print(__name__)
...
>>> else: print('Not Horrify')
...
Horrify
>>>

इसे सामान्य रूप से स्क्रिप्ट में if __name__ == '__main__' शामिल करने के लिए अच्छा अभ्यास माना जाता है।

अब जवाब देने के लिए if __name__ == '__main__' :

अब हम जानते हैं कि __name__ चीजों का व्यवहार स्पष्ट हो गया है:

if कोई प्रवाह नियंत्रण कथन है जिसमें कोड का ब्लॉक निष्पादित होगा यदि दिया गया मान सत्य है। हमने देखा है कि __name__ या तो __main__ या फ़ाइल नाम से आयात किया जा सकता है।

इसका अर्थ यह है कि यदि __name__ के बराबर है तो फ़ाइल मुख्य फ़ाइल होनी चाहिए और वास्तव में चलाना चाहिए (या यह दुभाषिया है), स्क्रिप्ट में आयातित मॉड्यूल या पैकेज नहीं।

यदि वास्तव में __name__ का मान __main__ तो कोड के उस ब्लॉक में जो भी हो, निष्पादित होगा।

यह हमें बताता है कि यदि चल रही फ़ाइल मुख्य फ़ाइल है (या आप सीधे दुभाषिया से चल रहे हैं) तो उस स्थिति को निष्पादित करना होगा। यदि यह एक पैकेज है तो यह नहीं होना चाहिए, और मूल्य __main__ नहीं होगा।

मॉड्यूल:

मॉड्यूल के नाम को परिभाषित करने के लिए __name__ को मॉड्यूल में भी इस्तेमाल किया जा सकता है

प्रकार:

__name__ साथ अन्य, कम आम लेकिन उपयोगी चीजें करना भी संभव है, कुछ मैं यहां दिखाऊंगा:

केवल तभी निष्पादित करना जब फ़ाइल एक मॉड्यूल या पैकेज है:

if __name__ != '__main__':
    # Do some useful things 

एक शर्त चलाना अगर फ़ाइल मुख्य है और दूसरा यदि यह नहीं है:

if __name__ == '__main__':
    # Execute something
else:
    # Do some useful things

आप पुस्तकालयों के विस्तृत उपयोग के बिना संकुल और मॉड्यूल पर चलने योग्य सहायता कार्यों / उपयोगिता प्रदान करने के लिए इसका भी उपयोग कर सकते हैं।

यह मुख्य स्क्रिप्ट के रूप में कमांड लाइन से मॉड्यूल को चलाने की अनुमति देता है, जो भी बहुत उपयोगी हो सकता है।




क्या होता है if __name__ == "__main__": क्या करें?

__name__ एक वैश्विक चर है (पायथन में, वैश्विक वास्तव में मॉड्यूल स्तर पर है ) जो सभी नामस्थानों में मौजूद है। यह आमतौर पर मॉड्यूल का नाम होता है (एक str प्रकार के रूप में)।

हालांकि, एकमात्र विशेष मामला, हालांकि, जो भी पायथन प्रक्रिया आप चलाते हैं, जैसा कि mycode.py में है:

python mycode.py

अन्यथा अज्ञात वैश्विक नामस्थान को '__main__' के मान को '__main__' असाइन किया गया है।

इस प्रकार, अंतिम लाइनों सहित

if __name__ == '__main__':
    main()
  • अपनी mycode.py स्क्रिप्ट के अंत में,
  • जब यह प्राथमिक, एंट्री-पॉइंट मॉड्यूल होता है जो पाइथन प्रक्रिया द्वारा चलाया जाता है,

आपके स्क्रिप्ट के विशिष्ट रूप से परिभाषित main फ़ंक्शन को चलाने के लिए कारण बन जाएगा।

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

import mycode
# ... any amount of other code
mycode.main()



आप फ़ाइल को एक स्क्रिप्ट के साथ-साथ एक आयात योग्य मॉड्यूल के रूप में उपयोग करने योग्य बना सकते हैं।

fibo.py (fibo नामक एक मॉड्यूल)

# Other modules can IMPORT this MODULE to use the function fib
def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()

# This allows the file to be used as a SCRIPT
if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

संदर्भ: https://docs.python.org/3.5/tutorial/modules.html




सवाल में कोड के यांत्रिकी पर बहुत सारे अलग-अलग होते हैं, "कैसे", लेकिन मेरे लिए कोई भी तब तक समझ में नहीं आया जब तक कि मैं "क्यों" समझ नहीं पाता। यह नए प्रोग्रामर के लिए विशेष रूप से सहायक होना चाहिए।

फ़ाइल "ab.py" लें:

def a():
    print('A function in ab file');
a()

और दूसरी फ़ाइल "xy.py":

import ab
def main():
    print('main function: this is where the action is')
def x(): 
    print ('peripheral task: might be useful in other projects')
x()
if __name__ == "__main__":
    main()

वास्तव में यह कोड क्या कर रहा है?

जब आप xy.py निष्पादित xy.py , तो आप import ab । आयात विवरण आयात पर तुरंत मॉड्यूल चलाता है, इसलिए ab के संचालन xy के शेष से पहले निष्पादित हो जाते हैं। एक बार ab साथ समाप्त हो गया, यह xy साथ जारी है।

दुभाषिया ट्रैक रखता है कि कौन सी स्क्रिप्ट __name__ साथ चल रही हैं। जब आप एक स्क्रिप्ट चलाते हैं - इससे कोई फर्क नहीं पड़ता कि आपने इसका नाम क्या रखा है - दुभाषिया इसे "__main__" कहता है, जिससे इसे मास्टर या 'होम' स्क्रिप्ट बना दिया जाता है जो बाहरी स्क्रिप्ट चलाने के बाद वापस आ जाता है। इस "__main__" स्क्रिप्ट से बुलाई गई किसी अन्य स्क्रिप्ट को इसके फ़ाइल नाम को __name__ (उदाहरण के लिए, __name__ == "ab.py" ) के रूप में असाइन किया गया है। इसलिए, if __name__ == "__main__": पंक्ति है if __name__ == "__main__": यह निर्धारित करने के लिए दुभाषिया का परीक्षण है कि क्या यह 'होम' स्क्रिप्ट को प्रारंभ / निष्पादित कर रहा है जिसे प्रारंभ में निष्पादित किया गया था, या यदि यह अस्थायी रूप से किसी अन्य (बाहरी) स्क्रिप्ट में देख रहा है। यह प्रोग्रामर लचीलापन देता है ताकि स्क्रिप्ट को अलग-अलग व्यवहार किया जा सके, अगर इसे सीधे बनाम सीधे बना दिया जाता है।

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

  • 'होम' फ़ाइल के रूप में xy.py खोलें; इसे __name__ चर में "__main__" __name__ हैं।
  • आयात करें और __name__ == "ab.py" साथ फ़ाइल खोलें।
  • ओह, एक समारोह। मैं याद रखूँगा कि।
  • ठीक है, a() समारोह a() ; मैंने अभी सीखा है। मुद्रण ' एबी फाइल में एक समारोह '।
  • फाइल समाप्त; वापस "__main__" !
  • ओह, एक समारोह। मैं याद रखूँगा कि।
  • और एक।
  • फंक्शन x() ; ठीक है, मुद्रण ' परिधीय कार्य: अन्य परियोजनाओं में उपयोगी हो सकता है '।
  • यह क्या है? एक if कथन। खैर, स्थिति पूरी हो गई है (परिवर्तनीय __name__ को "__main__" सेट किया गया है), इसलिए मैं main() फ़ंक्शन दर्ज करूंगा और प्रिंट ' मुख्य फ़ंक्शन: यह वह जगह है जहां कार्रवाई है '।

नीचे दो पंक्तियों का अर्थ है: "यदि यह main या 'होम' स्क्रिप्ट है, तो main() " नामक फ़ंक्शन निष्पादित करें। यही कारण है कि आप एक def main(): शीर्ष पर ब्लॉक देखेंगे, जिसमें स्क्रिप्ट की कार्यक्षमता का मुख्य प्रवाह शामिल है।

इसे क्यों लागू करें?

याद रखें कि मैंने पहले आयात बयान के बारे में क्या कहा था? जब आप एक मॉड्यूल आयात करते हैं तो यह केवल 'पहचान' नहीं करता है और आगे के निर्देशों की प्रतीक्षा करता है - यह वास्तव में स्क्रिप्ट के भीतर मौजूद सभी निष्पादन योग्य संचालन चलाता है। इसलिए, अपनी स्क्रिप्ट के मांस को main() फ़ंक्शन में प्रभावी रूप से संगरोधित करते हुए इसे अलग-अलग में डाल दें ताकि इसे किसी अन्य स्क्रिप्ट द्वारा आयात किए जाने पर तुरंत नहीं चलाया जा सके।

दोबारा, अपवाद होंगे, लेकिन आम अभ्यास यह है कि main() को आमतौर पर बाहरी रूप से नहीं कहा जाता है। तो आप एक और बात सोच रहे होंगे: अगर हम main() नहीं कह रहे हैं, तो हम स्क्रिप्ट को क्यों बुला रहे हैं? ऐसा इसलिए है क्योंकि कई लोग अपनी स्क्रिप्ट को स्टैंडअलोन फ़ंक्शंस के साथ बनाते हैं जिन्हें फ़ाइल में शेष कोड से स्वतंत्र चलाने के लिए बनाया जाता है। बाद में उन्हें स्क्रिप्ट के शरीर में कहीं और कहा जाता है। जो मुझे इस पर लाता है:

लेकिन कोड इसके बिना काम करता है

हाँ य़ह सही हैं। इन अलग-अलग कार्यों को एक इन-लाइन स्क्रिप्ट से कहा जा सकता है जो main() फ़ंक्शन के अंदर नहीं है। यदि आप आदी हैं (जैसा कि मैं, प्रोग्रामिंग के शुरुआती सीखने के चरणों में) ऑनलाइन स्क्रिप्ट बनाने के लिए जो आपको वही करता है, और यदि आपको कभी भी उस ऑपरेशन की आवश्यकता होती है तो आप इसे फिर से समझने की कोशिश करेंगे .. ठीक है, आप इस तरह की आंतरिक संरचना के लिए अपने कोड में उपयोग नहीं कर रहे हैं, क्योंकि इसे बनाने के लिए और अधिक जटिल है और यह पढ़ने के लिए सहज नहीं है। लेकिन यह एक ऐसी स्क्रिप्ट है जो संभवतः अपने कार्यों को बाहरी रूप से नहीं कह सकती है, क्योंकि अगर ऐसा होता है तो यह तुरंत वैरिएबल की गणना करना और असाइन करना शुरू कर देगा। और संभावना है कि यदि आप किसी फ़ंक्शन का पुन: उपयोग करने का प्रयास कर रहे हैं, तो आपकी नई स्क्रिप्ट पुराने से पर्याप्त रूप से पर्याप्त है कि विरोधाभासी चर होंगे।

स्वतंत्र कार्यों को विभाजित करने में, आपको अपने पिछले काम को दूसरी स्क्रिप्ट में कॉल करके पुनः उपयोग करने की क्षमता प्राप्त होती है। उदाहरण के लिए, "example.py" "xy.py" आयात कर सकता है और "xy.py" से 'x' फ़ंक्शन का उपयोग कर x() कॉल कर सकता है। (हो सकता है कि यह किसी दिए गए टेक्स्ट स्ट्रिंग के तीसरे शब्द को कैपिटल कर रहा हो; संख्याओं की सूची से एक संख्यात्मक सरणी बनाना और उन्हें स्क्वायर करना; या 3 डी सतह को रोकना। संभावनाएं असीमित हैं।)

[एक तरफ के रूप में, इस धागे में @kindall द्वारा एक जवाब है जिसने अंत में मुझे समझने में मदद की - क्यों, क्यों नहीं। दुर्भाग्य से इसे इस के डुप्लिकेट के रूप में चिह्नित किया गया है, जो मुझे लगता है कि एक गलती है।]




अगर नाम == ' मुख्य ':

हम देखते हैं कि __name__ == '__main__' : अक्सर।

यह जांचता है कि क्या एक मॉड्यूल आयात किया जा रहा है या नहीं।

दूसरे शब्दों में, if ब्लॉक को सीधे चलाया जाता है तो कोड ब्लॉक के भीतर कोड निष्पादित किया जाएगा। यहां directly not imported

आइए देखते हैं कि यह एक साधारण कोड का उपयोग करके क्या करता है जो मोड के नाम को प्रिंट करता है:

# test.py
def test():
   print('test module name=%s' %(__name__))

if __name__ == '__main__':
   print('call test()')
   test()

अगर हम सीधे python test.py माध्यम से कोड चलाते हैं, तो मॉड्यूल का नाम __main__ :

call test()
test module name=__main__



if __name__ == "__main__": मूल रूप से शीर्ष-स्तरीय स्क्रिप्ट वातावरण है, तो यह दुभाषिया निर्दिष्ट करता है कि ('मुझे पहले निष्पादित करने की सर्वोच्च प्राथमिकता है')।

'__main__' उस दायरे का नाम है जिसमें शीर्ष-स्तरीय कोड निष्पादित होता है। मानक इनपुट, एक स्क्रिप्ट, या एक इंटरैक्टिव प्रॉम्प्ट से पढ़ने पर एक मॉड्यूल का __name__ '__main__' बराबर सेट होता है।

if __name__ == "__main__":
    # execute only if run as a script
    main()



if __name__ == "__main__":
    main()

जांचता है कि क्या __name__ स्क्रिप्ट का __name__ विशेषता "__main__" । दूसरे शब्दों में, यदि प्रोग्राम स्वयं निष्पादित किया गया है, तो विशेषता __main__ होगी, इसलिए प्रोग्राम निष्पादित किया जाएगा (इस मामले में main() फ़ंक्शन)।

हालांकि, यदि आपकी पाइथन स्क्रिप्ट का उपयोग मॉड्यूल द्वारा किया जाता है, if कथन के बाहर कोई भी कोड निष्पादित किया जाएगा, तो if \__name__ == "\__main__" का उपयोग यह जांचने के लिए किया जाता है कि प्रोग्राम को मॉड्यूल के रूप में उपयोग किया जाता है या नहीं, और इसलिए यह तय करता है कि कोड को चलाने के लिए।




सिस्टम (पायथन दुभाषिया) स्रोत फ़ाइलों (मॉड्यूल) के लिए प्रदान करता है कि कई चर हैं। जब भी आप चाहें अपने मूल्य प्राप्त कर सकते हैं, तो, हम __name__ चर / विशेषता पर ध्यान केंद्रित करते हैं:

जब पायथन एक स्रोत कोड फ़ाइल लोड करता है, तो इसमें पाए गए सभी कोड निष्पादित होते हैं। (ध्यान दें कि यह फ़ाइल में परिभाषित सभी विधियों और कार्यों को कॉल नहीं करता है, लेकिन यह उन्हें परिभाषित करता है।)

दुभाषिया स्रोत कोड फ़ाइल निष्पादित करने से पहले, यह उस फ़ाइल के लिए कुछ विशेष चर परिभाषित करता है; __name__ उन विशेष चरों में से एक है जो पायथन स्वचालित रूप से प्रत्येक स्रोत कोड फ़ाइल के लिए परिभाषित करता है।

यदि पाइथन इस स्रोत कोड फ़ाइल को मुख्य प्रोग्राम (यानी आपके द्वारा चलाए जाने वाली फ़ाइल) के रूप में लोड कर रहा है, तो यह इस फ़ाइल के लिए "__main__" मान रखने के लिए विशेष __name__ चर सेट करता है।

यदि यह किसी अन्य मॉड्यूल से आयात किया जा रहा है, तो __name__ उस मॉड्यूल के नाम पर सेट हो जाएगा।

तो, आपके उदाहरण में भाग में:

if __name__ == "__main__":
   lock = thread.allocate_lock()
   thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
   thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))

मतलब है कि कोड ब्लॉक:

lock = thread.allocate_lock()
thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))

जब आप मॉड्यूल को सीधे चलाते हैं तो केवल तभी निष्पादित किया जाएगा; कोड ब्लॉक निष्पादित नहीं होगा यदि कोई अन्य मॉड्यूल इसे कॉल / आयात कर रहा है क्योंकि __name__ का मान उस विशेष उदाहरण में " मुख्य " के बराबर नहीं होगा।

उम्मीद है कि यह मदद करता है।




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

if __name__ == '__main__':
    # Do something appropriate here, like calling a
    # main() function defined elsewhere in this module.
    main()
else:
    # Do nothing. This module has been imported by another
    # module that wants to make use of the functions,
    # classes and other useful bits it has defined.



if __name__ == "__main__": तो क्या करें?

मूल बातें की रूपरेखा के लिए:

  • वैश्विक चर, __name__ , मॉड्यूल में जो आपके प्रोग्राम में प्रवेश बिंदु है, '__main__' । अन्यथा, यह वह नाम है जिसे आप मॉड्यूल आयात करते हैं।

  • इसलिए, if ब्लॉक के तहत कोड केवल तभी चलाया जाएगा जब मॉड्यूल आपके प्रोग्राम में प्रवेश बिंदु है।

  • यह आयात पर नीचे कोड ब्लॉक निष्पादित किए बिना, अन्य मॉड्यूल द्वारा मॉड्यूल में कोड आयात करने की अनुमति देता है।

हमें यह क्यों चाहिये?

अपने कोड का विकास और परीक्षण

मान लें कि आप मॉड्यूल के रूप में उपयोग किए जाने के लिए डिज़ाइन की गई एक पायथन लिपि लिख रहे हैं:

def do_important():
    """This function does something very important"""

आप फ़ंक्शन के इस कॉल को नीचे जोड़कर मॉड्यूल का परीक्षण कर सकते हैं :

do_important()

और इसे चलाने (कमांड प्रॉम्प्ट पर) कुछ ऐसा करने के साथ:

~$ python important.py

समस्या

हालांकि, यदि आप मॉड्यूल को किसी अन्य स्क्रिप्ट में आयात करना चाहते हैं:

import important

आयात पर, do_important फ़ंक्शन को कॉल किया जाएगा, इसलिए आप शायद नीचे अपने फ़ंक्शन कॉल, do_important() टिप्पणी करेंगे।

# do_important() # I must remember to uncomment to execute this!

और फिर आपको याद रखना होगा कि आपने अपनी टेस्ट फ़ंक्शन कॉल पर टिप्पणी की है या नहीं। और यह अतिरिक्त जटिलता का अर्थ यह होगा कि आप भूलने की संभावना रखते हैं, जिससे आपकी विकास प्रक्रिया अधिक परेशानी हो जाती है।

एक बेहतर तरीका

__name__ परिवर्तनीय बिंदु नामस्थान पर जहां भी पाइथन दुभाषिया इस समय होता है।

एक आयातित मॉड्यूल के अंदर, यह उस मॉड्यूल का नाम है।

लेकिन प्राथमिक मॉड्यूल (या एक इंटरैक्टिव पायथन सत्र, यानी दुभाषिया के पढ़ने, इवल, प्रिंट लूप, या आरईपीएल) के अंदर आप अपने "__main__" से सब कुछ चला रहे हैं।

तो यदि आप निष्पादन से पहले जांचते हैं:

if __name__ == "__main__":
    do_important()

उपर्युक्त के साथ, आपका कोड केवल तब लागू होगा जब आप इसे प्राथमिक मॉड्यूल के रूप में चला रहे हों (या जानबूझकर इसे किसी अन्य स्क्रिप्ट से कॉल करें)।

एक बेहतर तरीका भी

हालांकि, इस पर सुधार करने के लिए एक पाइथोनिक तरीका है।

क्या होगा यदि हम मॉड्यूल के बाहर से इस व्यवसाय प्रक्रिया को चलाने के लिए चाहते हैं?

अगर हम कोड डालते हैं तो हम व्यायाम करना चाहते हैं क्योंकि हम इस तरह के एक समारोह में विकसित और परीक्षण करते हैं और फिर तुरंत '__main__' लिए हमारी जांच करते हैं:

def main():
    """business logic for when running this module as the primary one!"""
    setup()
    foo = do_important()
    bar = do_even_more_important(foo)
    for baz in bar:
        do_super_important(baz)
    teardown()

# Here's our payoff idiom!
if __name__ == '__main__':
    main()

अब हमारे मॉड्यूल के अंत के लिए एक अंतिम कार्य है जो हम मॉड्यूल को प्राथमिक मॉड्यूल के रूप में चलाने पर चलाएंगे।

यह मॉड्यूल और उसके कार्यों और वर्गों को main कार्य चलाने के बिना अन्य स्क्रिप्ट में आयात करने की अनुमति देगा, और एक अलग '__main__' मॉड्यूल से चलते समय मॉड्यूल (और इसके कार्यों और वर्गों) को कॉल करने की अनुमति भी देगा, यानी

import important
important.main()

यह मुहावरे __main__ मॉड्यूल की व्याख्या में पाइथन दस्तावेज़ में भी पाया जा सकता है। वह पाठ कहता है:

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

if __name__ == '__main__':
    main()



Related