ما هو " إذا _ _ اسم _ _ = ="__ الرئيسية__": في بيثون وكيفية استخدامها?

في لغة برمجة بايثون ، خاصة عند العمل مع الوحدات النمطية ، يمكنك غالبا مواجهة رمز يحتوي على السلسلة "إذا __اسم__=="_____". للوهلة الأولى ، قد يبدو هذا تعبيرا غامضا ، ولكنه في الواقع مفيد جدا ومهم للمطورين.

أولا ، دعنا نتعرف على معنى__ اسم__. هذا متغير مدمج في بايثون يحتوي على اسم الوحدة الحالية. إذا تم تنفيذ الوحدة كبرنامج رئيسي ، فستكون قيمة المتغير ____ __مساوية لـ"______". أي عندما نقوم بتشغيل الوحدة النمطية مباشرة ، بدلا من توصيلها كوحدة نمطية لبرنامج نصي آخر ، يصبح الشرط إذا __اسم__ = = "____ _ _ " صحيحا.

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

مثال الاستخدام:

إذا _ _ اسم _ _ = =" _ _ الرئيسية__":

# هنا يمكنك وضع التعليمات البرمجية التي سيتم تنفيذها فقط عندما يتم تشغيل وحدة مباشرة

طباعة ("مرحبا ، العالم!")

1. ما هو " إذا _ _ اسم _ _ = =" _ _ الرئيسية__": في بيثون?
2. ماذا يعني "إذا _ _ اسم _ _ = ="__ الرئيسية _ _ " يعني في بيثون?
3. كيف "إذا __اسم__ = =" __الرئيسية__ " العمل في بيثون?
4. متى تستخدم " إذا _ _ اسم _ _ = =" _ _ الرئيسية__": في بيثون?
5. مثال على استخدام " إذا _ _ اسم _ _ = =" _ _ الرئيسية__": في بايثون
6. لماذا أحتاج " إذا _ _ اسم _ _ = =" _ _ الرئيسية__": في بيثون?
7. ملامح " إذا _ _ اسم _ _ = =" _ _ الرئيسية__": في بيثون
8. سؤال وجواب
9. ما هو " إذا _ _ اسم _ _ = =" _ _ الرئيسية__"":?
10. كيفية استخدام " إذا _ _ اسم _ _ = =" _ _ الرئيسية__"":?
11. ما هو الغرض الرئيسي من استخدام " إذا _ _ اسم _ _ = =" _ _ الرئيسية__"":?
12. ماذا يحدث إذا كنت لا تستخدم "إذا _ _ اسم _ _ = =" _ _ الرئيسية__"":?
13. هل من الممكن استخدام " إذا _ _ اسم _ _ = =" _ _ الرئيسية _ _ " أكثر من مرة في نفس البرنامج النصي?

ما هو " إذا _ _ اسم _ _ = =" _ _ الرئيسية__": في بيثون?

عندما نكتب برامج بايثون ، نحتاج غالبا إلى التأكد من تنفيذ بعض التعليمات البرمجية فقط إذا تم تشغيل البرنامج النصي مباشرة ، ولم يتم استيراده من وحدة نمطية أخرى. للقيام بذلك ، نستخدم البناء " إذا _ _ اسم _ _ = =" _ _ الرئيسية__":".

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

يرجع هذا السلوك إلى حقيقة أن بايثون تستخدم متغير__ اسم _ _ لتحديد دور الوحدة. عندما يتم تشغيل الوحدة مباشرة ، ستكون قيمتها " _ _ الرئيسية__". إذا تم استيراد الوحدة من برنامج آخر ، فستتوافق القيمة مع اسم الوحدة نفسها.

باستخدام " إذا _ _ اسم _ _ = =" _ _ الرئيسية__":"يصبح مفيدا بشكل خاص عندما نريد تشغيل الاختبارات أو استدعاء بعض التعليمات البرمجية لتصحيح الأخطاء فقط عند تشغيل البرنامج النصي مباشرة.

مثال الاستخدام:

إذا _ _ اسم _ _ = =" _ _ الرئيسية__":

# التعليمات البرمجية التي سيتم تنفيذها فقط عند تشغيل البرنامج النصي للطباعة مباشرة

("مرحبا ، العالم!")

في هذا المثال ، إذا قمنا بتشغيل هذا البرنامج النصي مباشرة ، "مرحبا بالعالم!"سيتم عرضها على الشاشة. إذا قمنا باستيراد هذه الوحدة إلى برنامج نصي آخر ، فسيتم تخطي هذا الرمز.

ماذا يعني "إذا _ _ اسم _ _ = ="__ الرئيسية _ _ " يعني في بيثون?

ربما كنت قد رأيت السطر " إذا _ _ اسم _ _ = ="__ الرئيسية__": "في العديد من البرامج النصية بيثون, ولكن ماذا يعني ولماذا هو مطلوب?

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

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

هنا مثال على استخدام " إذا _ _ اسم _ _ = =" _ _ الرئيسية__": "في بايثون:

• تنفيذ رمز معين:

إذا _ _ اسم _ _ = =" _ _ الرئيسية__":

# الرمز الخاص بك

• استيراد وحدة نمطية:

اسم وحدة الاستيراد

في هذه الحالة ، لن يتم تنفيذ التعليمات البرمجية في الوحدة النمطية تلقائيا عند الاستيراد ، فقط إذا تم استدعاؤها صراحة.

دعونا ننظر إلى مثال:

# sample_module.py

مواطنه مرحبا():

طباعة ("مرحبا ، العالم!")

إذا _ _ اسم _ _ = =" _ _ الرئيسية__":

مرحبا()

عندما نقوم بتشغيل هذا البرنامج النصي مباشرة ، سيكون الإخراج "مرحبا بالعالم!". ولكن إذا قمنا باستيراده إلى برنامج نصي آخر ، فلن يتم تنفيذ الكود الخاص به تلقائيا.

وبالتالي ، " إذا _ _ اسم _ _ = =" _ _ _ _ الرئيسية": "يوفر لنا القدرة على تقييد تنفيذ التعليمات البرمجية فقط عند تشغيل الوحدة النمطية مباشرة ، وليس عند الاستيراد.

كيف "إذا __اسم__ = =" __الرئيسية__ " العمل في بيثون?

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

سيتم تجاهلها.

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

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

يتم كتابة اسم الوحدة النمطية المستوردة.

مثال على استخدام " إذا _ _ اسم _ _ = =" _ _ الرئيسية__":

مواطنه مضاعفة (أ ، ب):

العودة أ * ب

إذا _ _ اسم _ _ = =" _ _ الرئيسية__":

النتيجة = ضرب (5 ، 7)

طباعة (نتيجة)

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

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

متى تستخدم " إذا _ _ اسم _ _ = =" _ _ الرئيسية__": في بيثون?

لغة البرمجة بايثون لديها بناء خاص " إذا _ _ اسم _ _ = ="__الرئيسية__":"،والذي يسمح لك بتحديد ما إذا كان البرنامج النصي يتم تشغيله مباشرة من سطر الأوامر أو يتم استيراده كوحدة نمطية في برنامج نصي آخر.

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

الحالات الرئيسية حيث "إذا __اسم__ = =" __الرئيسية__": "يجب أن تستخدم ما يلي:

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

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

مثال على استخدام " إذا _ _ اسم _ _ = ="__الرئيسية__":":

مواطنه الرئيسية():

# التعليمات البرمجية التي يجب تنفيذها فقط عند تشغيل البرنامج النصي من تلقاء نفسها

إذا _ _ اسم _ _ = =" _ _ الرئيسية__":

الرئيسية()

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

باستخدام " إذا _ _ اسم _ _ = =" _ _ الرئيسية__": يشير إلى رمز منظم جيدا وسهل القراءة ، لأنه يسلط الضوء على منطق مختلف لمهام مختلفة: تشغيل البرنامج والاستيراد إلى برنامج نصي آخر. هذا يتجنب المشاكل المتعلقة بإعادة تنفيذ التعليمات البرمجية أو الآثار الجانبية غير المرغوب فيها أثناء الاستيراد.

مثال على استخدام " إذا _ _ اسم _ _ = =" _ _ الرئيسية__": في بايثون

تعريف " إذا _ _ اسم _ _ = ="__ الرئيسية__": هو المفتاح لفهم كيفية تشغيل ملف قابل للتنفيذ في بيثون. يتيح لك هذا التصميم تحديد ما إذا كان الملف هو الملف القابل للتنفيذ "الرئيسي" للبرنامج ، أو ما إذا كان قد تم استيراده إلى وحدة نمطية أخرى.

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

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

دعونا ننظر إلى مثال بسيط:

# some_module.py

مواطنه بعض_وظيفة():

طباعة ("هذه هي الوظيفة بعض الوظائف () من الوحدة النمطية بعض الوحدات")

إذا _ _ اسم _ _ = =" _ _ الرئيسية__":

طباعة ("هذا هو الملف القابل للتنفيذ الرئيسي للبرنامج")

طباعة ("استدعاء الوظيفة بعض الوظائف () من الوحدة النمطية بعض الوحدات")

بعض_وظيفة()

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

ومع ذلك ، إذا كان الملف هو بعض_وحدة.إذا تم استيراد الحمر إلى وحدة نمطية أخرى ، ثم الشرط إذا __اسم__ == "__الرئيسية__": سوف تكون كاذبة ، ولن يتم تنفيذ التعليمات البرمجية داخل هذا الشرط.

باستخدام إذا _ _ اسم _ _ = =" _ _ الرئيسية__": إنها ممارسة جيدة عند تطوير برامج بايثون ، لأنها تتيح لك إنشاء وحدات مرنة يمكن استخدامها كبرامج قائمة بذاتها أو استيرادها إلى وحدات أخرى.

