פונקציות בפייטון - חלק 1
def, שם וסוגריים, והקוד נכתב בהזחה. השימוש בפונקציות מונע כתיבה חוזרת של אותו קוד, ומאפשר מודולריות ברמות שונות של התוכנית.None. ניתן להחזיר כמה ערכים בפסיקים, והם מתקבלים כטאפל שניתן לגשת לכל איבר בו לפי אינדקס.def f(a, b=4) מאפשר לקרוא לפונקציה בלי לציין את הפרמטר השני, ואז הוא מקבל 4.f(a=1, b=6). הסדר אז אינו חשוב, והקוד נעשה קריא יותר.*args מקבל מספר לא ידוע של ארגומנטים כטאפל, ו-kwargs מקבל ארגומנטים בשם כמילון. הסדר הנכון הוא: פרמטרים רגילים, אחריהם *args, ואז kwargs.None ולהגדיר בתוך הפונקציה רשימה חדשה.פרקי ההרצאה: פונקציות בפייטון - חלק 1
תמלול ההרצאה: פונקציות בפייטון - חלק 1
הטקסט המלא של הדקות הראשונות בהרצאה «פונקציות בפייטון - חלק 1» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
שלום לכולם, בשיעור הזה נדבר על פונקציות בפייתון. דבר ראשון, פונקציה זה אוסף של קוד, שהמטרה שלו לעשות פעולה מסוימת, יותר ספציפית וקטנה.
למה אנחנו עושים פונקציות? זה כדי שנוכל לעשות Usability לקוד. כלומר, אם נגיד אנחנו רוצים לבדוק את הסכום של שני מספרים, אם נעשה את זה כל פעם שאנחנו נצטרך לבדוק את הסכום שלהם, אז הקוד שלנו יהיה מאוד ארוך.
לעומת זאת, אם יהיה לנו בלוק של קוד שאנחנו יכולים להגיד לו, מחזיר לי את הסכום של שני המספרים, אז הקוד שלנו יהיה הרבה יותר קצר.
אז בעצם כל הקטע של פונקציות זה כחלק מתוכניות, תכנות לעשות מודולריות לקוד שלנו. כלומר, יש לנו מודולריות ברמת הפונקציה, ברמת האובייקט, אם זה Object Oriented, ברמת המודול וברמת התוכנה, וככה אנחנו יכולים לעשות Usability ברמות שונות
בקוד שלנו. עכשיו, פייתון פונקציה מוגדרת מאוד בקלות על ידי המילה השמורה def ואז השם של הפונקציה שזה יכול להיות נגיד בשביל הדוגמה sum2 בעצם הוא התחיל בדוגמה יותר פשוטה מייברינט שהיא מקבלת איזשהו אובייקט וכל מה שהיא תעשה היא תדפיס אותו למסך ואם אנחנו רוצים לקרוא לפונקציות פשוט
טוב מייברינט ואת האובייקט שאנחנו רוצים לקרוא לו עכשיו אנחנו רוצים להדפיס למסך "hello world" אם נריץ את הדבר הזה על ידי השולש פה.
זהו, קראנו לפונקציה. אבל פונקציה בפייתון זה דבר הרבה יותר מסובך. פונקציה יכולה, חוץ מלקבל פרמטרים, היא יכולה גם להחזיר פרמטרים.
היא יכולה גם לא לקבל פרמטרים בכלל, דרך אגב. יכולתי לכתוב, למחוק פה את ה-st, שם פה להדפיס, צריך להעיף את הפרמטר מכאן, כי בעצם אין התאמה בין הקריאה לפונקציה לבין הפרמטרים שהיא מקבלת, וזהו בוא נעשה משהו קצת יותר מתוך בוא נעשה
גם פונקציה שמחזירה ערך נגיד פונקציה שמקבלת a וb והיא מחזירה piece את a ועוד b וגם תחזיר את a ועוד b אני יכול לקרוא 1, 2 למשל ואני אקבל 3 שנייה רגע בוא נעשה c כזה print אפשר לראות גם את התוצאה שהמיין שלנו יחזיר כלומר שהסקריפטר הראשי שלנו יחזיר את התוצאה פונקציה כמו שאנחנו רואים יש לנו את הקוד מתחיל בהגדרה של
הפונקציה היא לא רצה אבל פייטון מגדיר אותה הוא רואה שיש לנו פה בייק שנקרא מייברינט שמקבל a וb לאחר מכן הוא רואה שיש פה קריאה לפונקציה הוא קורא לה בתוך הפונקציה הוא מדפיס את a ועוד b הוא מחזיר את a ועוד b ולאחר מכן הוא מדפיס את התוצאה מחוץ הפונקציה נגמרת כמו כל דבר אחר בפייטון לפי הזכות,
כלומר אם הייתי כותב פה עוד איזשהו שורה זה היה עדיין חלק מהפונקציה שלי, אבל מכיוון שהשורה שלאחר מכן היא נמצאת ארבעה ספייסים אחורנית זה כבר לא חלק מהפונקציה.
שימו לב שאני לא אמרתי לפונקציה מה זה a ועוד b, זה בעצם דבר שהוא נכון לכל פייתון, אז אם אני אתן לפונקציה הזאת ערכים לא תקינים אני אקבל פה תוצאות קצת לא צפויות כמו exception, כי אני בעצם לא יכול, אני לא יכול לחבר סטרינג
ואינט. על הדבר הזה אפשר להתגבר מאוד בקלות. אפשר פשוט לעשות if type של a שונה מ-type b. אז אחרת, פונקציה שבהגדרה לא מחזירה כלום בעצם מחזירה נאן.
בואו נראה מה קורה עכשיו. אני רק אענה לך אם זה שווה. my function returns none, כי בעצם אי אפשר לחבר אחד סטרינג ואינטג'ר. איינטון היא לא שפה שמנסה לעשות לך המרות אוטומטיות בניגוד לשפות אחרות שכן מנסות לעשות את זה.
פונקציה גם יכולה להחזיר כמה פרמטרים. למשל, בואו נכתוב פונקציה שמקבלת a וb ומחזירה גם את הסכום שלהם וגם את הכפל שלהם. אז כל מה שצריך לעשות זה return a ועוד b, ולא צריך סוגריים, a ועוד b פסיק a כפול b למשל, ואז בונים הם ה-utpass 3 ו-2 כי 1 ועוד 2 3, פול שתיים זה שתיים בעצם c זה טאפל קיבלנו חזרת טאפל שים לב שc לא
יכול להשתנות אם נעשה c במקום האפס שווה אחד נקבל שגיאה כי הוא לא יכול להשתנות שימו לב שבגלל שc הוא טאפל אפשר לגשת אליו עם אינדקסים מהי function return זה יכול לעשות c במקום האפס return sum function return אפשר לכתוב כזה דבר סאם איז, מולטי פליינג, מולי על האנגלית, איז
ואינדקס אחד וקיבלנו שני הערכים מהפונקציה שלנו. שימו לב שלפונקציה בספייטון יכול להיות גם ערך דיפולטיבי. למשל, a, b שווה 4. אם נריץ את הקוד כך, לא יהיה שום הבדל.
אם נמחוק את 2, הקוד הזה עדיין יהיה תקין ו-b יהיה שווה 4, אנחנו בעצם נתנו את a ו-b הוא ייקח מהערך הדיפולטיבי שהוא 4. כמו כן אפשר בקריאה לפונקציה לכתוב a שווה זה בעצם אותו דבר אבל אז אפשר לעשות a שווה 1, b שווה 6. שימו לב שזה לא משנה הסדר של a וb פה, אפשר לעשות b שווה 6 ואז a שווה 1, זה עדיין יעבוד.
היתרון בזה זה א' הקוד הרבה יותר קריא, כלומר שאני רואה אם הפונקציה לא נמצאת ליד הקריאה אליה וזה בדרך כלל המצב, פונקציה מוגדרת בקובץ אחד, לפעמים בתיקייה אחרת גם, והקריאה לפונקציה, או יותר נכון הקריאות לפונקציה נמצאות במקום אחר.
ואתה צריך, אוקיי, יש לי את הפונקציה הזאת, מה הפרמטר הראשון, מה הפרמטר השני, וככה זה קצת יותר מקל. כמובן שזה יותר מקל בערכים שהם עם שמות יותר הגיוניים. עכשיו אנחנו נתקן את זה גם.
נשתמש ב-re-factoring שלנו. נחליק עם אני. כמובן שעכשיו הקוד יהיה הרבה יותר קריב, ואני לא באמת צריך את החתימה של הפונקציה לדעת מה יש פה.
יותר מזה, אם החתימה של הפונקציה השתנתה, נגיד עכשיו הפונקציה כבר לא מקבלת מספרים, היא מקבלת סטרינג. אם אני אדאג לכתוב את זה כמו שצריך, כבר לא יעבוד, אני אקבל אקספצ'ן, ואני אבין שהפונקציה שלי כבר השתנתה, ולכן אני לא יכול...
סטרינג, סטרינג, סטרינג. עכשיו, אם אני אריץ את הקוד שלי, אני רואה שהפונקציה קיבלה Unexpected Keyword Argument, כלומר הפונקציה קיבלה number 2 וnumber 1 והיא לא יודעת איפה number 1 נמצא, הוא לא נמצא בחתימה של הפונקציה ולכן קיבלנו exception.
ככה בעצם חסכנו לנו בעיה, כי היה לנו איזושהי פונקציה שקיבלה מספר מסוים של פרמטרים עם שמות משמעותיים והיא עשתה עליהם איזשהו חישוב.
אם אנחנו משנים את אחד מהשמות של הפונקציה, אז כל מי שמשתמש בפונקציה עם השמות, אז הוא לא יטעה ויחשוב ויהיה יותר קל למצוא באגים ככה. חשוב לשים לב לסדר של הפרמטרים.
למה אני מתכוון? זה רגע את המצב. אז אני לא יכול לעשות כזה דבר, כי מה שקורה פה, פייתון מנסה להבין איזה ארגומנט בקריאה לפונקציה מתאים לאיזה פרמטר בחתימה של הפונקציה.
אז היא אומרת, אוקיי, אין לי פה בהתחלה שום דבר, המספר 6 כנראה מתאים ל-number 1. ואז היא אומרת, אוקיי, ועכשיו יש לי אבל number 1 ששווה ל-1, אבל number 1 אני כבר אמרתי שהוא 6, אני לא יודעת מה לעשות, Exception.
קיבלתי Multiple Values for Keyword Arguments. לכן, דבר ראשון, אם אתם רוצים להשתמש ב-Keyword Arguments, אז א', הם חייבים להיות בסוף, כלומר, גם הדבר הזה לא יעבוד.
יש סדר לדברים. ודבר שני, אתם צריכים לשים לב שאין לכם בטעות, כמו שהיה לי מקודם, שאתם קוראים לאותו משתנה פעמיים, פעם דרך הערך שלו ופעם דרך שימוש מיוחד מסוים בשם שלו.
פייתון מאפשרת עוד דבר. אתם רוצים לשלוח ליסט לפונקציה ושהליסט הזה ייפתח. למה אני מתכוון? נגיד יש לי ליסט, יש בתוכו תארכים 1 ו-7 ואני רוצה לשלוח אותו לפונקציה.
אז הדבר הפשוט שאני יכול לעשות זה לכתוב lst0 ו-lst1 וזה היה עובד, אבל אם נגיד יש לי ליסט של עשרה פרמטרים ויכולת להיות פונקציה של עשרה פרמטרים, זה קצת מעצבן לכתוב list 1, 0, 1, 2, 3.
אז אפשר פשוט לכתוב חבית lst, וזה בעצם אומר לפייתון, תעשה unpacking ל-list. כלומר, תשלח כללית, אבל אל באמת תשתמש בו, אל באמת תשלח אותו בתור פרמטר לערך הראשון, אלא תעשה לו unpacking.
מה עוד אנחנו יכולים לעשות פה? בוא נגיד שיש לנו גם number 3, ואנחנו רוצים להוסיף גם פה number 3 לפה, אני יכול להגיד אוקיי אני רוצה שהערך הראשון יהיה שלוש ואת שאר הערכים תעשה unpack לליסט שלי וזה יעבוד אז כמה דגשים דבר ראשון חשוב שהאורך של הליסט יתאים לאורך של מספר הארגומנטים בפונקציה למשל אם אני אוסיף פה איזשהו ערך אז זה לא יעבוד
אני מקבל פה בעיה הוא אומר שמייפרינט ציפתה לקבל שלושה ארגומנטים אבל וקיבלתי 4. דבר נוסף זה, שימו לב למה זה חוסך לנו.
אם הייתי רוצה לשלוח עכשיו שלושה פרמטרים מהליסט הזה, כל מה שהייתי צריך לכתוב LST, ואז LST 1, ואז LST 2. כל זה אני יכול להחליף פשוט על ידי חובית LST. עכשיו בואו נניח שאנחנו רוצים לקבל פונקציה שמקבלת מספר משתנה של פרמטרים.
תגידו למה זה טוב. אני אגיד לכם, הנה בשביל זה זה טוב. אני רוצה עכשיו לכתוב פונקציה שמקבלת מספר משתנה של פרמטרים, מחזירה את הסחור שלהם, אני לא יודע כמה פרמטרים אני אקבל, אני לא רוצה עכשיו להכין פונקציה עם עשרות פרמטרים.
כל מה שצריך לעשות זה פשוט להוסיף פה כוכבית בארקס, וזה אומר שבעצם אנחנו מקבלים פה מספר מסוים