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


Answers

عندما يتم تشغيل البرنامج النصي الخاص بك عن طريق تمريره كمترجم لمترجم Python ،

python myscript.py

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

في هذه الحالة ، يكون رمز المستوى الأعلى كتلة if . __name__ هو __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__" .

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))



هناك عدد من المتغيرات التي يوفرها النظام (Python interpreter) للملفات المصدر (الوحدات النمطية). يمكنك الحصول على قيمها في أي وقت تريده ، لذا دعنا نركز على الخاصية المميزة / المتغير __name__ :

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

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

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

إذا تم استيراد هذا من وحدة نمطية أخرى ، فسيتم تعيين __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__ لن تساوي " main " في ذلك المثيل المعين.

آمل أن يساعد هذا.




ماذا 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()



عند تشغيل 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.



ماذا 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()

يمكن العثور على هذا المصطلح أيضًا في وثائق Python في شرح وحدة __main__ . ينص هذا النص:

تمثل هذه الوحدة النمطية نطاق (غير ذلك المجهول) الذي ينفّذ فيه البرنامج الرئيسي للمترجم - الأوامر مقروءة إما من الإدخال القياسي ، أو من ملف نصي ، أو من موجه تفاعلي. هذه هي البيئة التي يتسبب فيها المقطع النصي "الشرطي الشرطي" في تشغيل برنامج نصي:

if __name__ == '__main__':
    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 ، تقوم 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() ". ولهذا السبب سترى def main(): حظر أعلى ، والذي يحتوي على التدفق الرئيسي لوظيفة البرنامج النصي.

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

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

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

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

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

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

[جانبا ، يحتوي هذا الموضوع على إجابة من جانب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 ، python test.py اسم الوحدة النمطية __main__ :

call test()
test module name=__main__



if __name__ == "__main__": هي في الأساس بيئة if __name__ == "__main__": من المستوى الأعلى ، فإنها تحدد المترجم ("لدي الأولوية القصوى التي يجب تنفيذها أولاً").

'__main__' هو اسم النطاق الذي يتم فيه تنفيذ التعليمة البرمجية ذات المستوى الأعلى. يتم ضبط __name__ للوحدة النمطية على '__main__' عند القراءة من الإدخال القياسي أو البرنامج النصي أو من موجه تفاعلي.

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



قبل شرح أي شيء حول if __name__ == '__main__' من المهم فهم ما هو __name__ وماذا يفعل.

ما هو __name__ ؟

__name__ هو DunderAlias ​​- يمكن اعتباره متغيرًا عالميًا (يمكن الوصول إليه من الوحدات) ويعمل بطريقة مشابهة global .

هي سلسلة (عالمي كما ذكر أعلاه) كما هو مشار إليه type(__name__) (العائد <class 'str'> ) ، وهو معيار يحمل في ثناياه عوامل لإصدارات Python 3 و Python 2 .

أين:

لا يمكن استخدامه فقط في البرامج النصية ولكن يمكن العثور عليه أيضًا في كل من المترجم والوحدات / الحزم.

مترجم:

>>> print(__name__)
__main__
>>>

النصي:

test_file.py :

print(__name__)

مما __main__ في __main__

الوحدة النمطية أو الحزمة:

somefile.py:

def somefunction():
    print(__name__)

test_file.py:

import somefile
somefile.somefunction()

مما somefile في بعض somefile

لاحظ أنه عند استخدامها في حزمة أو وحدة نمطية ، تأخذ __name__ اسم الملف. لا يتم إعطاء مسار الوحدة النمطية أو مسار الحزمة ، ولكن له DunderAlias __file__ الخاص به ، والذي يسمح بذلك.

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

ممارسة:

يعني المتغير أنه يمكن الكتابة فوق القيمة ("لا" تعني "يجب") ، يؤدي الكتابة فوق قيمة __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__ يساوي __main__ ، فيجب أن يكون الملف هو الملف الرئيسي ويجب أن يكون قيد التشغيل بالفعل (أو هو المترجم) ، وليس وحدة نمطية أو حزمة تم استيرادها في البرنامج النصي.

إذا كانت __name__ بالفعل تأخذ قيمة __main__ فسيتم تنفيذ أي شيء في كتلة الكود هذا.

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

وحدات:

يمكن أيضًا استخدام __name__ في الوحدات النمطية لتعريف اسم الوحدة

المتغيرات:

من الممكن أيضًا القيام بأشياء أخرى أقل شيوعًا ولكنها مفيدة مع __name__ ، وسوف أقوم __name__ هنا:

تنفيذ فقط إذا كان الملف وحدة أو حزمة:

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

تشغيل شرط واحد إذا كان الملف الرئيسي والآخر إذا لم يكن:

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

يمكنك أيضًا استخدامه لتوفير وظائف مساعدة / أدوات مساعدة قابلة للتشغيل على الحزم والوحدات النمطية دون الاستخدام المتقن للمكتبات.

كما يسمح أيضًا بتشغيل الوحدات من سطر الأوامر كنصوص رئيسية ، والتي يمكن أن تكون مفيدة جدًا أيضًا.




if __name__ == "__main__":
    main()

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

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






Links