פונקציות למבדה ב-Python

מהן פונקציות למבדה?

​
ב-Python, פונקציות הן אובייקטים: ניתן להקצות אותן למשתנים, ניתן להחזיר אותן מפונקציות אחרות, לאחסן אותן ברשימות או dicts ולהעביר אותן כפרמטרים עבור פונקציות אחרות. שקול, למשל, את map() פונקציה מובנית. התחביר שלו הוא map(function, iterable) והוא משמש ליישום שימושי function לכל אלמנט של iterable.

map() בעצם מחזיר א iterator לְהִתְנַגֵד. בפועל, אנו יציקו את התוצאה כ-a list, tuple, set, dictוכו', מה שנוח יותר.
​
נניח שאתה רוצה לריבוע כל איבר ברשימה באמצעות ה map() פוּנקצִיָה. על מנת לעשות זאת, נגדיר א square() פונקציה והשתמש בה כפרמטר עבור map():

my_list = [1,2,3,4,5]
def square(x):
    return x**2

my_modified_list = list(map(square, my_list))
print(my_modified_list)

[1, 4, 9, 16, 25]

​
עם זאת, אם השימוש היחיד שלנו square() הפונקציה היא ליצור רשימה זו, זה נקי יותר להשתמש ב-a lambda פוּנקצִיָה:

my_list = [1,2,3,4,5]
my_modified_list = list(map(lambda x: x**2, my_list))
print(my_modified_list)

[1, 4, 9, 16, 25]

בפייתון, lambda פונקציות הן פונקציות אנונימיות שמקבלות את השם והתחביר שלהן מאלונזו צ'רץ' חשבון למדה. התחביר שלהם הוא:

lambda x_1,..., x_n : expression(x_1, ..., x_n)

זה יוצר פונקציה אנונימית שמקבלת כקלט את המשתנים x_1, ..., x_n ומחזיר את המוערך expression(x_1, ..., x_n).
​
מטרת lambda יש להשתמש בפונקציות כפרמטר עבור פונקציות שמקבלות פונקציות כפרמטר, כפי שעשינו עם map() מֵעַל. Python מאפשר לך להקצות א lambda פונקציה למשתנה, אבל ה מדריך בסגנון PEP 8 מייעץ נגד זה. אם אתה רוצה להקצות פונקציה פשוטה למשתנה, עדיף לעשות זאת כהגדרה של שורה אחת. זה מבטיח שהאובייקט המתקבל נקרא כראוי, ומשפר את קריאות העקיבה:

anonymous_square = lambda x : x**2
​
def named_square(x): return x**2
​
print(anonymous_square.__name__)
print(named_square.__name__)


a = anonymous_square
b = named_square
print(a.__name__)
print(b.__name__)

למה להשתמש בפונקציות למבדה?

לאחר הפסקה האחרונה, אולי אתה תוהה מדוע תרצה להשתמש ב-a lambda פוּנקצִיָה. אחרי הכל, כל מה שאפשר לעשות עם א lambda ניתן לבצע פונקציה עם פונקציה בעלת שם.
​
התשובה לכך היא זאת lambda פונקציה מטרה זה לחיות בתוך ביטויים גדולים יותר המייצגים חישוב. דרך אחת לחשוב על זה היא באמצעות אנלוגיה עם משתנים וערכים. שקול את הקוד הבא:

x = 2

המשתנה x הוא מציין מיקום (או שם) עבור המספר השלם 2. למשל, להתקשר print(x) ו print(2) נותן בדיוק את אותו פלט. במקרה של פונקציות:

def square(x): return x**2

הפונקציה square() הוא מציין מיקום לחישוב של ריבוע מספר. חישוב זה יכול להיכתב בצורה חסרת שם כמו lambda x: x**2.
​
בעקבות הסטייה הפילוסופית הזו, בואו נראה כמה דוגמאות ליישומים עבור lambda פונקציות.
​

שימוש ב-Lambda עם הפונקציה sorted()

השמיים sorted() הפונקציה ממיינת איטרציה. הוא מקבל פונקציה בתור שלה key ארגומנט, והתוצאה של הפונקציה המוחלת על כל רכיב של ה-Iterable משמשת לסדר האלמנטים.
​
זה מתאים באופן מושלם עבור א lambda פונקציה: על ידי הגדרת ה key פרמטר עם א lambda פונקציה, אנו יכולים למיין לפי כל סוג של תכונה של האלמנטים. לדוגמה, אנו יכולים למיין רשימה של שמות לפי שם משפחה:

name_list = ['Grace Hopper', 'Ada Lovelace', 'Emmy Noether', 'Marie Curie']
​
sorted_by_surname = sorted(name_list, key = lambda x: x.split()[1])
​
print(sorted_by_surname)

['Marie Curie', 'Grace Hopper', 'Ada Lovelace', 'Emmy Noether']

שימוש ב- Lambda עם הפונקציה 'filter()'

השמיים filter() לפונקציה יש את התחביר הבא: filter(function, iterable) והוא מוציא את האלמנטים של iterable אשר מעריכים function(element) נכון (זה דומה ל-an WHERE סעיף ב-SQL). אנחנו יכולים להשתמש lambda מתפקד כפרמטרים עבור filter() כדי לבחור אלמנטים מתוך איטרציה.

שקול את הדוגמה הבאה:

num_list = list(range(0,100))
​
multiples_of_15= filter(lambda x: (x % 3 == 0) and (x % 5 == 0), num_list)
​
print(list(multiples_of_15))

[0, 15, 30, 45, 60, 75, 90]

filter() חל על lambda פונקציה lambda x: (x % 3 == 0) and (x % 5 == 0) לכל אלמנט של range(0,100), ומחזיר א filter לְהִתְנַגֵד. אנו ניגשים לאלמנטים על ידי ליהוק אותם בתור list.
​

שימוש ב-Lambda עם פונקציית ה-map()

​
הדוגמה האחרונה שלנו היא משהו שראינו במבוא - ה map() פונקציה. ה map() תחביר הפונקציה הוא: map(function, iterable), ו map() חל function לכל אלמנט של iterable, מחזיר א map אובייקט שניתן לגשת אליו על ידי השלכה ל-a list.

ראינו איך אפשר להחיל את זה על רשימות, אבל זה יכול להיות מיושם על תכתיבים באמצעות ה dict.items() שיטה:

my_data = {'Mary':1, 'Alice':2, 'Bob':0}
map_obj = map(lambda x: f'{x[0]} had {x[1]} little lamb', my_data.items())
print(', '.join((map_obj)))

Mary had 1 little lamb, Alice had 2 little lamb, Bob had 0 little lamb

או למחרוזת:

my_string = 'abcdefg'
''.join(map(lambda x: chr(ord(x)+2),my_string))

'cdefghi'

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

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

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

def number_of_words(text):
  return len(text.split())
​
def second_word(text):
  return text.split()[1]
​
def fourth_letter_of_fourth_word(text):
  return text.split()[3][3]
​
function_list = [number_of_words, second_word, fourth_letter_of_fourth_word]
​
my_text = 'Mary had a little lamb'
map_obj = map(lambda f: f(my_text), function_list)
​
feature_list = list(map_obj)
​
print(feature_list)

[5, 'had', 't']

​

סיכום

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