python - ماذا يفعل إذا__name__== "__main__": هل؟




namespaces python-module (18)

ماذا 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__ هو متغير عام (في Python ، يعني عالمي بالفعل على مستوى الوحدة النمطية ) موجود في كافة مساحات الأسماء. هو عادة اسم الوحدة (كنوع str ).

كحالة خاصة فقط ، ومع ذلك ، في أي عملية بايثون تقوم بتشغيل ، كما هو الحال في mycode.py:

python mycode.py

يتم تعيين مساحة الاسم العمومية المجهولة بخلاف ذلك إلى قيمة '__main__' إلى __name__ الخاصة __name__ .

وبالتالي ، بما في ذلك الخطوط النهائية

if __name__ == '__main__':
    main()
  • في نهاية البرنامج النصي mycode.py ،
  • عندما تكون الوحدة الأساسية ، نقطة البداية التي يتم تشغيلها بواسطة عملية بايثون ،

سيتسبب في تشغيل الوظيفة الأساسية المحددة بشكل فريد لنص البرنامج النصي الخاص بك.

فائدة أخرى لاستخدام هذا البناء: يمكنك أيضًا استيراد شفرتك كوحدة نمطية في نص برمجي آخر ثم تشغيل الوظيفة الرئيسية إذا قرر برنامجك ووقته:

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

ماذا if __name__ == "__main__": هل؟

لتوضيح الأساسيات:

  • المتغير الشامل ، __name__ ، في الوحدة النمطية التي هي نقطة الدخول إلى البرنامج الخاص بك ، هو '__main__' . وإلا ، فهو الاسم الذي تقوم باستيراد الوحدة بواسطته.

  • لذلك ، سيتم تشغيل التعليمة البرمجية ضمن كتلة if فقط إذا كانت الوحدة هي نقطة الدخول إلى البرنامج.

  • يسمح هذا الرمز في الوحدة النمطية يمكن استيرادها بواسطة الوحدات النمطية الأخرى دون تنفيذ كتلة التعليمة البرمجية أسفل الاستيراد.

لماذا نحتاج هذا؟

تطوير واختبار الكود الخاص بك

لنفترض أنك كتبت نص برمجي Python مصمم ليتم استخدامه كوحدة نمطية:

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

يمكنك اختبار الوحدة عن طريق إضافة هذه الدعوة للوظيفة إلى الأسفل:

do_important()

وتشغيلها (في موجه الأوامر) بشيء مثل:

~$ python important.py

المشكلة

ومع ذلك ، إذا كنت ترغب في استيراد الوحدة النمطية إلى برنامج نصي آخر:

import important

عند الاستيراد ، do_important الدالة do_important ، لذلك ربما تقوم بالتعليق على استدعاء الوظيفة ، do_important() ، في الأسفل.

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

وبعد ذلك عليك أن تتذكر ما إذا كنت قد علقت على استدعاء وظيفة الاختبار أم لا. وهذا التعقيد الزائد يعني أنك من المحتمل أن تنسى ، مما يجعل عملية التطوير أكثر صعوبة.

طريقة أفضل

__name__ المتغير __name__ إلى مساحة الاسم حيثما يحدث مترجم Python في الوقت الحالي.

داخل الوحدة المستوردة ، هو اسم تلك الوحدة.

ولكن داخل الوحدة الأساسية (أو في دورة بيثون تفاعلية ، أي في القراءة ، أو التقيم ، أو حلقة الطباعة ، أو REPL) ، فإنك تقوم بتشغيل كل شيء من "__main__" .

لذلك إذا قمت بالتدقيق قبل تنفيذ:

if __name__ == "__main__":
    do_important()

مع ما سبق ، سيتم تنفيذ التعليمات البرمجية الخاصة بك فقط عند تشغيلها كوحدة نمطية أساسية (أو الاتصال عن قصد من برنامج نصي آخر).

طريقة أفضل

هناك طريقة بيثونيه لتحسين هذا ، على الرغم من.

