השם של הסקריפט או המודול של Python שמבוצע כעת מאוחסן במשתנה המיוחד __name__ של Python. Python 3.0 הציג את המשתנה __name__, שנעדר מ- Python 2. x. הסקריפט או המודול הנוכחי של Python, __main__, מוקצה למשתנה __name__ בזמן שהוא מופעל.
מה המשמעות של _שם_?
לפייתון יש משתנה מובנה בשם __name__ המאחסן את שם הסקריפט או המודול שפועלים כעת. שם הסקריפט או המודול מאוחסן במשתנה __name__ אלא אם המודול הנוכחי פועל, ובמקרה זה הערך __main__ מוקצה לו.
כתוצאה מכך, כאשר סקריפט Python מבוצע, הערך של המשתנה __name__ שלו תמיד צריך להיות __main__ אם הוא מיובא לסקריפט אחר של Python. אם לא, שם המודול יופיע.
דוגמא :
כדי להבין זאת יותר, הבה נשתמש בדוגמה. לעשות סקריפט בפייתון בשם testing.py, וצרף אליו את הקוד הבא:
# Code to define a function def anything(): print('Value of the __name__ : ', __name__) anything()
תְפוּקָה:
char לתוך מחרוזת Java
Value of the __name__ : __main__
הֶסבֵּר:
הסקריפט פועל באופן מיידי כתוכנית הראשית, כפי שמצוין בפלט 'ערך השם: ראשי'. ב-Python, הערך של המשתנה __name__ של הסקריפט מוגדר אוטומטית ל'__main__' כאשר הסקריפט מבוצע ישירות. פלט זה מאשר שהסקריפט מופעל ישירות במקום מיובא כמודול לסקריפט אחר
כעת נבנה סקריפט אחר של Python בשם mains.py ולייבא לתוכו את הקודם.
דוגמא :
# importing testing.py import testing testing.anything()
תְפוּקָה:
Value of the __name__ : testing
הֶסבֵּר:
בדיקה. anything() היא השיטה המופעלת כאשר הסקריפט testing.py מיובא לסקריפט אחר של Python באמצעות בדיקת ייבוא. במצב זה, שם המודול, במקרה זה 'בדיקה', מוגדר כערך של המשתנה __name__ ב-testing.py במקום '__main__'. מסיבה זו, הפלט של בדיקה. anything() הוא 'ערך של __name__: testing'. זה ממחיש כיצד הפעלת הסקריפט ישירות לעומת ייבוא כמודול משפיעה על הערך של המשתנה __name__.
שימוש בתנאי אם שם == main :
אנו משתמשים ב- אם הצהרה והמצב __שם__ == __ראשי__ להצהיר על כך קוד Python מסוים צריך להיות רק מבוצע כאשר הסקריפט מופעל ישירות .
אלגוריתם דק
דוגמא :
# importing testing.py import testing if __name__ == __main__: testing.anything()
במקרה זה, היכולת של המודול או הסקריפט הנוכחי לפעול באופן עצמאי מוכחת באמצעות המחרוזת __main__. כדי לציין למתורגמן Python שמילת מפתח במשתנה __name__ שמורה או מיוחדת, יש שני קווים תחתונים משני צידי המונח.
ענן אביב
דוגמה לקוד עבור שם ב- Python:
כפי שנאמר קודם, כאשר אנו מריצים קובץ קוד, הקוד מתבצע ישירות - הוא אפילו לא מיובא לקובץ אחר - וכתוצאה מכך, הערך של המשתנה __name__ משתנה ל-__main__.
# defining a function def anything(): print('It is a function in the ScriptP1.') if __name__=='__main__': anything() print('Called from the ScriptP1.') else: print('ScriptP1 is imported into another file.')
תְפוּקָה:
It is a function in the ScriptP1. Called from the ScriptP1.
הֶסבֵּר:
הפונקציה anything() שצוינה בסקריפט ScriptP1 מופעלת ישירות בתור התוכנית הראשית, כפי שמוצג על ידי הפלט 'זה פונקציה ב-ScriptP1'. ואחריו 'נקרא מה-ScriptP1'. כאשר הסקריפט מופעל ישירות ב-Python, המשתנה __name__ מוגדר ל'__main__'; כתוצאה מכך, התנאי אם __name__=='__main__': מוערך ל-True, וקורא לפונקציה anything(). הצהרת ההדפסה הבאה מאמתת שהסקריפט אכן מופעל ישירות.
כעת, בואו ניצור קובץ סקריפט חדש של Python בשם ScriptP2.py, לייבא אליו את ScriptP1.py וננסה לקרוא למתודה ScriptP1 any().
קוד : ה ScriptP2.py הקוד מסופק כאן:
import ScriptP1 if __name__=='__main__': ScriptP1.anything() print('Called from the ScriptP2.')
תְפוּקָה:
excel להסיר את התו הראשון
ScriptP1 is imported into another file. It is a function in the ScriptP1. Called from the ScriptP2.
הֶסבֵּר:
סקריפט Python שסופק מראה כיצד לייבא את מודול 'ScriptP1' לתוך הסקריפט הפעיל. השיטה 'anything()' קיימת ב-'ScriptP1', והיא נקראת בסקריפט הראשי. פונקציה זו נקראת, והסקריפט מוציא 'נקרא מה-ScriptP2'. כדי לציין שקריאת הפונקציה הושלמה. זרימת אירועים זו מצביעה על כך שהפונקציה שצוינה ב-'ScriptP1' הייתה נגישה ובוצעה בהצלחה בהקשר של הסקריפט שפועל כעת, המזוהה כ-'ScriptP2'.
כאשר משפט הייבוא עבור ScriptP1 הופעל בתוך ScriptP2, למשתנה __name__ היה הערך ScriptP1 (שם המודול); אבל מכיוון ש-ScriptP2 היה הסקריפט הראשון שרץ, כעת יהיה לו הערך __main__.
הדפסת הערך של __שם__ :
בואו נדפיס את הערך של המשתנה __name__ בכל שלב של ביצוע כדי לעזור לכם להבין אותו טוב יותר.
דוגמא : קוד המקור של הסקריפט ScriptP1.py Python מסופק להלן:
התנתק מחשבון גוגל באנדרואיד
print('Value or the variable __name__ : ' + __name__)
תְפוּקָה:
Value or the variable __name__ : __main__
הֶסבֵּר:
הדוגמה של קוד Python שמסופקת מפלטת את הערך של המשתנה __name__, שכאשר הסקריפט מופעל ישירות, מוערך ל'main'. זה אומר שכאשר הסקריפט מופעל ישירות, בלוק הקוד שמגיע אחרי התנאי if __name__ == '__main__': יפעל במקום להיות מיובא כמודול לסקריפט אחר. סוג זה של התנהגות משמש לעתים קרובות כדי להבחין בין הפעלת סקריפט בתור היישום הראשי לבין ייבואו לסקריפט אחר כמודול.
דוגמה 2: והנה קוד המקור של הסקריפט ScriptP2.py:
# importing the file ScriptP1.py import ScriptP1 print('Value or the variable __name__ : ' + __name__)
תְפוּקָה:
Value or the variable __name__ : __main__
הֶסבֵּר:
סקריפט Python שסופק משתמש בהצהרת import כדי לייבא את הקובץ 'ScriptP1.py. ' כאשר הוא מבוצע, 'main' מודפס כערך של המשתנה __name__. המשמעות היא שבמקום לייבא כמודול לסקריפט אחר, הסקריפט מבוצע ישירות בתור היישום הראשי. בעת ביצוע סקריפטים של Python, זוהי ההתנהגות הרגילה; הקשר הביצוע של הסקריפט בא לידי ביטוי במשתנה __name__.
סיכום :
ברוב שפות התכנות, השיטה או הפונקציה העיקרית משמשת בדרך כלל כנקודה שבה כל תוכנית מבוצעת. אבל מה עם פייתון? ביצוע של תוכנית Python (script) מתחיל בדרך כלל בשורה אפס או ברמת ההזחה של התוכנית 0. יצירת משתנה __name__, לעומת זאת, מתרחשת לפני שתוכנית Python פועלת. משתנה זה עשוי לשמש כדי להחליף את השיטה הראשית ב- Python.