carbs = int(input("How many carbohydrates does this product have?: "))
fat = int(input("How much fat does this product have?: "))
protein = int(input("How much protein does this product have?: "))

total_calories = carbs * 4 + fat * 9 + protein * 4
print("This product has " + str(total_calories) + " calories in it.")

"""
Explanation: <img src="images/logo.jpg" style="display: block; margin-left: auto; margin-right: auto;" alt="לוגו של מיזם לימוד הפייתון. נחש מצויר בצבעי צהוב וכחול, הנע בין האותיות של שם הקורס: לומדים פייתון. הסלוגן המופיע מעל לשם הקורס הוא מיזם חינמי ללימוד תכנות בעברית.">
<p style="text-align: right; direction: rtl; float: right;">פונקציות</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">הגדרה</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
<dfn>פונקציה</dfn> היא קטע קוד קצר ותחום שנועד לפתור בעיה ספציפית.<br>
כל פונקציה היא מעין רכיב בתוכנה שלנו שנושא שם מסוים. אפשר להסתכל על פונקציה כ<mark>קטע קוד שמממש משימה מוגדרת היטב</mark>.<br>
לדוגמה, פונקציה יכולה להיות "המר טמפרטורה ממעלות פרנהייט לצלזיוס".<br> 
במובן הזה, <mark>פונקציות הן כמו תוכניות קטנות – יש להן קלט, הן עושות תהליך מסוים ומחזירות תוצאה מסוימת</mark>.<br>
אם ניקח את הפונקציה המדוברת מלמעלה, אפשר לתאר אותה כתוכנית קטנה כך:
</p>
<ul style="text-align: right; direction: rtl; float: right; clear: both;">
    <li><strong>קלט</strong> – טמפרטורה מסוימת</li>
    <li><strong>תהליך</strong> – המרת הטמפרטורה למעלות צלזיוס</li>
    <li><strong>פלט</strong> – החזרת התוצאה</li>
</ul>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
פונקציות הן למעשה אבני הבניין של תוכנה – כל פונקציה שואפת למלא תפקיד מוגדר בתוכנה, ובעזרת הרבה אבני בניין שכאלו אפשר לבנות תוכנה מורכבת.<br>
התוכנות שבהן אתם משתמשים ביום־יום מורכבות בדרך כלל מכמות רבה מאוד של פונקציות. 
</p>

<p style="text-align: right; direction: rtl; float: right; clear: both;">
עד סוף השיעור נדע איך יוצרים פונקציה כזו ואיך משתמשים בה.<br>
נדמיין פונקציה כמכונה שמקבלת ערכים, ויודעת לתת לנו פלט מסוים לפי אותם ערכים.<br>
אחרי שכתבנו פונקציה ובדקנו שהיא עובדת, נוכל להשתמש בה בלי לנסות לפענח בכל פעם מחדש את הלוגיקה שנמצאת בתוכה.
</p>

<figure>
    <img src="images/function-machine.png" style="display: block; margin-left: auto; margin-right: auto;" width="200px" alt="איור להמחשה של מעין מכונה, עם פתח כחול בצד שמאל שכתוב עליו IN, ופתח ירוק בצד שמאל שכתוב עליו OUT. בין ה־IN ל־OUT יש מכונה מורכבת ומלאת מכוונים, שלא ברור מה מטרתם.">
    <figcaption style="text-align: center; direction: rtl; clear: both;">
        ככה אני מדמיין פונקציה:<br>
        מכונה שמקבלת קלט ומוציאה פלט, ושאף אחד לא צריך לדעת מה קורה בתוכה.
    </figcaption>
</figure>

<p style="text-align: right; direction: rtl; float: right;">דוגמאות</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
אחת הפונקציות שכמעט כולם מכירים היא העלאה בריבוע.<br>
הקלט של הפונקציה הוא מספר כלשהו, התהליך שקורה בפונקציה הוא הכפלת המספר בעצמו, והפלט הוא תוצאת המכפלה.<br>
לדוגמה, הקלט של פונקציה בשם "העלאה בריבוע" יכול להיות <em>5</em>, והפלט שלה יהיה <samp>25</samp>.<br>
דוגמאות נוספות לקלט הן <em dir="ltr" style="direction: ltr">-3</em>, שעבורו הפלט יהיה <samp>9</samp>,
או <em dir="ltr" style="direction: ltr">0.5</em>, שעבורו הפלט יהיה <samp>0.25</samp>.<br>   
</p>

<p style="text-align: right; direction: rtl; float: right;">רעיונות נוספים לפונקציות</p>
<ul style="text-align: right; direction: rtl; float: right; clear: both;">
    <li>בהינתן שני מספרים, בדוק מי הגדול ביניהם והחזר אותו.</li>
    <li>בהינתן מספר כלשהו, החזר את סכום כל המספרים הזוגיים מ־0 ועד אליו.</li>
    <li>בהינתן שני מספרים ופעולת חשבון, החזר את תוצאת התרגיל.</li>
    <li>בהינתן שם משתנה, בדוק מה הסוג שלו (נשמע מוכר?)</li>
    <li>בדוק מה הטמפרטורה הצפויה הממוצעת ב־<em>n</em> הימים הקרובים והחזר את התוצאה.</li>
</ul>

<p style="text-align: right; direction: rtl; float: right;">כתיבת פונקציה</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
    דרך קלה לקבל הערכה גסה של כמה קלוריות יש במוצר מזון, היא זו:
</p>

<ol style="text-align: right; direction: rtl; float: right; clear: both;">
    <li>מצאו את כמות הפחמימות במוצר והכפילו ב־4.</li>
    <li>מצאו את כמות השומן במוצר והכפילו ב־9.</li>
    <li>מצאו את כמות החלבון במוצר והכפילו ב־4.</li>
    <li>כמות הקלוריות במוצר היא חיבור הערכים שקיבלתם בשלבים 1–3.</li>
</ol>

<div class="align-center" style="display: flex; text-align: right; direction: rtl; clear: both;">
    <div style="display: flex; width: 10%; float: right; clear: both;">
        <img src="images/exercise.svg" style="height: 50px !important;" alt="תרגול"> 
    </div>
    <div style="width: 70%">
        <p style="text-align: right; direction: rtl; float: right; clear: both;">
            כתבו תוכנית (ללא פונקציות) המקבלת מהמשתמש את ערכי הפחמימות, השומן והחלבון במוצר.<br>
            הדפיסו למשתמש את כמות הקלוריות במוצר.<br>
            פתרו את התרגיל לפני שתמשיכו הלאה.
        </p>
    </div>
    <div style="display: flex; width: 20%; border-right: 0.1rem solid #A5A5A5; padding: 1rem 2rem;">
        <p style="text-align: center; direction: rtl; justify-content: center; align-items: center; clear: both;">
            <strong>חשוב!</strong><br>
            פתרו לפני שתמשיכו!
        </p>
    </div>
</div>

<p style="text-align: right; direction: rtl; float: right; clear: both;">
והנה הפתרון לשאלה מלמעלה (אזהרת ספוילר!)</p>
End of explanation
"""