ماذا لو أردنا تشغيل عملية الأعمال هذه من خارج الوحدة؟

إذا وضعنا الرمز الذي نرغب في ممارسته أثناء تطويره واختباره في وظيفة كهذه ومن ثم إجراء '__main__' لـ '__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__' ) ليتم استدعاؤها عند التشغيل من وحدة مختلفة '__main__' ، أي

import important
important.main()

يمكن أيضًا العثور على هذه __main__ في وثائق Python في شرح وحدة __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__

أبسط تفسير للمتغير __name__ ( __name__ ) هو ما يلي:

قم بإنشاء الملفات التالية.

# 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__" .


السبب ل

if __name__ == "__main__":
    main()

هو في المقام الأول لتجنب مشاكل قفل الاستيراد التي قد تنشأ من وجود كود مستورد مباشرة . تريد أن يتم تشغيل main() إذا تم استدعاء الملف الخاص بك مباشرةً (وهي حالة __name__ == "__main__" ) ، ولكن إذا تم استيراد الرمز الخاص بك ، فيجب على المستورد إدخال __name__ == "__main__" من الوحدة الرئيسية الحقيقية لتجنب مشاكل قفل الاستيراد.

التأثير الجانبي هو أنك تقوم بتسجيل الدخول تلقائيًا إلى منهجية تدعم نقاط دخول متعددة. يمكنك تشغيل البرنامج باستخدام main() كنقطة دخول ، ولكن لا يلزمك ذلك . بينما يتوقع setup.py main() ، فإن الأدوات الأخرى تستخدم نقاط إدخال بديلة. على سبيل المثال ، لتشغيل ملفك كعملية gunicorn ، تقوم بتعريف وظيفة app() بدلاً من main() . تمامًا كما هو الحال مع gunicorn ، تستورد gunicorn شفرتك بحيث لا تريد أن تفعل أي شيء أثناء استيرادها (بسبب مشكلة قفل الاستيراد).


ببساطة ، __name__ هو متغير يتم تعريفه لكل نص برمجي يحدد ما إذا كان البرنامج النصي يتم تشغيله كوحدة نمطية رئيسية أو يتم تشغيله كوحدة نمطية مستوردة.

إذا كان لدينا نصان

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

و

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

الإخراج من تنفيذ script1 هو

Script 1's name: __main__

والإخراج من تنفيذ script2 هو:

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

كما ترون ، يخبرنا __name__ ما هي الكود "الوحدة الرئيسية". هذا أمر رائع ، لأنه يمكنك كتابة التعليمات البرمجية فقط ولا داعي للقلق بشأن المشكلات الهيكلية مثل C / C ++ ، حيث ، إذا كان الملف لا ينفذ وظيفة "رئيسية" ، فلا يمكن تجميعه كملف قابل للتنفيذ ، وإذا كان كذلك ، لا يمكن استخدامه بعد ذلك كمكتبة.

لنفترض أنك كتبت نصًا برمجيًا في Python ينفّذ شيئًا رائعًا وتنفذ حمولة من الوظائف المفيدة لأغراض أخرى. إذا كنت ترغب في استخدامها ، if __name__ == "__main__": استيراد البرنامج النصي الخاص بك واستخدامه بدون تنفيذ البرنامج (نظراً لأن التعليمات البرمجية الخاصة بك لا تنفذ إلا في if __name__ == "__main__": context). في حين أنه في C / C ++ سيكون عليك تقسيم هذه الأجزاء إلى وحدة منفصلة تتضمن الملف. صورة الوضع أدناه ؛

الأسهم عبارة عن روابط استيراد. بالنسبة لثلاث وحدات ، كل محاولة لتضمين كود الوحدات السابقة هناك ستة ملفات (تسعة ، عد ملفات التنفيذ) وخمسة روابط. هذا يجعل من الصعب تضمين تعليمات برمجية أخرى في مشروع C إلا إذا تم تجميعها على وجه التحديد كمكتبة. الآن تصويرها لبيثون:

تكتب وحدة نمطية ، وإذا أراد شخص ما استخدام شفرتك ، فإنه يقوم فقط باستيرادها ، ويمكن أن يساعد المتغير __name__ على فصل الجزء القابل للتنفيذ من البرنامج من جزء المكتبة.


عند تشغيل Python بشكل تفاعلي يتم تعيين متغير __name__ المحلي إلى قيمة __main__ . وبالمثل ، عند تنفيذ وحدة Python من سطر الأوامر ، بدلاً من استيرادها إلى وحدة نمطية أخرى ، يتم تعيين السمة __name__ لها بقيمة __main__ ، بدلاً من الاسم الفعلي للوحدة النمطية. وبهذه الطريقة ، يمكن للوحدات أن تنظر إلى قيمة __name__ الخاصة بهم لتحديد كيفية استخدامهم ، سواءً كدعم لبرنامج آخر أو كتطبيق رئيسي تم تنفيذه من سطر الأوامر. وبالتالي ، فإن اللغة التالية شائعة جدًا في وحدات Python:

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.

عندما تكون هناك عبارات معينة في الوحدة النمطية لدينا ( M.py ) نريد أن يتم تنفيذها عند تشغيلها على أنها رئيسية (غير مستوردة) ، يمكننا وضع هذه البيانات (حالات الاختبار ، وكشوف الطباعة) تحت هذا في if الحظر.

كما افتراضياً (عند تشغيل الوحدة النمطية الرئيسية ، لا يتم استيرادها) يتم تعيين متغير __name__ إلى "__main__" ، وعندما يتم استيراده ، __name__ المتغير __name__ على قيمة مختلفة ، على الأرجح اسم الوحدة النمطية ( 'M' ). هذا مفيد في تشغيل تنويعات مختلفة لوحدات معا ، وفصل بيانات المدخلات والمخرجات الخاصة بهم وأيضاً إذا كانت هناك أي حالات اختبار.

باختصار ، استخدم هذا " if __name__ == "main" " لمنع تشغيل كود (معين) عند استيراد الوحدة.


عندما يقرأ مترجم Python ملف مصدر ، فإنه ينفذ جميع التعليمات البرمجية الموجودة فيه.

قبل تنفيذ الشفرة ، سيحدد بعض المتغيرات الخاصة. على سبيل المثال ، إذا كان مترجم Python يقوم بتشغيل تلك الوحدة (الملف المصدر) كبرنامج رئيسي ، فإنه يقوم بتعيين المتغير __name__ الخاص __name__ له قيمة "__main__" . في حالة استيراد هذا الملف من وحدة نمطية أخرى ، سيتم تعيين __name__ إلى اسم الوحدة النمطية.

في حالة البرنامج النصي الخاص بك ، دعونا نفترض أنه ينفذ كوظيفة رئيسية ، على سبيل المثال قلت شيئا مثل

python threading_example.py

على سطر الأوامر. بعد إعداد المتغيرات الخاصة ، سيتم تنفيذ جملة import وتحميل تلك الوحدات. سيقوم بعد ذلك بتقييم كتلة def ، وإنشاء كائن دالة وإنشاء متغير يسمى myfunction يشير إلى كائن الدالة. ستقرأ بعد ذلك العبارة if وسترى أن __name__ تساوي "__main__" ، لذا سيتم تنفيذ الكتلة الظاهرة هناك.

سبب واحد للقيام بذلك هو أن تكتب في بعض الأحيان وحدة (ملف .py ) حيث يمكن تنفيذها مباشرة. بدلا من ذلك ، يمكن أيضا استيرادها واستخدامها في وحدة أخرى. من خلال إجراء الفحص الرئيسي ، يمكنك تنفيذ هذا الرمز فقط عندما ترغب في تشغيل الوحدة كبرنامج وليس لديك عندما يقوم شخص ما فقط باستيراد الوحدة الخاصة بك والاتصال بوظائفك بنفسك.

انظر هذه الصفحة للحصول على بعض التفاصيل الإضافية.

