פגישה 9 - פונקציות ומשתנים מקומיים

שיעורון ה' - לפונקציה שלי שלוש קריאות...

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

      >>> def my_function():
      ...     print "this is my function"
      ... 
      

  וכדי להפעיל את הפונקציה:

      >>> my_function()
      this is my function
      

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

• ניקח פונקציה מורכבת יותר, המציירת מעין כוכב על המסך:

      >>> def print_stars():
      ...     print " *"  
      ...     print "* *"
      ...     print " * "
      ... 
      

  כעת ניתן להדפיס כמה כוכבים בקלות:

      >>> print_stars(); print_stars() 
       *
      * *
       * 
       *
      * *
       * 
      

  (סימן ה-; (נקודה פסיק) משמש להפרדה בין שתי פקודות באותה השורה).

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

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

       def print_n_stars(i):
           while i > 0:
               print "*",
               i = i - 1
           print ""
      

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

      >>> print_n_stars(1)
      *
      >>> print_n_stars(5)
      * * * * *
      

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

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

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

       def add_one(i):
           return i + 1
      

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

      >>> print add_one(5)
      6
      >>> i = add_one(7)
      >>> print i
      7
      

• שימו לב: אם הפונקציה אמורה להחזיר מספר, אבל השתמשנו בה בביטוי המצפה למחרוזת - נקבל שגיאה:

      >>> str = "5 plus 1 is " + add_one(5)
      Traceback (most recent call last):
        File "<stdin>", line 1, in ?
      TypeError: cannot concatenate 'str' and 'int' objects
      

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

כלי קטן - טווחים

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

      >>> range(0, 10)
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      

  (קבוצת המספרים בין אפס לעשר, לא כולל עשר).

      >>> range(0, 10, 2)
      [0, 2, 4, 6, 8]
      

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

      >>> i = 0          
      >>> for j in range(0, 10):
      ...     i = i + j
      ... 
      >>> print i
      45
      

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

משחק חמישי - צייר לי משולש, או ריבוע, או משהו...

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

            *
            **
            ***
            *****
            ******
            *******
            ********
            *********
           

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

שיעורון ו' - משתנים מקומיים - מבחוץ ומבפנים.

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

      >>> def confusion(i):
      ...     i = i + 1
      ...     print "i: ", i
      ... 
      >>> i = 3
      >>> confusion(i)
      i:  4
      >>> print i
      3
      

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

שימוש שגוי במשתנה אחד לשתי מטרות

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

      >>> i = 0
      >>> while i < 2:
      ...     for i in range(0, 2):
      ...         print "*",
      ...     print
      ...     i = i + 1
      ... 
      * *
      

  (התוכניתן רצה להדפיס ריבוע של 2 כוכביות על 2 כוכביות. בפועל, הודפסה שורה אחת בלבד).

שימוש במשתנים מקומיים

• עכשיו נראה את אותו הדבר, בעזרת פונקציה:

      >>> def print_stars(i):
      ...     for i in range(0, i):
      ...         print "*",
      ...     print
      ... 
      >>> i = 0
      >>> while i < 2:
      ...     print_stars(2)
      ...     i = i + 1
      ... 
      * *
      * *
      

עוד על משתנים מקומיים

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

משחק שישי - "כמה דני..." - תוכנית למבלבלים מתחילים.

• משחק שבא לבחון מי מתבלבל יותר מהר.
• כיתבו תוכנית שכל המשתנים בה נקראים "דני" (danny).
• התוכנית צריכה לבצע משהו שימושי...
• ...והמדריכים יצטרכו לנחש מה היא עושה.
• נראה מי יתבלבל יותר - אתם או המדריכים...

נכתב על ידי גיא קרן