सवाल क्या होता है यदि __name__ == "__main__": क्या करें?


इससे क्या होता है 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))

4149
2018-01-07 04:11


मूल




जवाब:


जब पाइथन दुभाषिया एक स्रोत फ़ाइल पढ़ता है, तो इसमें पाए गए सभी कोड निष्पादित होते हैं।

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

अपनी स्क्रिप्ट के मामले में, मान लीजिए कि यह मुख्य कार्य के रूप में निष्पादित है, उदा। तुमने कुछ कहा

python threading_example.py

कमांड लाइन पर। विशेष चर सेट अप करने के बाद, यह निष्पादित करेगा import बयान और उन मॉड्यूल लोड करें। इसके बाद इसका मूल्यांकन किया जाएगा def ब्लॉक, एक फंक्शन ऑब्जेक्ट बनाना और एक चर बनाने वाला बनाना myfunction जो फंक्शन ऑब्जेक्ट को इंगित करता है। फिर यह पढ़ा जाएगा if बयान और देखें कि __name__ बराबर करता है "__main__", इसलिए यह वहां दिखाए गए ब्लॉक को निष्पादित करेगा।

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

देख यह पन्ना कुछ अतिरिक्त विवरण के लिए।


4421
2018-01-07 04:26



नोट: यदि आप फ़ंक्शन परिभाषाओं से पहले कोड डालते हैं तो यह मुख्य से पहले निष्पादित होगा। print("This code executes before main.") def functionA(): print("Function A") def functionB(): print("Function B") if __name__ == '__main__': functionA() functionB()  इस कोड में परिणाम: This code executes before main. Function A Function B - Stainsor


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

python myscript.py

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

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

if __name__ == "__main__":
    ...

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

# 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

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


1415
2018-01-07 04:28



शानदार स्पष्टीकरण। - Poles


के लिए सबसे सरल व्याख्या __name__ परिवर्तनीय (imho) निम्नलिखित है:

निम्नलिखित फाइलें बनाएं।

# a.py
import b

तथा

# b.py
print "Hello World from %s!" % __name__

if __name__ == '__main__':
    print "Hello World again from %s!" % __name__

उन्हें चलाने से आपको यह आउटपुट मिल जाएगा:

$ python a.py
Hello World from b!

जैसा कि आप देख सकते हैं, जब एक मॉड्यूल आयात किया जाता है, पायथन सेट करता है globals()['__name__'] मॉड्यूल के नाम पर इस मॉड्यूल में।

$ python b.py
Hello World from __main__!
Hello World again from __main__!

जैसा कि आप देख सकते हैं, जब एक फ़ाइल निष्पादित की जाती है, पायथन सेट करता है globals()['__name__'] इस फाइल में करने के लिए "__main__"


562
2018-01-07 11:35





इससे क्या होता है 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__ मॉड्यूल। वह पाठ कहता है:

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

if __name__ == '__main__':
    main()

413
2017-11-23 04:38





if __name__ == "__main__"वह हिस्सा है जो स्क्रिप्ट चलाता है जब कमांड लाइन (कमांड) कमांड लाइन जैसे कमांड का उपयोग करता है python myscript.py


92
2018-01-07 04:14





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

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

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

python mycode.py

अन्यथा अज्ञात वैश्विक नामस्थान का मूल्य असाइन किया गया है '__main__' इसके लिए __name__

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

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

आपकी स्क्रिप्ट को विशिष्ट रूप से परिभाषित कर देगा main चलाने के लिए समारोह।

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

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

57
2017-10-14 20:22





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

फ़ाइल "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, आप import ab। आयात विवरण आयात पर तुरंत मॉड्यूल चलाता है, इसलिए abके संचालन शेष के पहले निष्पादित हो जाते हैं xyके। एक बार समाप्त हो गया ab, यह जारी है xy

दुभाषिया ट्रैक रखता है कि किस स्क्रिप्ट के साथ चल रहे हैं __name__। जब आप एक स्क्रिप्ट चलाते हैं - इससे कोई फ़र्क नहीं पड़ता कि आपने इसका नाम क्या रखा है - दुभाषिया इसे कॉल करता है "__main__", इसे मास्टर या 'होम' स्क्रिप्ट बनाते हैं जो बाहरी स्क्रिप्ट चलाने के बाद वापस आ जाता है।

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

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

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

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

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

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

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

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

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

लेकिन यह एक ऐसी स्क्रिप्ट है जो संभवतः अपने कार्यों को बाहरी रूप से नहीं कह सकती है, क्योंकि अगर ऐसा होता है तो यह तुरंत वैरिएबल की गणना करना और असाइन करना शुरू कर देगा। और संभावना है कि यदि आप किसी फ़ंक्शन का पुन: उपयोग करने का प्रयास कर रहे हैं, तो आपकी नई स्क्रिप्ट पुराने से पर्याप्त रूप से पर्याप्त है कि विरोधाभासी चर होंगे।

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

(स्वगत कथन के रूप में, यह प्रश्न @kindall द्वारा एक उत्तर दिया गया है जिसने अंत में मुझे समझने में मदद की - क्यों, क्यों नहीं। दुर्भाग्यवश इसे एक डुप्लिकेट के रूप में चिह्नित किया गया है यह वाला, जो मुझे लगता है कि एक गलती है।)


47
2017-09-29 04:33





जब हमारे मॉड्यूल में कुछ बयान होते हैं (M.py) जब हम मुख्य (आयात नहीं किए जाते) के रूप में चलेंगे, तो हम इसे निष्पादित करना चाहते हैं, हम इसके तहत उन बयान (परीक्षण-मामले, प्रिंट स्टेटमेंट) रख सकते हैं ifब्लॉक।

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

संक्षेप में, इसे इस्तेमाल करो 'if __name__ == "main" 'मॉड्यूल आयात होने पर (निश्चित) कोड को चलाने से रोकने के लिए ब्लॉक करें।


39
2018-04-03 14:09





आइए उत्तर को एक अधिक अमूर्त तरीके से देखें:

मान लें कि हमारे पास यह कोड x.py में है:

...
<Block A>
if __name__ == '__main__':
    <Block B>
...

जब हम "x.py" चला रहे हैं तो ब्लॉक ए और बी चलाए जाते हैं।

लेकिन जब हम एक और मॉड्यूल चला रहे हैं तो ब्लॉक ए (और नहीं बी) चलाया जाता है, उदाहरण के लिए, "x.py" जिसमें xy आयात किया जाता है और कोड वहां से चलाया जाता है (जैसे कि "x.py" में कोई फ़ंक्शन होता है y.py से कहा जाता है)।


32
2018-01-20 17:48