ملاحظة (بواسطة Stainsor): إذا قمت بوضع التعليمة البرمجية قبل تعريفات الدالة ، فسوف يتم تنفيذها قبل main.

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

إذا كانت هذه الوحدة غير رئيسية ، فستحصل على:

This code executes before 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 ، تقوم import ab . تقوم جملة الاستيراد بتشغيل الوحدة فورًا عند الاستيراد ، بحيث يتم تنفيذ عمليات ab قبل باقي بيانات xy . بمجرد الانتهاء من ab ، فإنه يستمر مع xy .

يقوم المترجم بتتبع البرامج النصية التي تعمل مع __name__ . عندما تقوم بتشغيل برنامج نصي - بغض النظر عن ما "__main__" - يسميه المترجم "__main__" ، مما يجعله البرنامج الرئيسي أو البرنامج النصي "المنزل" الذي يتم إرجاعه بعد تشغيل برنامج نصي خارجي.

أي برنامج نصي آخر يسمى هذا البرنامج النصي "__main__" يتم تعيين اسم الملف الخاص به كـ __name__ (على سبيل المثال ، __name__ == "ab.py" ). ومن ثم ، فإن السطر if __name__ == "__main__": هو اختبار المترجم لتحديد ما إذا كان يقوم بتفسير / تحليل النص البرمجي "الرئيسي" الذي تم تنفيذه في البداية ، أو إذا كان ينظر بشكل مؤقت إلى برنامج نصي آخر (خارجي). وهذا يعطي المرونة للمبرمج لجعل البرنامج النصي يتصرف بشكل مختلف إذا تم تنفيذه مباشرة مقابل.

دعونا ننتقل إلى الشفرة المذكورة أعلاه لفهم ما يحدث ، مع التركيز أولاً على الأسطر غير الثابتة والترتيب الذي تظهر به في النصوص. تذكر أن وظيفة - أو كتل - لا تفعل أي شيء من تلقاء نفسها حتى يتم استدعاؤها. ما قد يقوله المترجم إذا تمتم إلى نفسه:

  • افتح xy.py كملف "home" ؛ نسميها "__main__" في المتغير __name__ .
  • استيراد وفتح الملف مع __name__ == "ab.py" .
  • أوه ، وظيفة. سوف اتذكر ذلك.
  • حسنا ، وظيفة a() ؛ أنا تعلمت ذلك للتو. الطباعة " وظيفة في ملف ab ".
  • نهاية الملف؛ العودة إلى "__main__" !
  • أوه ، وظيفة. سوف اتذكر ذلك.
  • واحدة أخرى.
  • وظيفة x() ؛ حسنا ، طباعة " مهمة طرفية: قد تكون مفيدة في مشاريع أخرى ".
  • ما هذا؟ بيان if . حسنًا ، تم استيفاء الشرط (تم تعيين المتغير __name__ إلى "__main__" ) ، لذلك سأقوم بإدخال الوظيفة main() وطباعة " الوظيفة الرئيسية: هذا هو المكان الذي يكون فيه الإجراء ".

تعني السطرين "__main__" : "إذا كان هذا هو البرنامج النصي "__main__" أو" home "، "__main__" تنفيذ الدالة المسماة main() ". ولهذا السبب سترى def main(): حظر أعلى ، والذي يحتوي على التدفق الرئيسي لوظيفة البرنامج النصي.

لماذا تنفيذ هذا؟

تذكر ما قلته في وقت سابق عن بيانات الاستيراد؟ عندما تقوم باستيراد وحدة ، فإنها لا "تتعرف" عليها فقط وتنتظر المزيد من التعليمات - فهي في الواقع تدير جميع العمليات القابلة للتنفيذ الموجودة داخل البرنامج النصي. لذا ، فإن وضع اللحم الخاص بك في الوظيفة main() عزله بشكل فعال ، ووضعه في عزلة بحيث لا يتم تشغيله فورًا عند استيراده بواسطة نص برمجي آخر.

