פרק קודם:

מה נלמד

• שימוש בפונקציות כחשיבה בלוגיקה
• פונקציות כיחידות לוגיות בזיכרון
• מה הן למבדות - Lambdas
• כיצד כותבים למבדות
• שימושים עיקריים

פונקציות כחשיבה לוגית

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

1
2
3
4
5

def Add(a,b):
    return a+b  

a = Add      
a(1,2)          

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

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

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

איך ניתן להסתכל על זה:

יש לנו פרמטר a אשר לוקח לעצמו את Add.
קריאה ל-a בעצם קורא ל-Add.

אם נשווה את העצמים עצמם - a ו-Add נוכל לראות שהם זהים:

מזה נוכל להבין שהפונקציה המקורית לא שוכפלה, בעצם a מצביע לפונקציה המקורית.

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

מה הן למבדות

למבדה - Lambda היא פונקציה אנונימית - ללא שם.

כותבים למבדה אך בד”כ לא אומרים את ה-“ב”.

למשל בהגדרת הפונקציה הזו יש לנו שם:

1
2

def Add(a,b):
    return a+b

כתיבת למבדות

התחביר הוא:

1

lambda a,b: a + b

כמו שראינו ניתן לשים למבדות במשתנים וכך לתת להם שם:

1
2

add = lambda a,b: a+b   
add(1,2)                

ניתן להחזיר למבדות מפונקציות (תזכרו את העקרון הזה לפרק הבא!).

1
2
3
4
5
6
7
8
9
10
11

def SelectFunction(command):
    if command == 'print':
        return lambda a : print(a)
    if command == 'exit':
        return lambda : exit()

func = SelectFunction('print')
func('Hello World')

exitFunc = SelectFunction('exit')
exitFunc()

תרגיל

1. תחשבו על מקרים בו נרצה להחזיר פונקציה מפונקציה.

2. תחזרו לפרק 9, כעת נשכתב את הקוד הזה בעזרת למבדות.

1
2
3
4
5
6

def SortBy(element):
    return len(element) # חייב להחזיר מספר!  

arr = ['AAA','AA', 'AAAA','A']
arr.sort(key = SortBy)
print(arr)

3. בעזרת למבדות כתבו תכנית מחשבון פשוטה שיודעת לעבד את התווים: +, -, *, /
   חיבור, חיסור כפל וחילוק בהתאמה.

1
2
3
4

sortBy = lambda element : len(element)
arr = ['AAA','AA', 'AAAA','A']
arr.sort(key = sortBy)
print(arr)

1

['A', 'AA', 'AAA', 'AAAA']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import re

def SelectCalculation(symbol):
    if symbol == '+':
        return lambda a,b: a + b
    if symbol == '-':
        return lambda a,b: a - b
    if symbol == '/':
        return lambda a,b: a / b # Caution - divide by 0.  
    if symbol == '*':
        return lambda a,b: a * b

calcStr = input('Write your calculation: ')
calcRegex = '([0-9]+).*([+-///*]).*([0-9]+)'
match = re.search(calcRegex, calcStr)
if match == None:
    print("Couldn't detect a calculation string")
    exit()

a = match.group(1)
firstNum = int(match.group(1))
symbol = match.group(2)
secondNum = int(match.group(3))

calculationMethod = SelectCalculation(symbol)

result = calculationMethod(firstNum, secondNum)
print(result)

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

בפרק הבא אנחנו נלמד על פיצ’ר מאוד חשוב - ה-Decorator.
ובכך נעלה את יכולות תכנות הפונקציות שלנו.