لماذا أحتاج " إذا _ _ اسم _ _ = =" _ _ الرئيسية__": في بيثون?

باستخدام البناء " إذا _ _ اسم _ _ = ="__ الرئيسية__": "هي واحدة من ميزات لغة بايثون. يتيح لك هذا التصميم تحديد ما إذا كان الملف الحالي قد بدأ كبرنامج منفصل أو تم استيراده إلى ملف آخر.

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

وهكذا ، " إذا _ _ اسم _ _ = =" _ _ الرئيسية__": "يسمح لك بإنشاء كتلة من التعليمات البرمجية التي سيتم تنفيذها فقط إذا تم تشغيل الملف مباشرة.

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

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

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

ملامح " إذا _ _ اسم _ _ = =" _ _ الرئيسية__": في بيثون

"إذا _ _ اسم _ _ = ="__الرئيسية__": - هذا تعبير شرطي في بايثون يسمح لك بالتحقق مما إذا كان الملف يتم تشغيله مباشرة كبرنامج نصي أو يتم استيراده إلى وحدة نمطية أخرى.

عند تشغيل البرنامج ، يقوم مترجم بايثون بتعيين قيمة المتغير الخاص _ _ اسم _ _ إلى"_____". وهذا يعني أن رمز داخل إذا __اسم _ _ = ="__ الرئيسية _ _ " كتلة: سيتم تنفيذه فقط عند تشغيل الملف مباشرة.

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

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

مثال على استخدام " إذا _ _ اسم _ _ = =" _ _ الرئيسية__"::

1. لديك وحدة نمطية file.py مع بعض التعليمات البرمجية ، بما في ذلك الوظائف والفئات.
2. أنت تقوم بإنشاء ملف جديد script.py واستيراد وظائف وفئات من module.py .
3. تريد ذلك عند بدء التشغيل script.py تم تنفيذ رمز معين يستدعي الوظائف ويستخدم الفئات من module.py .
4. إضافة التعليمات البرمجية التالية إلى نهاية الملف module.py :
• إذا _ _ اسم _ _ = =" _ _ الرئيسية__":
5. الآن ، عند بدء تشغيل الوحدة.الحمر كبرنامج مستقل ، إلا أن رمز داخل إذا _ _ اسم __ = = "__ الرئيسية _ _ " كتلة سيتم تنفيذها:. متى يكون module.py يتم استيرادها إلى script.py ، رمز داخل إذا _ _ اسم _ _ = = "__ الرئيسية _ _ " كتلة: سيتم تجاهلها.

في الختام ، " إذا _ _ اسم _ _ = ="__الرئيسية__": في بيثون ، بل هو ميزة مريحة للغاية لفصل التعليمات البرمجية التي سيتم تنفيذها فقط عند بدء تشغيل الملف من التعليمات البرمجية التي سيتم استخدامها عند استيراد وحدة. يتيح لك ذلك إنشاء وحدات ومكتبات قابلة لإعادة الاستخدام ، مما يزيد من سهولة قراءة التعليمات البرمجية وكفاءتها.

سؤال وجواب

ما هو " إذا _ _ اسم _ _ = =" _ _ الرئيسية__"":?

"إذا _ _ اسم _ _ = =" _ _ الرئيسية _ _ " هو بناء خاص في بيثون التي تسمح لك لتنفيذ كتلة معينة من التعليمات البرمجية فقط عند استدعاء البرنامج النصي مباشرة ، وليس عند الاستيراد إلى وحدة أخرى. عندما يقوم مترجم بايثون بتنفيذ البرنامج النصي ، فإنه يحدد قيمة المتغير المدمج _ _ اسم _ _ إلى"_____". إذا كانت هذه المجموعة من التعليمات البرمجية داخل الشرط "إذا _ _ اسم _ _ = =" _ _ _ _ _ " ، فسيتم تنفيذها فقط عند استدعاء البرنامج النصي مباشرة من سطر الأوامر أو من برنامج آخر.

كيفية استخدام " إذا _ _ اسم _ _ = =" _ _ الرئيسية__"":?

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

ما هو الغرض الرئيسي من استخدام " إذا _ _ اسم _ _ = =" _ _ الرئيسية__"":?

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

ماذا يحدث إذا كنت لا تستخدم "إذا _ _ اسم _ _ = =" _ _ الرئيسية__"":?

إذا كنت لا تستخدم "إذا __اسم__ = = "____ الرئيسية"" ، فسيتم تنفيذ جميع التعليمات البرمجية المكتوبة أسفل هذا السطر بغض النظر عما إذا كان البرنامج النصي يتم استدعاؤه مباشرة أو استيراده إلى وحدة نمطية أخرى. قد يؤدي هذا إلى نتائج غير مرغوب فيها أو غير صحيحة عند استخدام الوحدة النمطية في برنامج آخر.

هل من الممكن استخدام " إذا _ _ اسم _ _ = =" _ _ الرئيسية _ _ "" أكثر من مرة في نفس البرنامج النصي?

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