مرة أخرى ، سيكون هناك استثناءات ، ولكن الممارسة الشائعة هي أن main() عادة لا يتم استدعائها خارجيًا. لذلك قد تتساءل عن شيء آخر: إذا لم نكن ندعو main() ، فلماذا نسمي النص على الإطلاق؟ يرجع السبب في ذلك إلى قيام العديد من الأشخاص ببناء نصوصهم باستخدام وظائف مستقلة تم إنشاؤها ليتم تشغيلها بشكل مستقل عن بقية الشفرة في الملف. ثم يطلق عليها لاحقاً في مكان آخر في نص البرنامج النصي. الذي يقودني إلى هذا:

لكن الشفرة تعمل بدونها

نعم هذا صحيح. يمكن استدعاء هذه الوظائف المنفصلة من برنامج نصي مضمّن غير موجود داخل دالة main() . إذا كنت معتادًا (كما هو الحال في المراحل التعليمية المبكرة من البرمجة) لإنشاء برامج نصية مضمنة تعمل تمامًا على ما تحتاجه ، وستحاول معرفة ذلك مرة أخرى إذا احتجت هذه العملية مرة أخرى .. حسنًا ، أنت لست معتادًا على هذا النوع من البنية الداخلية على شفرتك ، لأنه أكثر تعقيدًا للبناء وليس بديهيًا للقراءة.

ولكن هذا هو السيناريو الذي ربما لا يمكن أن تستدعي وظائفه خارجيا ، لأنه إذا فعل ذلك فإنه سيبدأ على الفور في حساب وتخصيص المتغيرات. وهناك احتمالات إذا كنت تحاول إعادة استخدام وظيفة ، فالنص الجديد الخاص بك يرتبط ارتباطًا وثيقًا بالبرنامج القديم بأنه ستكون هناك متغيرات متضاربة.

في تقسيم الوظائف المستقلة ، ستحصل على القدرة على إعادة استخدام عملك السابق عن طريق الاتصال بهم في برنامج نصي آخر. على سبيل المثال ، قد يستورد "example.py" "xy.py" ويستدعي x() ، مع استخدام الدالة "x" من "xy.py". (ربما يتم تكبير الكلمة الثالثة لسلسلة نصية معينة ؛ إنشاء مصفوفة NumPy من قائمة أرقام وتربيعها ؛ أو إلغاء سطح ثلاثي الأبعاد. الاحتمالات لا حدود لها).

(جانباً ، يحتوي هذا السؤال على إجابة من قبلkindall ساعدتني أخيراً في فهمه - لماذا ، وليس كيف. لسوء الحظ تم وضع علامة على أنها نسخة مكررة من هذا السؤال ، والذي أعتقد أنه خطأ).


وهو خاص عندما يتم استدعاء ملف Python من سطر الأوامر. يستخدم هذا عادة لاستدعاء وظيفة "main ()" أو تنفيذ تعليمات برمجية بدء تشغيل مناسبة أخرى ، مثل التعامل مع وسائط سطر الأوامر على سبيل المثال.

يمكن كتابتها بعدة طرق. آخر هو:

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

أنا لا أقول يجب عليك استخدام هذا في رمز الإنتاج ، لكنه يعمل على توضيح أنه لا يوجد شيء "سحري" حول if __name__ == '__main__' . إنها اتفاقية جيدة لاستدعاء وظيفة رئيسية في ملفات بايثون.


يعتبر:

if __name__ == "__main__":
    main()

يتحقق ما إذا كانت السمة __name__ للبرنامج النصي Python هي "__main__" . وبعبارة أخرى ، إذا تم تنفيذ البرنامج نفسه ، فإن السمة ستكون __main__ ، لذلك سيتم تنفيذ البرنامج (في هذه الحالة الدالة main() ).

ومع ذلك ، إذا تم استخدام نص برمجي Python من قِبل وحدة نمطية ، فسيتم تنفيذ أي كود خارج بيان if ، لذلك if \__name__ == "\__main__" فقط للتحقق مما إذا كان البرنامج يستخدم كوحدة نمطية أم لا ، و لذلك تقرر ما إذا كان سيتم تشغيل التعليمات البرمجية.


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 أخرى ، فلن يتم تنفيذ الشفرة ضمن "بيان if".

