לולאות, פונקציות חוקים יבשים?

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

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

לולאות מה איתן?
ניתן לבצע כמה פעולות באותה אחת (באפשרויות שניתן לנו כי זה True or False)?
ניתן לשים בה קלט מתי שאני רוצה?
ניתן לשים בה פונקציה ? או if?
מה החוקים הברורים ללולאה??
(זה, מזכיר את זה, שמזכיר את זה… לכן אשמח לחוקים כדי ליצור לי הבדל במוח )

כשאת אומרת ‘קלט’ את מתכוונת ארגומנט בתוך הפונקציה או input מהמשתמש?

בגדול בתוך לולאה אפשר לשים כל דבר. השאלה מה כדאי…

input,
מה הכלל אבל בגדול, לולאה בתוך פונקציה?
או שפונקציה בתוך לולאה זה סביר ולא יבהלו שיראו את הכתיבה כך…
if זורם בתוך לולאה?

פונקציות:
את יכולה להכניס כמה פעולות שאת רוצה לפונקציה.
המליצו להכניס פעולה אחת כדי שיהיה יותר קל לתפעל את הקוד, לבדוק טעויות,
להימנע מטעויות וכו. (“פעולה” אחת אינה הכוונה אגב לשורת קוד אחת אלא ל"משימה" אחת שאת רוצה שהפונקציה תבצע )

רצוי לקבל קלט מחוץ לפונקציה. אבל שוב זה אפשרי ותלוי במה משרתת אותך הפונקציה.

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

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

מקווה שעניתי על הכל

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

תודה לשניכם

פונקציות

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

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

לולאות

1. לולאות הן חלק מהקוד שלנו. מותר לשים בתוכן כמה שורות שנרצה.
   עדיף לא לעשות לולאות עצומות כי זה יקשה על קריאות הקוד, אבל שום דבר הוא לא תורה מסיני.
2. מותר לשים בתוך לולאות קלט, כן. בד"כ כן נעדיף שלכל לולאה (בדומה לפונקציה) יהיה תפקיד אחד, אבל זה לא הכרחי.
3. מותר לשים בתוך לולאה פונקציה – אבל זה נחשב מאודדדדדד לא מנומס (למה להגדיר מחדש כ"כ הרבה פעמים פונקציה? ). מקובל מאוד לקרוא לפונקציה בתוך לולאה.
4. מותר לשים בתוך לולאה if – אנחנו נראה את זה הרבה.

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

למה זה לא מנומס לקלוט קלט מהמשתמש בתוך פונקציה? למה עדיף מבחוץ, ואז “למשוך” אותו כפרמטר?

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

נדמיין את הפונקציה max שמוצאת את הגדול מבין שני מספרים:

def max():
    a = int(input()) 
    b = int(input())
    if a > b:
        return a
    return b

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

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

def max(a, b):
    if a > b:
        return a
    return b

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

בגלל זה: כל פונקציה צריכה להיות אחראית על דבר אחד בלבד.

כלומר: אני רוצה שפונקציה תהיה כמה שיותר: “כללית”,
כך שמתכנת שירצה להשתמש בה יהיה יכול להפעיל אותה פרמטרים שחושבו כרצונו?

הרעיון הוא שהיא תהיה תאימה עבור כמה שיותר קודים אחרים?

נכון, חשוב לנו שהיא תהיה כללית כדי שתתאים לכמה שיותר מקרים.
קריאה בנושאים קרובים: https://en.wikipedia.org/wiki/Coupling_(computer_programming)
(יכול להיות שכרגע ברמה טיפה גבוהה מדי)

קבלתי; תודה.

-איישם ביתר תשומת לב להבא!

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

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

הנה כתבה מענינת שמסבירה לעומק:

אלו שני נושאים שונים שיש ביניהם קשר, אבל בינתיים לא נערבב

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

בכוונה לא הזכרתי את הנושא כי לדעתי זה ahead of time בהרבה ואני לא רוצה לזרוק תיאוריות מפוצצות לאוויר בארכיטקטורה של שפות תכנות בזמן שאנחנו רק מתחילים ללמוד לכתוב פונקציות נכון

הרגעים שים מדבר #סינית

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

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

האם הנושא הזה זוכה להתייחסות בהמשך הקורס?

אולי בקורס ההמשך

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