מה עושה אם __name__ == "__main__" Construct ב-Python?

בשפות תכנות מסוימות, השיטה הראשית משמשת כנקודת הכניסה היחידה לביצוע תוכנית. תוך כדי מעבר משפות אחרות לפייתון, הביטוי if __name__ == "__main__" נראה כאילו מבצע את אותה משימה. ב-Python, זה לא המקרה.

ה if __name__ == "__main__" idiom מאפשר להפעיל קוד ספציפי כאשר הקובץ פועל כסקריפט. זה גם מוודא שאותו קוד לא יופעל כאשר אתה מייבא את הקובץ כמודול.

הבנת ההתנהגות המשתנה __שם__

ה __שֵׁם__ המשתנה מובנה ב- Python. הוא מייצג את השם של המודול או הסקריפט שבו הוא משמש. כאשר סקריפט מופעל כתוכנית הראשית, הערך שלו מוגדר ל __רָאשִׁי__. אם אתה מייבא את הסקריפט כמודול, ערך המשתנה מוגדר לשם האמיתי של המודול.

זה עשוי להיות מבלבל בהתחלה, אבל תסתכל על הדוגמה הבאה:

צור סקריפט ותן לו שם greetings.py. סקריפט זה יכיל פונקציה שמקבלת את פני המשתמש ומדפיסה את הערך של __שֵׁם__ מִשְׁתַנֶה. זה גם יבקש מהמשתמש להזין את שמו.

defלברך(שֵׁם):
 הדפס(ו"שלום, {שֵׁם}!")
הדפס("ערך של __שם__:", __שם__)
אם __שם__ == "__רָאשִׁי__":
 user_name = input("אנא הכנס את שמך: ")
 שלום (שם_משתמש)
אַחֵר:
 הדפס("המודול 'ברכות' יובא.")

מפעיל את greetings.py הסקריפט יציג את הפלט הבא:

הערך של ה __שֵׁם__ תשואות משתנות כ __רָאשִׁי__ כי הסקריפט מופעל ישירות.

כעת צור סקריפט אחר ותן לו שם script2.py. לאחר מכן, ייבא את ה ברכות סקריפט כמודול.

יְבוּא ברכות
הדפס("מבצע את תסריט הברכות...")
greetings.greet("אליס")

מתקשר ל לברך פונקציה מה בְּרָכָה מודול נותן את הפלט הבא.

הערך של ה __שֵׁם__ שינויים במשתנה לשם בפועל של המודול המיובא. במקרה הזה, ברכות.

הערך הזה הוא הביטוי if __name__ == "__main__" מחפש כדי לקבוע אם קובץ פועל כסקריפט או מיובא כמודול.

מתי להשתמש במבנה if __name__ == "__main__"?

אתה יכול להוסיף את if __name__ == "__main__" לבנות בכל סקריפט. אבל יש כמה תרחישים שבהם השימוש בו יכול להיות המועיל ביותר. תלמד על תרחישים אלה באמצעות תוכנית המחשבון הפשוטה למטה.

# calculator.py
defלְהוֹסִיף(א, ב):
לַחֲזוֹר a + b
defלהחסיר(א, ב):
לַחֲזוֹר א - ב
defלְהַכפִּיל(א, ב):
לַחֲזוֹר א * ב
defלחלק(א, ב):
אם ב != 0:
לַחֲזוֹר א/ב
אַחֵר:
לַחֲזוֹר"שגיאה: חלוקה באפס!"
אם __שם__ == "__רָאשִׁי__":
 הדפס("ברוכים הבאים למחשבון!")
 הדפס("בחר פעולה:")
 הדפס("1. לְהוֹסִיף")
 הדפס("2. להחסיר")
 הדפס("3. לְהַכפִּיל")
 הדפס("4. לחלק")
 בחירה = int (קלט("הזן את הבחירה שלך (1-4):"))
 num1 = float (קלט("הזן את המספר הראשון:"))
 num2 = float (קלט("הזן את המספר השני:"))
אם בחירה == 1:
 תוצאה = הוסף (מספר1, מספר2)
 הדפס(f"הסכום של {num1} ו {num2} הוא: {תוֹצָאָה}")
אליף בחירה == 2:
 תוצאה = חיסור (מספר1, מספר2)
 הדפס(f "ההבדל בין {num1} ו {num2} הוא: {תוֹצָאָה}")
אליף בחירה == 3:
 תוצאה = הכפל (מספר1, מספר2)
 הדפס(f"התוצר של {num1} ו {num2} הוא: {תוֹצָאָה}")
אליף בחירה == 4:
 תוצאה = חלק (מספר1, מספר2)
 הדפס(f"החלוקה של {num1} על ידי {num2} הוא: {תוֹצָאָה}")
אַחֵר:
 הדפס("בחירה לא חוקית!")