def calculate_calories():
    carbs = int(input("How many carbohydrates does this product have?: "))
    fat = int(input("How much fat does this product have?: "))
    protein = int(input("How much protein does this product have?: "))

    calories = carbs * 4 + fat * 9 + protein * 4
    print("This product has " + str(calories) + " calories in it.")

"""
Explanation: <p style="text-align: right; direction: rtl; float: right;">הגדרת הפונקציה</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
ההתחלה תהיה קפיצת ראש למים העמוקים, אבל אל חשש! אני אסביר בקרוב מה קורה כאן. בינתיים אני בונה קצת מתח.<br>
דבר ראשון נזרוק את הפתרון של התרגיל בתוך פונקציה.
</p>
End of explanation
"""


calculate_calories()

"""
Explanation: <p style="text-align: right; direction: rtl; float: right; clear: both;">
בתא שממש פה מעל, השתמשנו במילת המפתח <code>def</code> ובעזרתה <dfn>הגדרנו פונקציה</dfn> שנקראת <var>calculate_calories</var>.<br>
לפני שניכנס לפרטים על אודות ההגדרה ומה היא עושה, הריצו את התא ונסו לשים אצבע על תופעה משונה בתא הזה...<br>
ובכן, התופעה המשונה היא שבניגוד לפתרון התרגיל בלי הפונקציה שכתבנו למעלה, התא שבו הפונקציה כתובה לא עושה כלום!
</p>

<p style="text-align: right; direction: rtl; float: right;">קריאה לפונקציה</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
ובכן, זה מאחר שפונקציות לא פועלות מייד אחרי שמגדירים אותן.<br>
בניגוד למסרונים בתקופת בחירות, לפונקציות צריך ממש לקרוא אקטיבית כדי שיבואו.<br>
נעשה את זה, לפחות בינתיים, על ידי כתיבת השם של הפונקציה ואז סוגריים עגולים ריקים:
</p>
End of explanation
"""


#    שם הפונקציה
def hello_world():               # Function Header / כותרת הפונקציה
    print("Hello World!")        # גוף הפונקציה (מוזח!)

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

