הבנת עומס יתר של פונקציות ב-Python

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

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

בניגוד לשפות כמו C++ ו-Java, Python לא תומך בעומס יתר של פונקציות כברירת מחדל, אבל יש דרכים להשיג פונקציונליות דומה.

כיצד Python מטפל בעומס יתר של פונקציות?

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

defarithmetics(a, b):
return a - b
defarithmetics(a, b, c, d):
return a + b - c * d
print(arithmetics(1, 2, 3, 5)) # returns -12
print(arithmetics(1, 2)) # returns missing positional arguments error

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

בקוד לעיל, Python יזהה רק את ההגדרה השנייה של ה-

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

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

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

שיטה 1: שימוש בפרמטרים אופציונליים או ארגומנטים ברירת מחדל

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

defarithmetics(a, b=0, c=0):

 Arguments:
 a: The first number.
 b: The second number (optional).
 c: The third number (optional).

return a - b + c

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

print(arithmetics(1)) # returns 1
print(arithmetics(2, 5)) # returns -3
print(arithmetics(10, 3, 4)) # returns 11

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

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

שיטה 2: שימוש בארגומנטים משתנים

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

defarithmetics(a, *args):

 Arguments:
 a: The first number.
 *args: A variable number of arguments (optional).

 args_sum = 0
for num in args:
 args_sum *= num
return a - args_sum
print(arithmetics(1)) # returns 1
print(arithmetics(2, 5)) # returns 2
print(arithmetics(10, 3, 4, 2, 4, 6)) # returns 10

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

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

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

שיטה 3: שימוש ב- Multiple Dispatch Decorator

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

כדי להשתמש במעצב המשלוחים המרובים, בצע את השלבים הבאים:

1. להתקין רב-דיספת בסביבת Python שלך:

   pip install multipledispatch
   

2. קשט את הפונקציה שלך עם @לְשַׁגֵר מְעַצֵב. ה @לְשַׁגֵר מעצב הוא א מעצב פייתון המאפשר לך ליישם שיגור מרובה. זה ישלח אוטומטית את הפונקציה המתאימה בהתבסס על הארגומנטים שאתה מעביר אליו. אתה יכול להשתמש ב @לְשַׁגֵר מעצב על ידי ביצוע דפוס זה:

   from multipledispatch import dispatch
   @dispatch(data type1, data type2, data typeX)
   defyour_function(a, b, c, x):
   pass
   # perform your operations here
   

הנה דוגמה שמשתמשת ב-multiple dispatch decorator עבור עומס יתר של פונקציות ב- Python:

from multipledispatch import dispatch
@dispatch(int, int)
defadd(a, b):

 Arguments:
 a: Any integer.
 b: Any integer.

return a + b
@dispatch(int, list)
defadd(a, b):

 Arguments:
 a: Any integer.
 b: Any Python list.

 b.append(a)
return b
# returns 3
print(add(1, 2))
# returns [2, 3, 4, 5, 'w', 'done', 1]
print(add(1, [2, 3, 4, 5, 'w', 'done']))

קטע הקוד שלמעלה מגדיר שני מופעים של לְהוֹסִיף() פוּנקצִיָה. המופע הראשון לוקח שני מספרים שלמים כטיעונים שלו ומחזיר את הסכום שלהם.

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

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

הגישה הטובה ביותר לעומס יתר של פונקציות ב-Python

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

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

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