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




namespaces python-module (18)

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

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__ , मॉड्यूल में जो आपके प्रोग्राम में प्रवेश बिंदु है, '__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()

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

हम देखते हैं कि __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__

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

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

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

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

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


जब आप पाइथन को इंटरैक्टिव रूप से चलाते हैं तो स्थानीय __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.

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

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" बराबर होता है।


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

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

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


बस रखें, __name__ प्रत्येक स्क्रिप्ट के लिए परिभाषित एक चर है जो परिभाषित करता है कि स्क्रिप्ट मुख्य मॉड्यूल के रूप में चल रही है या इसे आयातित मॉड्यूल के रूप में चलाया जा रहा है।

तो अगर हमारे पास दो स्क्रिप्ट हैं;

#script1.py
print "Script 1's name: {}".format(__name__)

तथा

#script2.py
import script1
print "Script 2's name: {}".format(__name__)

स्क्रिप्ट 1 निष्पादित करने से आउटपुट है

Script 1's name: __main__

और स्क्रिप्ट 2 निष्पादित करने से आउटपुट है:

Script1's name is script1
Script 2's name: __main__

जैसा कि आप देख सकते हैं, __name__ हमें बताता है कि कौन सा कोड 'मुख्य' मॉड्यूल है। यह बहुत अच्छा है, क्योंकि आप केवल कोड लिख सकते हैं और सी / सी ++ जैसे संरचनात्मक मुद्दों के बारे में चिंता करने की ज़रूरत नहीं है, जहां, यदि कोई फ़ाइल 'मुख्य' फ़ंक्शन लागू नहीं करती है तो इसे निष्पादन योग्य के रूप में संकलित नहीं किया जा सकता है और यदि ऐसा होता है, इसे तब पुस्तकालय के रूप में उपयोग नहीं किया जा सकता है।

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

तीर आयात लिंक हैं। पिछले मॉड्यूल कोड को शामिल करने की कोशिश करने वाले प्रत्येक मॉड्यूल के लिए छह फाइलें हैं (नौ, कार्यान्वयन फाइलों की गिनती) और पांच लिंक। इससे सी कोड में अन्य कोड शामिल करना मुश्किल हो जाता है जब तक कि इसे विशेष रूप से लाइब्रेरी के रूप में संकलित नहीं किया जाता है। अब इसे पायथन के लिए चित्रित करें:

आप एक मॉड्यूल लिखते हैं, और यदि कोई आपके कोड का उपयोग करना चाहता है तो वे इसे आयात करते हैं और __name__ चर लाइब्रेरी भाग से प्रोग्राम के निष्पादन योग्य हिस्से को अलग करने में मदद कर सकते हैं।


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

यह कई तरीकों से लिखा जा सकता है। एक और है:

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

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


विचार करें:

if __name__ == "__main__":
    main()

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

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


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

फ़ाइल "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() कॉल कर सकता है। (हो सकता है कि यह किसी दिए गए टेक्स्ट स्ट्रिंग के तीसरे शब्द को कैपिटल कर रहा हो; संख्याओं की सूची से एक NumPy सरणी बनाना और उन्हें squaring करना; या 3 डी सतह को अलग करना। संभावनाएं असीमित हैं।)

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


सिस्टम (पायथन दुभाषिया) स्रोत फ़ाइलों (मॉड्यूल) के लिए प्रदान करता है कि कई चर हैं। जब भी आप चाहें अपने मूल्य प्राप्त कर सकते हैं, तो, हम __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__ का मान उस विशेष उदाहरण में " मुख्य " के बराबर नहीं होगा।

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


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

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

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

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


यदि यह .py फ़ाइल अन्य .py फ़ाइलों द्वारा आयात की जाती है, तो "अगर कथन" के तहत कोड निष्पादित नहीं किया जाएगा।

यदि यह .py python this_py.pyशैल के नीचे चलाया जाता है , या विंडोज़ में डबल क्लिक किया जाता है। "अगर कथन" के तहत कोड निष्पादित किया जाएगा।

यह आमतौर पर परीक्षण के लिए लिखा जाता है।


हाल ही में, मैं पाइथन (गहरी शिक्षा) में एक कक्षा बनाने और मेरी समझ के लिए और उपरोक्त शीर्ष सूचीबद्ध स्पष्टीकरण के समझौते के दौरान इस पर आया, मैं विस्तार से बताऊंगा

__name__=="__main__"

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

__name__=="__main__"

xxx = CLASS_NAME ()

xxx.create_data ()

इसका मतलब है कि अगर हम .py फ़ाइल को कॉल करते हैं, तो यह केवल डेटा बनाएगा और अन्य क्लास फ़ंक्शंस को संसाधित नहीं करेगा। अन्य वर्ग कार्यों (डेटा लोडिंग) को अन्य कक्षाओं द्वारा भी आयात किया जा सकता है।


मैं इस पृष्ठ पर पूरे उत्तर में बहुत कुछ पढ़ रहा हूं। मैं कहूंगा, अगर आप चीज को जानते हैं, तो निश्चित रूप से आप उन उत्तरों को समझेंगे, अन्यथा, आप अभी भी उलझन में हैं।

संक्षिप्त होने के लिए, आपको कई बिंदुओं को जानने की आवश्यकता है:

  1. import a कार्रवाई वास्तव में उन सभी को चलाती है जिन्हें "ए" में चलाया जा सकता है

  2. बिंदु 1 के कारण, आप इसे आयात करते समय "ए" में सबकुछ चलाने के लिए नहीं चाहते हैं

  3. बिंदु 2 में समस्या को हल करने के लिए, पायथन आपको एक शर्त जांच करने की अनुमति देता है

  4. __name__सभी .py मॉड्यूल में एक अंतर्निहित चर है; जब a.py आयात किया जाता है, तो __name__a.py मॉड्यूल का मान इसके फ़ाइल नाम "ए" पर सेट होता है; जब a.py "python a.py" का उपयोग करके सीधे चलाया जाता है, जिसका अर्थ है कि a.py प्रविष्टि बिंदु है, तो __name__a.py मॉड्यूल का मान स्ट्रिंग पर सेट होता है__main__

  5. तंत्र के आधार पर पाइथन __name__प्रत्येक मॉड्यूल के लिए चर सेट करता है , क्या आप जानते हैं कि बिंदु 3 कैसे प्राप्त करें? जवाब काफी आसान है, है ना? अगर एक शर्त रखें if __name__ == "__main__": ...:; आप __name__ == "a"अपनी कार्यात्मक आवश्यकता के आधार पर भी डाल सकते हैं

महत्वपूर्ण बात यह है कि पाइथन विशेष है 4 बिंदु है! बाकी सिर्फ मूल तर्क है।


यह उत्तर पाइथन सीखने वाले जावा प्रोग्रामर के लिए है। प्रत्येक जावा फ़ाइल में आमतौर पर एक सार्वजनिक वर्ग होता है। आप उस वर्ग का दो तरीकों से उपयोग कर सकते हैं:

  1. कक्षा को अन्य फाइलों से कॉल करें। आपको इसे कॉलिंग प्रोग्राम में आयात करना होगा।

  2. परीक्षण उद्देश्यों के लिए अकेले कक्षा स्टैंड चलाएं।

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





idioms