"""
Explanation: <p style="text-align: right; direction: rtl; float: right; clear: both;">
מה שעשינו בתא שמעל נקרא <dfn>קריאה לפונקציה</dfn>, וזו למעשה הדרך לגרום לתוכן של הפונקציה לרוץ.<br>
זה ממש כמו להפעיל מעין תוכנה קטנה בתוך התוכנה שלנו.
</p>

<p style="text-align: right; direction: rtl; float: right; clear: both;">
מזל טוב! יש לנו פונקציה עובדת.<br>
זה אפילו היה די קל:
</p>
<ol style="text-align: right; direction: rtl; float: right; clear: both;">
    <li>הגדרנו פונקציה בעזרת הקוד <code dir="ltr" style="direction: ltr;">def function_name():</code>, כש־<var>function_name</var> הוא בעצם <dfn>השם של הפונקציה</dfn>.</li>
    <li>מייד אחרי השורה הזו, כתבנו את <dfn>גוף הפונקציה</dfn> – מה היא עושה בפועל. בחלק הזה שמרנו על הזחה.</li>
    <li><em>קראנו לפונקציה</em> בציון השם שלה, ואז סוגריים. כך הפעלנו את הפונקציה, וגרמנו לכך שגוף הפונקציה ירוץ.</li>
</ol>

<div class="align-center" style="display: flex; text-align: right; direction: rtl; clear: both;">
    <div style="display: flex; width: 10%; float: right; clear: both;">
        <img src="images/warning.png" style="height: 50px !important;" alt="אזהרה!"> 
    </div>
    <div style="width: 90%">
        <p style="text-align: right; direction: rtl; clear: both;">
            קריאה לפונקציה חייבת להופיע אחרי הגדרתה.<br>
            אם קודם נקרא לפונקציה ורק אז נגדיר אותה, פייתון עדיין לא תכיר את הפונקציה ותזרוק לנו שגיאה.
        </p>
    </div>
</div>

<p style="text-align: right; direction: rtl; float: right;">טרמינולוגיה</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
כדי לזקק את הרעיון, ננסה להגדיר פונקציה פשוטה יחסית, ונקרא לה מייד כדי להפעיל אותה.<br>
שימו לב למינוחים החשובים: <em>כותרת הפונקציה</em>, <em>גוף הפונקציה</em>, <em>שם הפונקציה</em> וה<em>קריאה לפונקציה</em>.
</p>
End of explanation
"""


def calculate_calories():
    calories = carbs * 4 + fat * 9 + protein * 4
    print("This product has " + str(calories) + " calories in it.")


carbs = int(input("How many carbohydrates does this product have?: "))
fat = int(input("How much fat does this product have?: "))
protein = int(input("How much protein does this product have?: "))
calculate_calories()

"""
Explanation: <p style="text-align: right; direction: rtl; float: right;">פרמטרים</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
נהוג להגיד שכל פונקציה צריכה להיות אחראית לדבר אחד בלבד.<br>
במילים אחרות – כמה שפחות עבודה בתוך כל פונקציה, וכמה שיותר התמקדות במה שהיא <em>באמת</em> צריכה לעשות, כך ייטב.<br>
אחד הדברים הראשונים שנוח לנו להוציא מהפונקציה שלנו זה הקלט מהמשתמש, שביצענו בתוך הפונקציה:
</p>
End of explanation
"""


def calculate_calories(carbs, fat, protein):
    calories = carbs * 4 + fat * 9 + protein * 4
    print("This product has " + str(calories) + " calories in it.")

"""
Explanation: <p style="text-align: right; direction: rtl; float: right; clear: both;">
הקוד הזה אומנם יעבוד, אבל הוא כתוב בצורה גרועה מאוד.<br>
הוא מפר את העיקרון שהתחלנו איתו – פונקציה אמורה להיות יחידה עצמאית, קטנה וארוזה.<br>
היא אמורה להיות תלויה כמה שפחות בסביבה החיצונית.
</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
בתוך הפונקציה אנחנו מתייחסים למשתנים <var>fat</var>, <var>protein</var> ו־<var>carbs</var>, שאינם חלק מהפונקציה.<br>
ייתכן שבעתיד מישהו יעתיק את הפונקציה <var>calculate_calories</var> לתוכנית שלו, והמשתנים הללו לא יהיו מוגדרים בגוף התוכנית.<br>
במקרה כזה, לפונקציה לא יהיה מאיפה לקחת את הערכים והיא תקרוס.
</p>

<p style="text-align: right; direction: rtl; float: right; clear: both;">
הדרך להתמודד עם הבעיה הזו היא לחייב את הפונקציה לקבל באופן מסודר את הנתונים האלו מבחוץ.<br>
נראה דוגמה:
</p>
End of explanation
"""


calculate_calories(50, 90, 20)

"""
Explanation: <p style="text-align: right; direction: rtl; float: right; clear: both;">
שימו לב לכותרת הפונקציה.<br>
הכנסנו לשם את שמות 3 המשתנים הדרושים להרצת הפונקציה.<br>
אם תרצו, תוכלו להסתכל על זה כ"הקלט שנדרש עבור הפונקציה", או במקרה שלנו: "הנתונים שדרושים כדי לחשב את כמות הקלוריות במוצר".<br>
החלק הזה שהוספנו לפונקציה נקרא <dfn>הפרמטרים של הפונקציה</dfn>: כל אחד מהנתונים <var>carbs</var>, <var>fat</var> ו־<var>protein</var> הוא פרמטר.
    </p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
השם התיאורטי והמפונפן שמתכנתים משתמשים בו עבור השילוב של שם הפונקציה עם שמות הפרמטרים שלה נקרא <em>חתימת הפונקציה</em>.
</p>

<p style="text-align: right; direction: rtl; float: right; clear: both;">
איך תראה הקריאה לפונקציה עכשיו?<br>
אותו דבר, רק שבתוך הסוגריים נכתוב את הערכים שעבורם נרצה לחשב את כמות הקלוריות, לפי הסדר של הפרמטרים.<br>
הערכים שנעביר בתוך הקריאה לפונקציה נקראים <dfn>ארגומנטים</dfn>.
</p>
End of explanation
"""


