פונקציות - functions

פונקציות - functions

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

פונקציה יוצרים על ידי שימוש במילה def שהיא קיצור של definition (הגדרה), הבה ניצור פונקציה ונלמד להשתמש בה.

def power (n):

return (n**2)

print (power(3)) >>> 9

print(power(4)) >>> 16

הסבר לתוכנית למעלה (הכוללת את שתי השורות הראשונות) המייצרת פונקציה המקבלת משתנה n ומחזירה את ערך המשתנה בריבוע.

לאחר המילה def בחרנו שם לפונקציה שלנו (power) ובחרנו גם שם של משתנה (n). לאחר מכן נקודתיים (:), שורה מתחת מוזחת ימינה אנו רושמים מה הפונקציה שלנו תעשה עם הערך שיוזן ב- n לפני שתחזיר (return) אלינו את התוצאה. וזהו סיימנו יצרנו פונקציה בשם Power, אבל כדי שהפונקציה תעשה משהו, צריך להשתמש בה, או במילים אחרות לקרוא לה.

הקריאה לפונקציה או השימוש בפונקציה נעשה באמצעות שימוש בשם הפונקציה והזנת ערך במקום n. כך קיבלנו פונקציה פשוטה שלוקחת את הערך 3 למשל ומחזירה 9 או לוקחת את הערך 4 ומחזירה 16.

אפשר גם פונקציות בלי פרמטרים -

def printush ():

for i in range(3):

print("sababa")

printush()

>>>

sababa

sababa

sababa

בתוכנית למעלה כדאי לשים לב – שלאחר שיצרנו את הפונקציה printush (בשלוש שורות קוד) היא לא מדפיסה שום דבר עד שלא קוראים לה. הקריאה להפעלת הפונקציה מתבצעת באמצעות שם הפונקציה וסוגריים עגולים ריקים printush() לאחר הקריאה לפונקציה אנו לא צריכים לבקש print כי פעולת ההדפסה מוכלת בפונקציה שכתבנו. הפונקציה מכילה לולאת for שעוברת על טווח המספרים מ- 0 עד 3 (לא כולל 3) ובכל פעם מדפיסה את המילה sababa.

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

i=5

def printush ():

i=3

print("sababa"*i)

printush() >>> sababasababasababa

print(i) >>> 5

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

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

i=0 def printush (): global i i=3 print("sababa"*i) printush() >>> sababasababasababa print(i) >>> 3

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

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

אפשר גם לכתוב פונקציה הכוללת כמה פרמטרים -

def mul (a,b):

return (a*b)

print(mul(5,6))

>>>

30

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

היות שבפונקציה אין הוראה מובנית להדפיס אזי לא מספיק לקרוא לפונקציה, אלא צריך גם לבקש להדפיס את מה שהפונקציה מחזירה. במקרה הזה הכנסנו את 5 ו- 6 וקיבלנו 30.

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

def mul (a,b=2):

return (a*b)

print(mul(5,6)) >>> 30

print(mul(7)) >>> 14

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

פונקציה עם מספר בלתי מוגדר של פרמטרים - *args –

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

def mul(a, b,*args): m=a*b for n in args: m=n*m return m

print(mul(2,3,4,5))

>>>

120

:אפשר יותר חכם גם ככה

def mul(*args): m=1 for n in args: m*=n return m

print(mul(2,3,4,5,6))

>>>

720

בפונקציה שלמעלה המבצעת מכפלה של פרמטרים, המשתמש חייב להזין לפחות שני פרמטרים (a ו- b ) אחרת מה הקטע של מכפלה ? אבל יכול לבחור להזין גם יותר (ככל העולה על רוחו). לשם כך אנו מגדירים משתנה כללי (מילה שבחרנו במקרה הזה *args) אשר מתחילה בכוכבית. לא לבלבל עם כוכבית של כפל, כאן המשמעות שונה. משתנה כללי המתחיל בכוכבית בעצם מייצג כמות בלתי מוגבלת של משתנים נוספים (או כלום), אשר הלולאה for שבפונקציה מגדירה מה לעשות איתם. והיא קובעת שכל מספר שנזין בפונקציה חוץ מהשניים הראשונים, יוכפל גם הוא בתוצאת המכפלה של שני הפרמטרים הראשונים. לבסוף אנו מבקשים מהפונקציה להחזיר את הערך שהתקבל במשתנה הזמני m שיצרנו לשם כך, ואשר יכלול בסוף התהליך את מכפלת כל המספרים שהעברנו בפונקציה 2*3*4*5 שווים ל- 120.

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

אפשר להשתמש גם לצורך הכנסת פרמטר מילולי (מחרוזת) -

def names(a, b,*args): m=a+" "+b for n in args: m= m+" "+n return m

print(names("eddie","arbili", "the","author"))

>>>

eddie arbili the author

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

def dic(**kwargs): for k,v in kwargs.items(): if v<=27: print(f"{k} is {v} years old - just a kid") elif v > 27: print(f"{k} is {v} years old - an adult") dic(moshe=25,baruch=49,nitzan=19)

>>>

moshe is 25 years old - just a kid

baruch is 49 years old - an adult

nitzan is 19 years old - just a kid