איך להגדיר פונקציות ב-Python 3

הקדמה

A function is a block of instructions that performs an action and, once defined, can be reused. Functions make code more modular, allowing you to use the same code over and over again.

יש ל-Python מספר פונקציות מובנות שאולי אתה מכיר, כוללות:

• print() שתדפיס אובייקט לטרמינל
• int() שיהפוך סוג נתונים ממחרוזת או מספר לסוג נתונים של מספר שלם
• len() שתחזיר את האורך של אובייקט

שמות הפונקציות כוללות סוגריים ועשויות לכלול פרמטרים.

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

דרישות מוקדמות

עליך להתקין Python 3 ולהגדיר סביבת תכנות במחשב או בשרת שלך. אם אין לך סביבת תכנות מוגדרת, תוכל לעיין במדריכי התקנה והגדרה עבור סביבת תכנות מקומית או עבור סביבת תכנות על השרת שלך המתאימה למערכת ההפעלה שלך (אובונטו, סנטוס, דביאן, וכו').

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

נתחיל עם המרת התוכנית הקלאסית של "שלום, עולם!" לפונקציה.

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

A function is defined by using the def keyword, followed by a name of your choosing, followed by a set of parentheses which hold any parameters the function will take (they can be empty), and ending with a colon.

במקרה זה, נגדיר פונקציה בשם hello():

def hello():

זה יוצר את ההצהרה הראשונית ליצירת פונקציה.

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

def hello():
    print("Hello, World!")

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

לכן, מחוץ לבלוק הפונקציה שלנו, נקרא לפונקציה עם hello():

def hello():
    print("Hello, World!")

hello()

כעת, נריץ את התוכנית:

python hello.py

תקבלו את הפלט הבא:

Output
Hello, World!

הפונקציות עשויות להיות יותר מורכבות מהפונקציה hello() שהגדרנו למעלה. לדוגמה, אנו יכולים להשתמש בלולאות for, הצהרות תנאי ועוד בתוך בלוק הפונקציה שלנו.

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

# הגדרת הפונקציה names()
def names():
    # הגדרת משתנה name עם הקלט
    name = str(input('Enter your name: '))
    # בדיקה האם name מכיל תו קרוא
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')

    # עבור על name
    for letter in name:
        print(letter)

# קריאה לפונקציה
names()

הפונקציה names() שהגדרנו למעלה מגדירה הצהרת תנאי ולולאת for, מראה כיצד קוד יכול להתארגן בתוך הגדרת פונקציה. אולם, בהתבסס על מה שאנו מתכוונים לעשות עם התוכנית שלנו ואיך נרצה להגדיר את הקוד שלנו, יתכן כי נרצה להגדיר את ההצהרת התנאי ואת לולאת for כפונקציות נפרדות.

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

עבודה עם פרמטרים

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

A parameter is a named entity in a function definition, specifying an argument that the function can accept.

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

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    print(a, b, c)

add_numbers(1, 2, 3)

עברנו את המספר 1 לתוך הפרמטר x, 2 לתוך הפרמטר y, ו־3 לתוך הפרמטר z. ערכים אלו תואמים לכל פרמטר בסדר שבו הם ניתנים.

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

a = 1 + 2
b = 1 + 3
c = 2 + 3

הפונקציה גם מדפיסה את a, b, ו־c, ובהתבסס על החישובים לעיל ציפינו ש־a תהיה שווה ל־3, b תהיה 4, ו־c תהיה 5. בואו נפעיל את התוכנית:

python add_numbers.py

Output
3 4 5

כאשר אנו מעבירים 1, 2, ו־3 כפרמטרים לפונקציית add_numbers(), אנו מקבלים את הפלט הצפוי.

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

ארגומנטים מזהים

בנוסף לקריאה לפרמטרים בסדר, ניתן להשתמש בארגומנטים מזהים בקריאת פונקציה, שבה הקורא מזהה את הארגומנטים לפי שם הפרמטר.

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

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

# הגדר פונקציה עם פרמטרים
def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

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

עכשיו, נוכל לקרוא לפונקציה ולהקצות לה פרמטרים:

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# קריאה לפונקציה עם פרמטרים שהוקצו כמצויין לעיל
profile_info("sammyshark", 945)

# קריאה לפונקציה עם ארגומנטים מזהים
profile_info(username="AlexAnglerfish", followers=342)

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

בואו נריץ את התוכנית:

python profile.py

Output
Username: sammyshark
Followers: 945
Username: AlexAnglerfish
Followers: 342

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

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

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# שינוי סדר הפרמטרים
profile_info(followers=820, username="cameron-catfish")

כאשר אנו מפעילים שוב את התוכנית עם פקודת python profile.py, נקבל את הפלט הבא:

Output
Username: cameron-catfish
Followers: 820

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

ערכי ארגומנטים ברירת מחדל

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

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

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

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

profile_info(username="JOctopus")
profile_info(username="sammyshark", followers=945)

כאשר אנו מפעילים את התוכנית עם פקודת python profile.py, נקבל את הפלט הבא:

Output
Username: JOctopus
Followers: 1
Username: sammyshark
Followers: 945

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

החזרת ערך

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

A function can produce a value with the return statement, which will exit a function and optionally pass an expression back to the caller. If you use a return statement with no arguments, the function will return None.

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

בקובץ טקסט חדש בשם square.py, ניצור תוכנית שמרובעת את הפרמטר x ומחזירה את המשתנה y. אנו משתמשים בקריאה להדפסת המשתנה result, אשר נוצרת על ידי הרצת הפונקציה square() עם 3 שנשלח אליה.

def square(x):
    y = x ** 2
    return y

result = square(3)
print(result)

אנו יכולים להריץ את התוכנית ולקבל את הפלט:

python square.py

Output
9

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

כדי להבין עוד יותר איך פקודת return עובדת, אפשר להעריך את הפקודה return מתוך התוכנית:

def square(x):
    y = x ** 2
    # return y

result = square(3)
print(result)

כעת, בוא נריץ שוב את התוכנית:

python square.py

Output
None

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

כדוגמת נוספת, בתוכנית add_numbers.py למעלה, הייתה אפשרות להחליף את ההצהרת print() בהצהרת return.

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    return a, b, c

sums = add_numbers(1, 2, 3)
print(sums)

מחוץ לפונקציה, הגדרנו את המשתנה sums כשווה לתוצאת הפונקציה שמקבלת את הפרמטרים 1, 2, ו־3 כפי שעשינו למעלה. לאחר מכן קראנו להדפסה של המשתנה sums.

בואו נריץ את התוכנית שוב כעת שיש בה הצהרת return:

python add_numbers.py

Output
(3, 4, 5)

אנו מקבלים את אותם מספרים 3, 4, ו־5 כפלט שקיבלנו קודם באמצעות הצהרת print() בפונקציה. הפעם הם מועברים כ־tuple מכיוון שלרשימת הביטויים של ההצהרה של return יש לפחות פסיק אחד.

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

def loop_five():
    for x in range(0, 25):
        print(x)
        if x == 5:
            # עצירת פונקציה כאשר x == 5
            return
    print("This line will not execute.")

loop_five()

שימוש בהצהרת return בתוך לולאת for מסיים את הפונקציה, לכן השורה שנמצאת מחוץ ללולאה לא תרוץ. אם, במקום זאת, היינו משתמשים ב־break statement, רק הלולאה הייתה יוצאת באותו זמן, והשורה האחרונה של print() הייתה רצה.

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

שימוש ב־main() כפונקציה

אף על פי שב־Python ניתן לקרוא לפונקציה בתחתית התכנית והיא תרוץ (כפי שעשינו בדוגמאות למעלה), הרבה שפות תכנות (כמו C++ ו־Java) דורשות פונקצית main כדי להריץ. כל עוד לא חובה, כלול פונקצית main() יכול למיין את תכניות ה־Python שלנו בדרך לוגית שמקנה את הרכיבים החשובים ביותר של התוכנית בפונקציה אחת. זה יכול גם להפוך את התוכניות שלנו לנוחות יותר לקריאה על ידי מפתחים שאינם מכירים Python.

נתחיל עם הוספת פונקצית main() לתוכנית hello.py למעלה. נשמור על הפונקציה hello(), ואז נגדיר פונקצית main():

def hello():
    print("Hello, World!")

def main():

בתוך הפונקציה main(), נכלול הצהרת print() כדי ליידע אותנו שאנחנו נמצאים בפונקציה main(). בנוסף, נקרא לפונקציה hello() בתוך הפונקציה main():

def hello():
    print("Hello, World!")


def main():
    print("This is the main function")
    hello()

לבסוף, בתחתית התוכנית נקרא לפונקציה main():

def hello():
    print("Hello, World!")

def main():
    print("This is the main function.")
    hello()

main()

בנקודה זו, נוכל להריץ את התוכנית שלנו:

python hello.py

נקבל את הפלט הבא:

Output
This is the main function.
Hello, World!

מכיוון שקראנו לפונקציה hello() בתוך main() ואז קראנו רק ל־main() כדי להריץ, הטקסט Hello, World! נדפס רק פעם אחת, אחרי המחרוזת שאמרה לנו שאנחנו בתוך הפונקציה הראשית.

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

בפייתון, '__main__' הוא שם התחום שבו קוד ברמה עליונה ירוץ. כאשר תוכנית מופעלת מקלט סטנדרטי, סקריפט, או מהפקת פקודה אינטראקטיבית, ה־__name__ שלה מוגדר להיות שווה ל־'__main__'.

בשל זה, קיימת הסכמה להשתמש בבנייה הבאה:

if __name__ == '__main__':
    # קוד להרצה כאשר זה התוכנית הראשית כאן

זה מאפשר לקבצי התוכנית לשמש או:

• כתוכנית ראשית ולהריץ מה שאחרי ההצהרה if
• כמודול ולא להריץ מה שאחרי ההצהרה if.

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

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

הפונקציה הראשונה, has_vowel(), תבדוק האם מחרוזת ה־name מכילה תו קריאה.

הפונקציה השנייה print_letters() תדפיס כל אות של מחרוזת ה־name.

# הכרזה על משתנה גלובלי name לשימוש בכל הפונקציות
name = str(input('Enter your name: '))


# הגדרת פונקציה לבדיקה האם שם מכיל תו קריאה
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# לולאה על אותיות במחרוזת name
def print_letters():
    for letter in name:
        print(letter)

עם זהות התקנה זו, נגדיר את הפונקציה main() שתכיל קריאה לפונקציות has_vowel() ו־print_letters().

# הכרזה על משתנה גלובלי name לשימוש בכל הפונקציות
name = str(input('Enter your name: '))


# הגדרת פונקציה לבדיקה האם שם מכיל תו קריאה
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# לולאה על אותיות במחרוזת name
def print_letters():
    for letter in name:
        print(letter)


# הגדרת הפונקציה הראשית שקוראת לפונקציות אחרות
def main():
    has_vowel()
    print_letters()

לבסוף, נוסיף את ה־בניין if __name__ == '__main__': בתחתית הקובץ. לצרכינו, מאחר שהוספנו את כל הפונקציות שברצוננו להריץ בתוך הפונקציה main(), נקרא לפונקציה main() לאחר מכן לאחר פקודת if זו.

# הכרז על משתנה גלובלי לשימוש בכל הפונקציות
name = str(input('Enter your name: '))


# הגדר פונקציה לבדיקה אם השם מכיל תו ווקאלי
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# חזור על אותיות במחרוזת השם
def print_letters():
    for letter in name:
        print(letter)


# הגדר את השיטה הראשית שקוראת לפונקציות אחרות
def main():
    has_vowel()
    print_letters()


# בצע את הפונקציה main()
if __name__ == '__main__':
    main()

כעת ניתן להריץ את התוכנית:

python more_names.py

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

אם לא רצית להכריז על פונקציה main(), אפשר הייתה לסיים את התוכנית כך:

...
if __name__ == '__main__':
    has_vowel()
    print_letters()

שימוש ב־main() כפונקציה ובהצהרת if __name__ == '__main__': יכול לארגן את הקוד שלך בדרך לוגית, ולעשות אותו קריא ומודולרי.

סיכום

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

איך לכתוב מודולים ב-Python 3