#       שם הפונקציה
#                               פרמטרים
def calculate_calories(carbs, fat, protein):  # כותרת הפונקציה
    calories = carbs * 4 + fat * 9 + protein * 4
    print("This product has " + str(calories) + " calories in it.")


product_carbs = int(input("How many carbohydrates does this product have?: "))
product_fat = int(input("How much fat does this product have?: "))
product_protein = int(input("How much protein does this product have?: "))
#                                        ארגומנטים
calculate_calories(product_carbs, product_fat, product_protein)

"""
Explanation: <p style="text-align: right; direction: rtl; float: right; clear: both;">
אם כך, בארוחה שבה 50 גרם פחמימות, 90 גרם שומן ו־20 גרם חלבון, יש כ־1,090 קלוריות.<br>
</p>

<p style="text-align: right; direction: rtl; float: right; clear: both;">
נסכם את מה שעשינו עד עכשיו ונרענן את הטרמינולוגיה שלנו:
</p>
End of explanation
"""


def calculate_calories(carbs, fat, protein):
    calories = carbs * 4 + fat * 9 + protein * 4

calculate_calories(5, 30, 5)
print(calories)

"""
Explanation: <div class="align-center" style="display: flex; text-align: right; direction: rtl;">
    <div style="display: flex; width: 10%; float: right; ">
        <img src="images/warning.png" style="height: 50px !important;" alt="אזהרה!"> 
    </div>
    <div style="width: 90%">
        <p style="text-align: right; direction: rtl;">
            מותר שבתוך פונקציה יוגדר משתנה ששמו זהה למשתנה שנמצא מחוץ לפונקציה.<br>
            מתכנתים רבים מעדיפים להימנע מכך כדי למנוע באגים.
        </p>
    </div>
</div>

<p style="text-align: right; direction: rtl; float: right;">ערך החזרה</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
הפונקציה שלנו מתחילה להיראות נהדר, אבל מתכנתים מנוסים עדיין יעקמו את האף.<br>
כמו שאמרנו, פונקציה אמורה לעשות כמה שפחות, ולכן נעדיף שהיא גם לא תדפיס בעצמה את הערך שחישבה.<br>
היינו מעדיפים לקבל מהפונקציה רק את מספר הקלוריות שחישבנו, בלי טקסט מיותר.<br>
</p>

<p style="text-align: right; direction: rtl; float: right; clear: both;">
יש לצורת עבודה כזו יתרונות משמעותיים.<br>
אם הפונקציה תחזיר ערך מספרי, נוכל לעשות בו שימוש בפונקציות אחרות כדי לבצע פעולות המשך על התוצאה, כמו נניח: 
</p>
<ol style="text-align: right; direction: rtl; float: right; clear: both;">
    <li>לחשב כמה זמן אנחנו צריכים ללכת כדי לשרוף את כמות הקלוריות שצרכנו.</li>
    <li>לחשב כמה סופגניות היינו יכולים לאכול במקום הארוחה שחישבנו את כמות הקלוריות בה.</li>
    <li>לחשב אם נמכרו השנה מספיק המבורגרים של מקדונלדס כדי להשיג אנרגיה המשתווה בעוצמתה לפצצה שנחתה על הירושימה.</li>
</ol>

<p style="text-align: right; direction: rtl; float: right; clear: both;">
אוקיי, על פניו יש דרך פשוטה למדי לטפל בזה.<br>
בואו ננסה להפעיל את הפונקציה, ואז ניגש לערך <var>calories</var> שנמצא בתוכה!
</p>
End of explanation
"""


def calculate_calories(carbs, fat, protein):
    calories = carbs * 4 + fat * 9 + protein * 4
    return calories

"""
Explanation: <p style="text-align: right; direction: rtl; float: right; clear: both;">
מממ... זה לא עבד כמצופה.<br>
הסיבה שלא הצלחנו לקבל את התוכן של המשתנה <var>calories</var> מתוך הפונקציה, היא בגלל העיקרון שפונקציה היא קופסה סגורה.<br>
לכן, משתנים שמוגדרים בתוך הפונקציה זמינים אך ורק בתוכה, ונעלמים כשהיא מסיימת לרוץ.<br>
</p>

<p style="text-align: right; direction: rtl; float: right; clear: both;">
אז איך בכל זאת אפשר לקבל את תוצאת החישוב שלנו מתוך פונקציה?<br>
הביטו על הפונקציה הבאה:
</p>
End of explanation
"""


calculate_calories(50, 17.5, 36)