إذا تم تشغيل هذا .py بواسطة python this_py.pyshell ، أو النقر المزدوج في Windows. سيتم تنفيذ الكود الموجود تحت "بيان if".

هو مكتوب عادة للاختبار.


في الآونة الأخيرة ، صادفت هذا أثناء إنشاء فصل في python (التعلم العميق) ولفهمي والاتفاق على التفسيرات المدرجة أعلاه ، سأوضح

__name__=="__main__"

في بعض الأحيان نقوم ببناء صف في ملف .py ، ونحدد الكثير من الوظائف داخل تلك الفئة. ولكننا لا نرغب في معالجة كل وظائف الصف هذه لغرض واحد. forexample ، لإنشاء فئة وتعريف بعض الوظائف لإنشاء البيانات (ملفات .npy) بينما بعضها لتحميل البيانات. لذلك إذا عرفنا

__name__=="__main__"

XXX = CLASS_NAME ()

xxx.create_data ()

يعني إذا اتصلنا بالملف .py ، فسيعمل على إنشاء البيانات فقط ولن يقوم بمعالجة وظائف الصف الأخرى. يمكن أيضًا استيراد وظائف الصف الأخرى (تحميل البيانات) بواسطة فئات أخرى.


جميع الأجوبة شرحت الوظيفة إلى حد كبير. لكنني سأقدم مثالاً على استخدامها قد يساعد في إزالة المفهوم أكثر.

افترض أن لديك اثنين من ملفات Python ، وهما a.py و b.py. الآن ، تستورد a.py b.py. قمنا بتشغيل ملف a.py ، حيث يتم تنفيذ شفرة "import b.py" أولاً. قبل تشغيل باقي شفرة a.py ، يجب تشغيل الشفرة الموجودة في الملف b.py تمامًا.

في شفرة b.py ، هناك شفرة معينة حصرية لهذا الملف b.py ولا نريد أي ملف آخر (بخلاف ملف b.py) ، الذي قام باستيراد ملف b.py ، لتشغيله.

هذا هو ما يتحقق هذا السطر من التعليمات البرمجية. إذا كان هو الملف الرئيسي (أي b.py) الذي يقوم بتشغيل الكود ، وهو في هذه الحالة ليس (يتم تشغيل الملف الرئيسي) ، فلن يتم تنفيذ الكود إلا.


لقد قرأت الكثير طوال الإجابات على هذه الصفحة. وأود أن أقول ، إذا كنت تعرف الشيء ، بالتأكيد سوف تفهم تلك الإجابات ، وإلا ، لا يزال الخلط.

لكي تكون قصيرًا ، تحتاج إلى معرفة عدة نقاط:

  1. import a يعمل في الواقع كل ما يمكن تشغيله في "أ"

  2. بسبب النقطة 1 ، قد لا ترغب في تشغيل كل شيء في "a" عند استيراده

  3. لحل المشكلة في النقطة 2 ، يسمح لك python بوضع شرط للتحقق

  4. __name__هو متغير ضمني في جميع وحدات. عندما يتم استيراد __name__a.py ، يتم تعيين قيمة a.py على اسم الملف "a" ؛ عند تشغيل a.py مباشرةً باستخدام "python a.py" ، مما يعني أن a.py هي نقطة الإدخال ، ثم يتم تعيين قيمة __name__a.py على سلسلة__main__

  5. بناء على الآلية التي يحدد بها بيثون المتغير __name__لكل وحدة ، هل تعرف كيف تحقق النقطة 3؟ الجواب سهل إلى حد ما ، أليس كذلك؟ وضع إذا كان الشرط: if __name__ == "__main__": .... يمكنك حتى وضع إذا كنت __name__ == "a"تعتمد على حاجتك الوظيفية

الشيء المهم أن الثعبان خاص في النقطة 4! الباقي هو مجرد المنطق الأساسي.







idioms