התרחיש הראשון הוא כאשר אתה רוצה להריץ סקריפט באופן עצמאי ולבצע פעולות ספציפיות. זה מאפשר לסקריפט לתפקד כתוכנית עצמאית. ה if __name__ == "__main__" construct מאפשר למשתמשים ליצור אינטראקציה עם המחשבון באמצעות ממשק שורת הפקודה. זה נותן למשתמשים את היכולת להשתמש בפונקציונליות של התוכנית ללא צורך להבין או לשנות את הקוד הבסיסי.

עדיין ניתן להפעיל את התוכנית ללא if __name__ == "__main__" לבנות ולהשיג את אותה תוצאה, אבל הקוד שלך יאבד את ארגון הקוד המודולרי.

התרחיש השני הוא כשאתה רוצה את שלך קוד שיהיה עיצוב מודולרי. זה מאפשר לתוכניות אחרות לייבא את הסקריפט שלך כמודול ולהשתמש בפונקציות שלו מבלי להפעיל פונקציות מיותרות.

במקרה של תוכנית המחשבון, תוכניות אחרות יכולות לייבא את מַחשְׁבוֹן מודול מבלי להפעיל את ממשק CLI והנחיות קלט משתמש. זה מבטיח שימוש חוזר בקוד ועיצוב מודולרי. לפיכך, מאפשר למחשבון להשתלב בצורה חלקה ביישומים גדולים יותר.

יְבוּא מַחשְׁבוֹן
# שימוש בפונקציות ממודול המחשבון
result_add = calculator.add(5, 3)
הדפס("תוצאת הוספה:", תוצאה_הוסף)
result_subtract = calculator.subtract(10, 4)
הדפס("תוצאת חיסור:", חיסור_תוצאה)

התרחיש השלישי הוא כשאתה רוצה בדוק וניפוי באגים בסקריפט Python שלך ללא תלות במודולים או סקריפטים אחרים שעשויים לייבא אותו. בדוגמה של המחשבון, זה מקל על התמקדות בבדיקת פונקציונליות המחשבון ללא הפרעות מקוד חיצוני.

יְבוּא מַחשְׁבוֹן
# בדיקת פונקציות המחשבון
אם __שם__ == "__רָאשִׁי__":
# תוספת מבחן
 תוצאה = calculator.add(5, 3)
 הדפס("תוצאת הוספה:", תוצאה)
# חיסור בדיקה
 תוצאה = calculator.subtract(8, 4)
 הדפס("תוצאת חיסור:", תוצאה)
# כפל מבחן
 תוצאה = calculator.multiply(2, 6)
 הדפס("תוצאת הכפל:", תוצאה)

הקוד לעיל מדגים כיצד לנפות באגים בסקריפט המחשבון באופן עצמאי.

מתי מיותר להשתמש במבנה if __name__ == "__main__"?

כפי שראית בתרחישים לעיל, השימוש ב- if __name__ == "__main__" construct הוא להבדיל בין הסקריפט שאתה מריץ בתור התוכנית הראשית לבין זה שאתה מייבא כמודול. עם זאת ישנם מקרים שבהם השימוש בו מיותר.

המקרה הראשון הוא כאשר הסקריפט שלך פשוט ואין לו פונקציות או מודולים הניתנים לשימוש חוזר ואתה לא מתכוון לייבא אותו. במקרה זה, עליך להשמיט את המבנה הזה מכיוון שהסקריפט כולו מופעל בעת הריצה. זה נפוץ עבור סקריפטים חד-פעמיים שמבצעים מטרה מסוימת ואינם מיועדים לשימוש חוזר או לייבוא.

המקרה השני הוא כאשר אתה עובד בהפעלת Python אינטראקטיבית, למשל. בעת שימוש ב-Jupyter Notebook. בהפעלה אינטראקטיבית, אתה מקליד ומבצע קוד ישירות בשורת הפקודה או במעטפת Python אינטראקטיבית. כמו ה-Python REPL (Read-Eval-Print Loop). זה מאפשר לך להתנסות בקוד, ולבדוק קטעים קטנים, מה שמספק לך תוצאות מיידיות.

בסביבות אינטראקטיביות אלו, הרעיון של סקריפט הפועל כתוכנית הראשית או מיובא כמודול אינו חל. אתה מבצע ישירות קטעי קוד ללא צורך בנקודת כניסה מסורתית לסקריפט.

איך הופכים למאסטר בפייתון?

כדי להיות מאסטר בכל שפת תכנות, אתה צריך להבין איך המושגים הבסיסיים של הפונקציות או הכלים עובדים. בדיוק כמו שלמדת על המבנה if __name__ == "__main__" במאמר זה.

הבנת המושגים הבסיסיים תעזור לך לדעת בדיוק איך התוכנית שלך תתנהג כשאתה משתמש בהם. אין למהר, לימוד המושגים אחד בכל פעם יעזור לך לצלול עמוק יותר לתוך כל אחד מהם.