"""
Explanation: <p style="text-align: right; direction: rtl; float: right; clear: both;">
עוד לפני שאתייחס למילת המפתח החדשה <code>return</code>, שימו לב כמה נעים לקרוא את הפונקציה הזו.<br>
הפונקציה מתמקדת אך ורק במה שהיא אמורה לעשות, ואפשר להבין בקלות מה המטרה שלה ומה היא מבצעת.<br>
גם מתכנת שכלל לא מכיר את המטרה שלנו ואת התרגיל שממנו התחלנו, יכול במבט חטוף להבין מה ניסינו לעשות.
</p>

<p style="text-align: right; direction: rtl; float: right; clear: both;">
ננסה לקרוא לפונקציה החדשה שהגדרנו, ונראה מה יקרה:
</p>
End of explanation
"""


print("Calories in a Hamburger: " + str(calculate_calories(50, 17.5, 36)))
print("Calories in 2 Hamburgers: " + str(2 * calculate_calories(50, 17.5, 36)))

"""
Explanation: <p style="text-align: right; direction: rtl; float: right; clear: both;">
מעניין! הפונקציה ממש <em>החזירה לנו ערך</em>.<br>
זה אומר שהצלחנו לקבל מתוך הפונקציה נתון ממשי שאפשר לעבוד איתו.<br>
בואו נשחק עם זה:
</p>
End of explanation
"""


print("Calories in a Hamburger: " + str(501.5))
print("Calories in 2 Hamburgers: " + str(2 * 501.5))

"""
Explanation: <p style="text-align: right; direction: rtl; float: right; clear: both;">
אם זה עוזר לתפיסת הנושא עבורכם, תוכלו לדמיין מה קורה מאחורי הקלעים:<br>
פייתון רואה קריאה לפונקציה. היא מעבירה את הארגומנטים ששלחתם לתוך הפרמטרים שמופיעים בכותרת הפונקציה.<br>
כשהפונקציה מחזירה ערך, החלק בקוד שקרא לפונקציה ממש מתחלף בערך שחזר מהפונקציה.<br>
כך ששלב הביניים, לפני ההדפסה למסך, נראה מבחינת פייתון כך (השוו עם המשבצת הקודמת):
</p>
End of explanation
"""


calories_in_hamburger = calculate_calories(50, 17.5, 36)
print("Calories in a Hamburger: " + str(calories_in_hamburger))
print("Calories in 2 Hamburgers: " + str(2 * calories_in_hamburger))

"""
Explanation: <p style="text-align: right; direction: rtl; float: right; clear: both;">
נוכל להשתמש ברעיון הזה כדי לכתוב את הקוד בצורה קריאה יותר – נשמור את הערך שהפונקציה החזירה לנו בצד, ונשתמש בו:
</p>
End of explanation
"""


#       שם הפונקציה
#                               פרמטרים
def calculate_calories(carbs, fat, protein):  # כותרת הפונקציה
    calories = carbs * 4 + fat * 9 + protein * 4
    return calories  # ערך ההחזרה


product_carbs = int(input("How many carbohydrates does this product have?: "))
product_fat = int(input("How much fat does this product have?: "))
product_protein = int(input("How much protein does this product have?: "))
#                                     ארגומנטים
cal = calculate_calories(product_carbs, product_fat, product_protein)
print("This product has " + str(cal) + " calories in it.")

"""
Explanation: <p style="text-align: right; direction: rtl; float: right; clear: both;">
זה הזמן לראות את התוכנית שלנו מוכנה, עם כל הטרמינולוגיה עליה:
</p>
End of explanation
"""


def give_me_numbers(number):
    return number + 1
    return number + 2
    return number + 3

print(give_me_numbers(5))

"""
Explanation: <p style="text-align: right; direction: rtl; float: right;">עקרונות נוספים</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
העיקרון האחרון שניגע בו הוא העיקרון של החזרה מיידית.<br>
ברגע שפונקציה מגיעה לשורה שבה כתוב <code>return</code>, היא תחזיר ערך ותסיים את ריצתה באותה שורה.<br>
בואו נראה דוגמה:
</p>
End of explanation
"""


def absolute_value(number):
    if number < 0:
        number = number * -1
    return number

print(absolute_value(-5))

"""
Explanation: <p style="text-align: right; direction: rtl; float: right; clear: both;">
במקרה הזה, הערך היחיד שחזר הוא 6.<br>
הסיבה לכך היא שאחרי השורה <code>return number + 1</code>, הפונקציה החזירה ערך והפסיקה לרוץ.
</p>

<p style="text-align: right; direction: rtl; float: right;">דוגמה נוספת</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
לפניכם דוגמה של פונקציה שמחשבת את הערך המוחלט של מספר.<br>
לצורך הדוגמה הזו, הערך המוחלט של מספר מוגדר כמרחק שלו מהמספר אפס.<br>
למשל, הערך המוחלט של 6 הוא 6, והערך המוחלט של <span dir="ltr" style="direction: ltr;">-4</span> הוא 4.
</p>
End of explanation
"""


print(len('hello world'))

