3.1 פונקציות הרצאה

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

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

בואו ניכנס אל זה טיפה יותר לעומק.

פונקציות

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

למה פונקציות

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

כיצד מגדירים פונקציות?

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

def add(first_argument, second_argument):
    result = first_argument + second_argument
    return result

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

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

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

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

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

result = add(5,4) # result = 9

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

def print_name():
    name = input("Hello, what is your name: ")
    print(f"your name is {name}")

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

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

ומה אם אנחנו רוצים להחזיר כמה ערכים?

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

  def get_coordinates():
      return 3, 4
  
  x, y = get_coordinates() # x = 3, y = 4
  

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

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

דוגמה: מחשבון בסיסי

def welcome():
    print("hello, welcome to my calculator!")

def add(x, y):
    return x + y

def sub(x, y):
    return x - y

def mul(x, y):
    return x * y

def div(x, y):
    return x / y

# My calculator program
welcome()
print(add(1, 3))
print(mul(5, 5))

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

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

פונקציות נקיות

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

  def add(x, y):
  
  def add(x: int, y: int) -> int: 
  

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

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

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

  def welcome() -> None:
      print("hello, welcome to my calculator!")
  
  def add(x: int, y: int) -> int:
      return x + y
  
  def sub(x: int, y: int) -> int:
      return x - y
  
  def mul(x: int, y: int) -> int:
      return x * y
  
  def div(x: int, y: int) -> int:
      return x / y
  
  
  welcome()
  print(add(1, 3)) # prints 4
  print(mul(5, 5)) # prints 25
  

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

  def add(x: int, y: int) -> int: 
      """
      Adds 2 given numbers 
      """
  

def welcome() -> None:
    """
    Welcoming the user with a warm message
    """
    print("hello, welcome to my calculator!")

def add(x: int, y: int) -> int:
    """
    Adding 2 given parametrs and return
    """
    return x + y

def sub(x: int, y: int) -> int:
    """
    Subtracting 2 given parametrs and return
    """
    return x - y

def mul(x: int, y: int) -> int:
    """
    Multiplaing 2 given parametrs and return
    """
    return x * y

def div(x: int, y: int) -> float:  
   """  
   Dividing 2 given parametrs and return result
   """
   return x / y

# My calculator program
welcome() 
print(add(1, 3))
print(mul(5, 5))

• אחרי שנוסיף type-hinting ו- docstring לפונקציה מסויימת, בPyCharm יציג לנו תיעוד של הפונקציה.
  

פונקציית מיין - main function

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

  def main():
      print("Hello World!")
      print("our code starts here !")
  
  
  if __name__ == "__main__":
      main()
  

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

  if __name__ == "__main__":
  

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

סקופ - scope

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

  def function(x):
      y = 4
      return x + y
  
  def function2():
      z = 4
      res = function(z)
      print(res)
  

בפרק הזה יש גם שאלות ותשובות, (חדש) - שימו לב שאתם עוברים על זה לפני שאתם מתחילים את התרגול :)