פונקציות

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

פונקציות הן כוח משמעותי בשפות פיתוח. נניח שאנחנו רוצים ליצור מחשבון. אנחנו צריכים לאפשר הכנסה של 2 מספרים ופעולה (חיבור, חיסור וכו') ולקבל את התוצאה. בכל פעם יהיו שני מספרים שונים ופעולה שונה, איך אפשר לעשות את זה?

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

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

הגדרת פונקציה

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

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

# Defining the function
def greet_hello_world(): 
  print('hello world')

# Calling the function
greet_hello_world()

העברת פרמטרים לפונקציה

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

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

קריאה לפונקציה תהיה תמיד עם סוגריים.

def call_a_name():
    name = "danny"
    print(name)

name = "betty"
print(name)

call_a_name()

print(name)

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

def multiplier(input_num, input_multiplier):
  result = input_num * input_multiplier
  print(result)

multiplier(3, 5)

החזרת ערך מפונקציה

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

def multiplier(input_num, input_multiplier):
  result = input_num * input_multiplier
  return result

# Using the return value in the print function
print(multiplier(3, 5))

# Storing the function returned value and then using it
multiplier_result = multiplier(3, 5)
print(multiplier_result)

# Reusing the function
multiplier_result = multiplier(10, 5)
print(multiplier_result)

החזרת מספר ערכים מפונקציה

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

def power_fn(input_num):
  squared = input_num ** 2
  cubed = input_num ** 3
  return squared, cubed

squared_returned_value, cubed_returned_value = power_fn(5)
print(squared_returned_value, cubed_returned_value)

פרמטרים אופציונלים

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

def multiplier(input_num, input_multiplier = 5):
  result = input_num * input_multiplier
  return result

# Passing 2 params to the function
multiplier_result = multiplier(3, 10)
print(multiplier_result)

# Passing 1 param to the function, the default value will be used for the second one
multiplier_result = multiplier(3)
print(multiplier_result)

פונקציית lambda

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

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

# Regular function
def multiply_by_ten(num):
  return num * 10

print(multiply_by_ten(10)) # prints 100

###########################################

# lambda function
multiply_by_ten_lambda = lambda num: num * 10

print(multiply_by_ten_lambda (10)) # prints 100

שימוש ב-lambda כקלט לפונקציות אחרות

שימוש נפוץ ב-lambda הוא כקלט של פונקציות מובנות.

בדוגמא יש לנו רשימת ציונים, אנחנו רוצים לקבל רשימה חדשה ובה יהיו רק הציונים הגדולים מ-35. הפונקציה filter עוברת על ערכי הרשימה. היא מעבירה כל ערך לפונקציה lambda הפנימית לה. פונקציית ה-lambda מחזירה true אם הערך שעבר אליה גדול מ-35 ופונקציית filter יודעת שהערך שייך לרשימה החדשה שהיא בונה.

grades = [45, 89, 34, 67, 90, 55, 98, 35, 12, 84]
passing_grades = list(filter(lambda grade: grade > 35, grades))
print(passing_grades)

מודולים

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

ספריית datetime

ספריית datetime נותנת מענה לשימוש בתאריכים וזמנים.

import datetime

# Get today date
today = datetime.datetime.now()
print(today)

current_date = datetime.date.today()
print(current_date)

current_time = datetime.time(11,59, 30)
print(current_time)

ספריית random

ספריית random מייצרת מספרים אקראיים. המספרים לא באמת אקראיים ותלויים ב-seed.

from random import *
import random

# define the seed value to be used for generating random numbers
random.seed(31)
print(random.random())

# Pick a random number between 1 and 100.
print(randint(1, 100))

כדי שהמספרים יהיו יותר אקראיים, אפשר לשים seed רנדומלי ואותו לשים כ-seed.

from random import *
import random

# define the seed value to be used for generating random numbers
r_seed = random.seed(10)
random.seed(r_seed)
print(random.random())

# Pick a random number between 1 and 100.
print(randint(1, 100))

עבודה עם קבצים

לפייתון יש אפשרות ליצור קבצים, לעבור על התוכן שלהם, לבטל אותם וכו'

with open('somefile.txt') as file_object:
  print(file_object)

# Read file lines
with open('story.txt') as story_object:
  print(story_object.readline())

# Append to file
with open('shopping.txt', 'a') as shop:
  shop.write('Tomatoes, cucumbers, celery\n')

# Write to file, all prev content will be erased
with open('diary.txt','w') as diary:
  diary.write('Special events for today')