# פתרו לפני שתריצו: מה יהיה הערך שיודפס? מה ההבדל בין האגפים?
len('hello world') * 2 == len('hello world' * 2)

"""
Explanation: <div class="align-center" style="display: flex; text-align: right; direction: rtl; clear: both;">
    <div style="display: flex; width: 10%; float: right; clear: both;">
        <img src="images/exercise.svg" style="height: 50px !important;" alt="תרגול"> 
    </div>
    <div style="width: 90%">
        <p style="text-align: right; direction: rtl; float: right; clear: both;">
        <strong>תרגול</strong>:
            כתבו פונקציה שמקבלת שני מספרים ומחזירה את הגדול מביניהם.<br>
            רוצים אתגר? פתרו את התרגיל ב־4 שורות.
        </p>
    </div>
</div>

<p style="text-align: right; direction: rtl; float: right;">מזהים?</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
ייתכן שלא שמתם לב, אבל אתם כבר מכירים פונקציות מועילות ואפילו יצא לכם להשתמש בהן!<br>
לדוגמה, הפונקציה <code>print</code> שמטרתה להדפיס למסך הודעה שהיא מקבלת כארגומנט,<br>
או הפונקציה <code>type</code> שמטרתה להחזיר את סוג המשתנה שהיא מקבלת כארגומנט.
</p>

<p style="text-align: right; direction: rtl; float: right; clear: both;">
עכשיו, כשאתם כבר מבינים איך עובדות פונקציות, הגיע הזמן להכיר פונקציה חדשה: <code>len</code>.<br>
הפונקציה הזו מקבלת מחרוזת – ומחזירה את האורך שלה.<br>
בואו ננסה:
</p>
End of explanation
"""


def calculate_km_per_hour_for_5_km(hours_to_finish):
    km_per_hour = 5 / hours_to_finish
    return km_per_hour


def check_if_run_marathon_in_three_hours(km_per_hour):
    hours_to_finish_marathon = 42.195 / km_per_hour
    return hours_to_finish_marathon <= 3


time = float(input("How many hours did it take to finish a 5km run? "))
km_per_hour = calculate_km_per_hour_for_5_km(time)
can_run_marathon_in_three_hours = check_if_run_marathon_in_three_hours(km_per_hour)

if can_run_marathon_in_three_hours:
    print("Yes you can!")
else:
    print("No you can't!")

"""
Explanation: <div style="text-align: right; direction: rtl; float: right;">מטרות<br><sub>או: למה לי להשתמש בפונקציות בכלל</sub></div>
<p style="text-align: right; direction: rtl; float: right;">קְרִיאוּת</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
פונקציות מחלקות את הקוד שלנו לקטעים קטנים ובעלי שם, שיש מאחוריהם רעיון אחד שקל לקרוא ולתפוס.<br>
חלוקה לקטעים קטנים מאפשרת לנו לעקוב ביעילות אחרי מבנה התוכנית.<br>
כשנרצה לערוך חלק מסוים בתוכנית בשלב כלשהו – נדע בקלות ובמהירות איזה קטע בקוד צריך לשנות.
</p>

<p style="text-align: right; direction: rtl; float: right; clear: both;">מניעת חזרה</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
פונקציות עוזרות לנו למנוע מצבים שבהם היינו צריכים לכתוב קוד כמה פעמים.<br>
זה מועיל מכיוון שזה מאפשר לנו להשתמש מאוד מהר בקוד שכבר כתבנו בעבר.<br>
סיבה נוספת שיש להזכיר לחיוב, היא שתחזוקת הקוד קלה במידה ניכרת כשמבצעים שינוי במקום אחד מוגדר, במקום במקומות רבים ברחבי הקוד.
</p>

<p style="align: right; direction: rtl; float: right; clear: both;">מונחים</p>
<dl style="text-align: right; direction: rtl; float: right; clear: both;">
<dt>כותרת הפונקציה</dt><dd>השורה הראשונה בהגדרת הפונקציה. מתחילה ב־<code>def</code>, וכוללת את שם הפונקציה ואת שמות הפרמטרים שלה.</dd>
<dt>שם הפונקציה</dt><dd>שם שמתאר היטב את פעולתה של הפונקציה. אמור להתחיל בפעולה, כמו <var>get_account_number</var>.</dd>
<dt>פרמטרים</dt><dd>החלק שבתוך הסוגריים בכותרת הפונקציה. רשימה מופרדת בפסיקים של שמות המשתנים שימולאו בערכים מבחוץ, כדי שהפונקציה תוכל לבצע חישובים בעזרתם.</dd>
<dt>גוף הפונקציה</dt><dd>החלק המוזח שאחרי כותרת הפונקציה. כולל את כל החישובים הנדרשים כדי למלא את מטרת הפונקציה, לרבות החזרת ערך אל מחוץ לפונקציה.</dd>
<dt>ערך ההחזרה</dt><dd>הערך שהפונקציה תשלח בחזרה למי שקרא לה. מייד עם שליחת הערך הזה, הפונקציה תסיים את ריצתה.</dd>
<dt>ארגומנטים</dt><dd>הערכים שנשלחים מחוץ הפונקציה אל תוכה, ויושמו לתוך הפרמטרים.</dd>
<dt>קריאה לפונקציה</dt><dd>שימוש בשם הפונקציה כדי להפעיל אותה. לעיתים יחד עם ארגומנטים, אם הוגדרו פרמטרים בכותרת הפונקציה.</dd>
<dt>חתימת הפונקציה</dt><dd>השם של הפונקציה ושמות כל הפרמטרים שלה.</dd>
</dl>

<p style="text-align: right; direction: rtl; float: right; clear: both;">לסיכום</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
<em>פונקציה</em> היא מעין יחידת תוכנה בסיסית וקטנה.<br>
היא עוזרת לנו לחלק את התוכנה שלנו לתתי־משימות, ועושה אותה לקריאה יותר ולקלה יותר לתחזוקה.<br>
את הפונקציה אנחנו מגדירים בעזרת <em>כותרת הפונקציה</em>, שמכילה את מילת המפתח <em>def</em>, ואז את <em>שם הפונקציה</em> ואת <em>הפרמטרים</em> שהיא אמורה לקבל.<br>
מייד לאחר כותרת הפונקציה נגדיר בהזחה את <em>גוף הפונקציה</em> – שכולל את החישובים או את הפעולות שהפונקציה צריכה לבצע,<br>
ובסוף נבצע <em>החזרה</em> ל<em>ערך ההחזרה</em> שיופיע אחרי מילת המפתח <code>return</code>.<br> 
כדי להשתמש בפונקציה <em>נקרא לפונקציה</em> בהמשך הקוד על ידי כתיבת השם שלה, ובתוך סוגריים נפרט את <em>הארגומנטים</em>, שהם הערכים שנרצה להעביר לפונקציה.
</p>

<p style="text-align: right; direction: rtl; float: right; clear: both;">
חשוב לזכור!<br>
המשתנים בתוך הפונקציה אינם נגישים מבחוץ, כיוון שהיא נחשבת יחידה סגורה.<br>
כמו כן, ברגע שהפונקציה מריצה שורה שבה כתוב <code>return</code>, היא מחזירה ערך וריצתה נפסקת.
</p>

<p style="align: right; direction: rtl; float: right; clear: both;">תרגול</p>
<p style="align: right; direction: rtl; float: right; clear: both;">תרגיל לדוגמה: מרתון</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
דני מתאמן למרתון הקרוב. הוא מתחיל להתכונן על אש נמוכה, ורץ אתמול 5 קילומטרים.<br>
כתבו פונקציה שמקבלת כמה שעות לקח לדני לגמוע את 5 הקילומטרים הללו, ומחשבת מה קצב הריצה הממוצע של דני, בקמ"ש.<br>
כתבו פונקציה נוספת שבודקת אם דני יכול להשלים מרתון בתוך 3 שעות.<br>
אורכו של מסלול מרתון הוא 42.195 קילומטר.
</p>

<p style="text-align: right; direction: rtl; float: right; clear: both;">
ניתן לחשב באיזו מהירות (בקמ"ש) דני רץ אם ניקח את כמות הקילומטרים שעבר, ונחלק אותה בכמות השעות שרץ.<br>
ניתן לחשב כמה זמן יקח לדני לרוץ מסלול מסוים, אם ניקח את המרחק בקילומטרים שרץ ונחלק אותו במהירות של דני (בקמ"ש).<br>
ניתן לחשב כמה קילומטרים דני ירוץ בזמן נתון, אם ניקח את המהירות שלו בקמ"ש ונכפיל אותה בזמן שלקח לו לרוץ את המרחק הזה.
</p>

$$speed = \frac{distance}{time}$$
$$time = \frac{distance}{speed}$$
$$distance = {time}\cdot{speed}$$
<p style="text-align: right; direction: rtl; float: right; clear: both;">
הפתרון מופיע בתחתית המחברת.
</p>

<p style="align: right; direction: rtl; float: right; clear: both;">האריך במילים</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
כתבו פונקציה שמקבלת 3 מחרוזות כארגומנטים ומחזירה את המחרוזת הארוכה יותר מביניהן.
</p>

<p style="align: right; direction: rtl; float: right; clear: both;">פיזבאז</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
זוהי גרסה של תרגיל פופולרי בראיונות עבודה.
</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
כתבו פונקציה שמקבלת מספר.<br>
אם המספר מתחלק ב־3 ללא שארית, הדפיסו <samp>Fizz</samp>.<br>
אם המספר מתחלק ב־5 ללא שארית, הדפיסו <samp>Buzz</samp>.<br>
אם המספר מתחלק גם ב־3 וגם ב־5 ללא שארית, הדפיסו <samp>FizzBuzz</samp>.<br>
אם המספר לא מתחלק ב־3 ולא מתחלק ב־5, הדפיסו את המספר עצמו.
</p>

<p style="text-align: right; direction: rtl; float: right; clear: both;">
    לדוגמה,
    עבור המספר 9 הדפיסו <samp>Fizz</samp>,<br>
    עבור המספר 10 הדפיסו <samp>Buzz</samp>,<br>
    עבור המספר 15 הדפיסו <samp>FizzBuzz</samp>,<br>
    ועבור המספר 7 הדפיסו <samp>7</samp>.
</p>

<p style="align: right; direction: rtl; float: right; clear: both;">מספר הפוך</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
כתבו פונקציה שמקבלת מספר דו־ספרתי שספרת האחדות שלו שונה מ־0.<br>
הפונקציה תחזיר את המספר הפוך.<br>
לדוגמה: עבור 53 הפונקציה תחזיר <samp>35</samp>. עבור 19 הפונקציה תחזיר <samp>91</samp>. עבור 91 הפונקציה תחזיר <samp>19</samp>.
</p>

<p style="align: right; direction: rtl; float: right; clear: both;">מפענח הצפנים</p>
<div class="align-center" style="display: flex; text-align: right; direction: rtl; clear: both;">
    <div style="display: flex; width: 10%; float: right; clear: both;">
        <img src="images/warning.png" style="height: 50px !important;" alt="אזהרה!"> 
    </div>
    <div style="width: 90%">
        <p style="text-align: right; direction: rtl; clear: both;">
            זהו תרגיל ברמת קושי גבוהה, שמערב נושאים רבים.<br>
            הרגישו בנוח להיעזר במתרגלים שלכם.
        </p>
    </div>
</div>

<p style="text-align: right; direction: rtl; float: right; clear: both;">
הצופן לכספת הביתית שלכם הוא 4812. בנו משחק בול־פגיעה שמאפשר למשתמש לנסות לנחש את הצופן.<br>
למשתמש יש 3 ניסיונות לנחש נכונה את הצופן שלכם לפני שמופעלת אזעקה.<br>
כחלק ממנגנון ההגנה מאיבוד הסיסמה של הכספת, היא מציגה כמה ספרות נכונות המשתמש הזין אחרי כל ניחוש.<br>
אפשרו למשתמש להזין קוד 3 פעמים, וכתבו לו בכל ניסיון כמה מתוך הספרות שהזין באמת קיימות בקוד הנכון, לאו דווקא בסדר שהקיש.<br>
אם לא הצליח אחרי 3 ניסיונות, הדפיסו שהאזעקה הופעלה וסיימו את התוכנית.<br>
</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
לדוגמה, אם המשתמש הקיש בניסיון הראשון 0634, הדפיסו לו שרק אחת הספרות שניחש נכונה.<br>
אם המשתמש הקיש בסיבוב השני 1234, הדפיסו לו ש־3 ספרות תואמות את הקוד המקורי.<br>
אם המשתמש הקיש בסיבוב השלישי 1284, הדפיסו לו ש־4 ספרות תואמות את הקוד המקורי, ואז הדפיסו לו שהופעלה האזעקה.<br>
אם המשתמש הקיש באחד הסיבובים 4812, הדפיסו שהכספת נפתחה בהצלחה וסיימו את התוכנית מייד.
</p>

<p style="align: right; direction: rtl; float: right; clear: both;">סכום מספרים</p>
<p style="text-align: right; direction: rtl; float: right; clear: both;">
קבלו מספר וחשבו את העצרת שלו – מכפלת כל המספרים עד אותו מספר.<br>
לדוגמה, 5 עצרת שווה ל־1 כפול 2 כפול 3 כפול 4 כפול 5, והתוצאה היא 120.<br>
<strong>זהירות!</strong> זה תרגיל בונוס, והוא קשה מאוד. מאוד. מאוד מאוד. אנחנו לא אומרים סתם. הוא לא חובה ומיועד לאנשים שרוצים לאתגר את עצמם. מאוד.<br>
</p>

<p style="align: right; direction: rtl; float: right; clear: both;">פתרון התרגול לדוגמה: מרתון</p>
End of explanation
"""


MARATHON_DISTANCE = 42.195


def calculate_km_per_hour(km_to_run, hours_took_to_finish):
    km_per_hour = km_to_run / hours_took_to_finish
    return km_per_hour


def calculate_time_to_run(distance_to_run, km_per_hour):
    hours = distance_to_run / km_per_hour
    return hours


def print_if_can_run(target_time, actual_time):
    # זה בסדר להדפיס פה, כי זה ממש המטרה של הפונקציה.
    if actual_time <= target_time:
        print("Success! You can do it!")
    else:
        print("You can't do it :(")


time = float(input("How many hours did it take to finish a 5km run? "))
km_per_hour = calculate_km_per_hour(5, time)
hours_to_finish = calculate_time_to_run(MARATHON_DISTANCE, km_per_hour)
print_if_can_run(3, hours_to_finish)

"""
Explanation: <p style="text-align: right; direction: rtl; float: right; clear: both;">
בואו ננקה, נסדר ונהפוך דברים ליותר כלליים:
</p>
End of explanation
"""


