content/week07/3_Classes_Part_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/logo.jpg\" style=\"display: block; margin-left: auto; margin-right: auto;\" alt=\"לוגו של מיזם לימוד הפייתון. נחש מצויר בצבעי צהוב וכחול, הנע בין האותיות של שם הקורס: לומדים פייתון. הסלוגן המופיע מעל לשם הקורס הוא מיזם חינמי ללימוד תכנות בעברית.\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"text-align: right; direction: rtl; float: right;\">מחלקות – חלק 2</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">רענון</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בשיעור הקודם בנושא מחלקות למדנו ש<dfn>מחלקה</dfn> היא תבנית (\"שבלונה\") המאגדת תכונות ופעולות של ישות כלשהי.<br>\n",
    "    למדנו גם מה הוא מופע – התוצר של השימוש באותה שבלונה, באותה מחלקה, כדי ליצור פריט לפי השבלונה הזו.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    לדוגמה, מחלקת \"קבוצת ווטסאפ\" יכולה להיות מוגדרת כך:\n",
    "</p>\n",
    "\n",
    "<ul style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <li><em>תכונות</em>: כותרת, משתמשים ורשימת הודעות.</li>\n",
    "    <li><em>פעולות</em>: שליחת הודעה, הצטרפות לקבוצה או יציאה מהקבוצה.</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    קריאה למחלקת \"קבוצת ווטסאפ\" תיצור מופע חדש של קבוצת ווטסאפ, שבו יש את התכונות והפעולות שהוגדרו במחלקה.<br>\n",
    "    קריאה למחלקה 5 פעמים תיצור 5 קבוצות ווטסאפ שונות, שלכל אחת מהן התכונות והפעולות שהוגדרו במחלקה.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">משתני מחלקה</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    במסעדת \"זלוברי\" ליד כל רכיב בתפריט רשומים ערכיו התזונתיים ל־100 גרם.<br>\n",
    "    מנהלת המסעדה קיפף אוסין שכרה את שירותינו וביקשה מאיתנו לכתוב מחלקה המייצגת רכיב במנה.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    לכל רכיב יש:\n",
    "</p>\n",
    "\n",
    "<ul style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <li><em>תכונות</em>: שם, משקל פחמימות, משקל חלבונים ומשקל שומנים (בגרמים).</li>\n",
    "    <li><em>פעולות</em>: חישוב מספר הקלוריות ברכיב.</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    להזכירכם, דרך להערכה מהירה של מספר הקלוריות שיש ברכיב, היא זו:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ol style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <li>מצאו את משקל הפחמימות ברכיב והכפילו ב־4.</li>\n",
    "    <li>מצאו את משקל השומן ברכיב והכפילו ב־9.</li>\n",
    "    <li>מצאו את משקל החלבון ברכיב והכפילו ב־4.</li>\n",
    "    <li>מספר הקלוריות ברכיב היא חיבור הערכים שקיבלתם בשלבים 1–3.</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"align-center\" style=\"display: flex; text-align: right; direction: rtl; clear: both;\">\n",
    "    <div style=\"display: flex; width: 10%; float: right; clear: both;\">\n",
    "        <img src=\"images/exercise.svg\" style=\"height: 50px !important;\" alt=\"תרגול\"> \n",
    "    </div>\n",
    "    <div style=\"width: 70%\">\n",
    "        <p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "            נסו לממש בעצמכם את מחלקת Ingredient לפי התכונות והפעולות שתוארו למעלה.\n",
    "        </p>\n",
    "    </div>\n",
    "    <div style=\"display: flex; width: 20%; border-right: 0.1rem solid #A5A5A5; padding: 1rem 2rem;\">\n",
    "        <p style=\"text-align: center; direction: rtl; justify-content: center; align-items: center; clear: both;\">\n",
    "            <strong>חשוב!</strong><br>\n",
    "            פתרו לפני שתמשיכו!\n",
    "        </p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    מימוש של המחלקה ייראה כך:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ingredient:\n",
    "    def __init__(self, name, carbs, fats, proteins):\n",
    "        self.name = name\n",
    "        self.carbs = carbs\n",
    "        self.fats = fats\n",
    "        self.proteins = proteins\n",
    "    \n",
    "    def calculate_calories(self):\n",
    "        return (\n",
    "            self.carbs * 4\n",
    "            + self.fats * 9\n",
    "            + self.proteins * 4\n",
    "        )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    ושימוש בה ייראה כך:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mango = Ingredient('Mango', carbs=15, fats=0.4, proteins=0.8)\n",
    "mango.calculate_calories()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    אוסין מגדירה רכיב כ\"בריא\" אם מספר הקלוריות שבו קטן מ־100 עבור 100 גרם.<br>\n",
    "    נממש את הפעולה <code>is_healthy</code> שמחזירה <code>True</code> או <code>False</code>:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ingredient:\n",
    "    def __init__(self, name, carbs, fats, proteins):\n",
    "        self.name = name\n",
    "        self.carbs = carbs\n",
    "        self.fats = fats\n",
    "        self.proteins = proteins\n",
    "    \n",
    "    def calculate_calories(self):\n",
    "        return (\n",
    "            self.carbs * 4\n",
    "            + self.fats * 9\n",
    "            + self.proteins * 4\n",
    "        )\n",
    "\n",
    "    def is_healthy(self):\n",
    "        return self.calculate_calories() < 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    שימוש במספרים קבועים בקוד שלנו נחשב לרוב ללא מנומס, ותמיד נעדיף לתת להם שם.<br>\n",
    "    במקרה הזה, יש סיכוי שמסעדת \"זלוברי\" תשנה את הגדרתה עבור רכיבים דיאטטיים בעתיד, ועדיף שהמספר \"100\" לא יפוזר לאורך הקוד.<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    פתרון אפשרי הוא להגדיר משתנה בראש הקוד, שייצג את מספר הקלוריות המרבי למאכל דיאטטי.<br>\n",
    "    שימו לב שנהוג לכתוב את שמם של משתנים קבועים, אלו שערכיהם ישארו קבועים לכל אורך התוכנית, באותיות גדולות:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HEALTHY_CALORIES_UPPER_BOUND = 100\n",
    "\n",
    "\n",
    "class Ingredient:\n",
    "    def __init__(self, name, carbs, fats, proteins):\n",
    "        self.name = name\n",
    "        self.carbs = carbs\n",
    "        self.fats = fats\n",
    "        self.proteins = proteins\n",
    "    \n",
    "    def calculate_calories(self):\n",
    "        return (\n",
    "            self.carbs * 4\n",
    "            + self.fats * 9\n",
    "            + self.proteins * 4\n",
    "        )\n",
    "\n",
    "    def is_healthy(self):\n",
    "        return self.calculate_calories() < HEALTHY_CALORIES_UPPER_BOUND"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    הפתרון הזה עובד, אך מפספס עיקרון חשוב שהצגנו במחברת הקודמת שעסקה במחלקות.<br>\n",
    "    מחלקה אמורה לאגד את כל המידע הקשור אליה, וזה הדין גם בנוגע למחלקת \"רכיב\", שאמורה לכלול את כל המידע הרלוונטי אליה.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    אפשרות נוספת היא להגדיר את הערך כתכונה של כל מופע חדש שניצור:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ingredient:\n",
    "    def __init__(self, name, carbs, fats, proteins):\n",
    "        self.name = name\n",
    "        self.carbs = carbs\n",
    "        self.fats = fats\n",
    "        self.proteins = proteins\n",
    "        self.HEALTHY_CALORIES_UPPER_BOUND = 100\n",
    "\n",
    "    def calculate_calories(self):\n",
    "        return (\n",
    "            self.carbs * 4\n",
    "            + self.fats * 9\n",
    "            + self.proteins * 4\n",
    "        )\n",
    "\n",
    "    def is_healthy(self):\n",
    "        return self.calculate_calories() < self.HEALTHY_CALORIES_UPPER_BOUND"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    מדובר בבחירה מעט בזבזנית, כיוון שאם יהיו לנו מיליון רכיבים נצטרך ליצור במיליון מופעים את <var>HEALTHY_CALORIES_UPPER_BOUND</var>.<br>\n",
    "    יתרה מכך, אם נחליט לשנות את <var>HEALTHY_CALORIES_UPPER_BOUND</var> נצטרך לפנות לכל מיליון המופעים הקיימים ולשנות בהם את הערך.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    אפשרות טובה יותר, שבה טרם נתקלנו, היא להגדיר את המשתנה ברמת המחלקה עצמה:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ingredient:\n",
    "    HEALTHY_CALORIES_UPPER_BOUND = 100\n",
    "\n",
    "    def __init__(self, name, carbs, fats, proteins):\n",
    "        self.name = name\n",
    "        self.carbs = carbs\n",
    "        self.fats = fats\n",
    "        self.proteins = proteins\n",
    "\n",
    "    def calculate_calories(self):\n",
    "        return (\n",
    "            self.carbs * 4\n",
    "            + self.fats * 9\n",
    "            + self.proteins * 4\n",
    "        )\n",
    "\n",
    "    def is_healthy(self):\n",
    "        return self.calculate_calories() < self.HEALTHY_CALORIES_UPPER_BOUND"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    מה קרה בקוד שלמעלה?<br>\n",
    "    הגדרנו את <var>HEALTHY_CALORIES_UPPER_BOUND</var> באותה רמה היררכית של הגדרת הפעולות במחלקה.<br>\n",
    "    הגדרה של משתנה ברמת המחלקה גורמת לו להיות משותף לכל המופעים שייווצרו מאותה מחלקה.<br>\n",
    "    בשלב זה כל מופע יכול לגשת לערך <var>HEALTHY_CALORIES_UPPER_BOUND</var> כאילו הוא חלק מתכונות המופע.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "banana = Ingredient('Banana', carbs=23, fats=0.3, proteins=1.1)\n",
    "melon = Ingredient('Melon', carbs=8, fats=0.2, proteins=0.8)\n",
    "\n",
    "print(banana.HEALTHY_CALORIES_UPPER_BOUND)\n",
    "print(melon.HEALTHY_CALORIES_UPPER_BOUND)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בתא האחרון יצרנו שני מופעים חדשים של רכיבים – הראשון של בננה והשני של מלון.<br>\n",
    "    הצלחנו לגשת למשתנה המחלקה <var>HEALTHY_CALORIES_UPPER_BOUND</var> שמשותף לשניהם דרך המופע שלהם.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    קריאה ל־<code dir=\"ltr\">banana.is_healthy()</code> תעביר את המופע <var>banana</var> לפרמטר <var>self</var> של הפעולה <var>is_healthy</var>.<br>\n",
    "    הביטוי <code>self.HEALTHY_CALORIES_UPPER_BOUND</code> יאפשר לנו להשיג את משתנה המחלקה, כיוון שאל <var>self</var> הועבר המופע עצמו:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"Is Banana healthy? -- {banana.is_healthy()}\")\n",
    "print(f\"Is Melon healthy? -- {melon.is_healthy()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    הטריק הזה נקרא \"<dfn>משתני מחלקה</dfn>\" והוא מועיל ונפוץ, בעיקר עבור הגדרת ערכים קבועים המשותפים לכל המופעים שייווצרו מהמחלקה.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">תרגיל ביניים: חללר</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בעקבות הצלחתכם בחברת צ'יקצ'וק, פנה אליכם היזם המוכר אלון מסכה וביקש מכם להצטרף לחברתו \"חללר\".<br>\n",
    "    אלון מעוניין לבנות גשושית שיכולה לנוע במהירות האור, והוא מעוניין בעזרתכם בבניית סימולציה של גשושית שכזו.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    תכונות הגשושית (<var>SpaceProbe</var>) יהיו זמן השיגור שלה ומהירות הטיסה הממוצעת של הגשושית בקמ\"ש.<br>\n",
    "    לכל מופע של גשושית תהיה גם הפעולה <var>get_distance</var> שתחשב מה המרחק שהחללית עברה מנקודת השיגור שלה.<br>\n",
    "    אפשר לחשב זאת על ידי מציאת מספר השעות שעברו מרגע השיגור, והכפלתו במהירות הממוצעת של החללית.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כדי שהסימולציה תדמה מצב מציאותי, ביקש אלון להגביל את מהירות הגשושית.<br>\n",
    "    אם המהירות הממוצעת שהוגדרה לגשושית קטנה מ־0 – הגדירו אותה כ־0. אם היא גדולה ממהירות האור – הגדירו אותה כמהירות האור.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">מחלקות הן אזרחיות ממדרגה ראשונה</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כדי להבין טוב יותר איך פייתון מתנהגת, חשוב להבין שהמחלקה <var>Ingredient</var> גם היא ערך לכל דבר.<br>\n",
    "    בדיוק כמו פונקציות (או כל ערך אחר), אפשר לבצע השמה שלה למשתנה:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SomethingINeedForMyRecipe = Ingredient\n",
    "honey = SomethingINeedForMyRecipe('Honey', carbs=82, fats=0, proteins=0.3)\n",
    "honey.calculate_calories()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בדוגמה האחרונה ביצענו השמה, וגרמנו למשתנה <var>SomethingINeedForMyRecipe</var> להצביע על המחלקה <var>Ingredient</var>.<br>\n",
    "    שימו לב שלא הפעלנו את ה־<code>__init__</code> של <var>Ingredient</var>, אלא השתמשנו בה כערך – ציינו את שמה ללא הסוגריים.<br>\n",
    "    בשלב הזה <var>SomethingINeedForMyRecipe</var> ו־<var>Ingredient</var> הצביעו לאותו מקום, ולכן אפשר היה ליצור רכיבים בעזרת <var>SomethingINeedForMyRecipe</var>.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    הדפסה של המשתנה <var>SomethingINeedForMyRecipe</var> תגלה לנו שמדובר במחלקה המקורית, <var>Ingredient</var>: \n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(SomethingINeedForMyRecipe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    וכך גם בדיקת הסוג של המופע <var>honey</var>, שנוצר מהקריאה ל־<var>SomethingINeedForMyRecipe</var>:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(honey)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    אפשר לקחת את האמירה שמחלקות הן כמו כל ערך אחר צעד אחד קדימה.<br>\n",
    "    ניצור שתי מחלקות, ונכניס את המחלקות עצמן לתוך רשימה:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class User:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"{self.name} is {self.age} years old.\"\n",
    "\n",
    "\n",
    "class Superstar:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = f'🌟Superstar {name}🌟'\n",
    "        self.age = age - 5  # Your skin is so young!\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"{self.name} is {self.age} years old.\"\n",
    "\n",
    "\n",
    "classes = [User, Superstar]\n",
    "for class_object in classes:\n",
    "    print(f\"The result from {class_object} is...\")\n",
    "    kipik = class_object(\"Kipik the Turtle\", 75)\n",
    "    print(kipik)\n",
    "    print('-' * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    מה התרחש בקוד שלמעלה?\n",
    "</p>\n",
    "\n",
    "<ol style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <li>יצרנו שתי מחלקות, <var>User</var> ו־<var>Superstar</var>.</li>\n",
    "    <li>יצרנו רשימה שאיבריה הם המחלקות <var>User</var> ו־<var>Superstar</var>, וגרמנו למשתנה בשם <var>classes</var> להצביע על הרשימה בעזרת השמה.</li>\n",
    "    <li>עברנו על התוכן של <var>classes</var> בעזרת לולאת <code>for</code>.</li>\n",
    "    <li>בכל איטרציה לקחנו מחלקה אחת (שעליה הצביע המשתנה <var>class_object</var>), ובנינו בעזרתה מופע של קיפיק.</li>\n",
    "    <li>הדפסנו את המופע בכל מחלקה שהגענו אליה – הראשון מופע שנוצר מהמחלקה <var>User</var>, והשני מופע שנוצר מהמחלקה <var>Superstar</var>.</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בשיעור על פונקציות בשבוע שעבר למדנו שפונקציות הן אזרחיות ממדרגה ראשונה – כלומר, הן ערכים לכל דבר.<br>\n",
    "    מהדוגמה האחרונה אפשר לראות שגם מחלקות בפייתון, בדומה לפונקציות, הן אזרחיות ממדרגה ראשונה.<br>\n",
    "    המשמעות היא שהן ערך לכל דבר, כמו מספרים ומחרוזות: אפשר להכניס אותן לרשימה, להעביר אותן כפרמטר ולאחסן אותן במשתנים.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">שימוש ישיר בערך המחלקה</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    נחדד פעם נוספת את ההבדלים בין מופע למחלקה.<br>\n",
    "    נביט במחלקה <var>Ingredient</var> שמייצגת רכיב במסעדה.<br>\n",
    "    בעזרת קריאה למחלקה (השבלונה, התבנית) <var>Ingredient</var> נוכל ליצור מופעים חדשים של רכיבים.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כך ניצור מחלקה:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ingredient:\n",
    "    HEALTHY_CALORIES_UPPER_BOUND = 100\n",
    "\n",
    "    def __init__(self, name, carbs, fats, proteins):\n",
    "        self.name = name\n",
    "        self.carbs = carbs\n",
    "        self.fats = fats\n",
    "        self.proteins = proteins\n",
    "\n",
    "    def calculate_calories(self):\n",
    "        return (\n",
    "            self.carbs * 4\n",
    "            + self.fats * 9\n",
    "            + self.proteins * 4\n",
    "        )\n",
    "\n",
    "    def is_healthy(self):\n",
    "        return self.calculate_calories() < self.HEALTHY_CALORIES_UPPER_BOUND"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    וכך ניצור מופע:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cinnamon = Ingredient('Cinnamon', carbs=81, fats=1.2, proteins=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כפי שראינו לפני כן, מחלקה היא ערך לכל דבר.<br>\n",
    "    מעבר לכך, ראינו שאפשר להגדיר משתנים השייכים למחלקה.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    אפשר לגשת לאותם משתנים שלא דרך מופע מסוים, בעזרת שימוש בשם המחלקה.<br>\n",
    "    נוכל, לדוגמה, להשיג את הערך שנמצא ב־<var>HEALTHY_CALORIES_UPPER_BOUND</var> כך:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ingredient.HEALTHY_CALORIES_UPPER_BOUND"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בשורה למעלה ציינו את שם המחלקה עצמה, כתבנו נקודה, ומייד אחריה התייחסנו לאחד המשתנים המוגדרים בה.<br>\n",
    "    הגדרת קבועים במחלקה והתייחסות אליהם מבחוץ הוא רעיון די נפוץ שנהוג להשתמש בו לא מעט בתכנות.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    אם נרצה, נוכל גם לבצע השמה למשתנה המחלקה מבחוץ, ולשנות אותו עבור כל המופעים שמתייחסים אליו:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"healthy if calories < 100: {cinnamon.is_healthy()}\")\n",
    "Ingredient.HEALTHY_CALORIES_UPPER_BOUND = 400\n",
    "print(f\"healthy if calories < 400: {cinnamon.is_healthy()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בניגוד לגישה למשתנה המחלקה בצורה שהוצגה למעלה, לא נוכל לגשת באותו אופן לתכונה <code>Ingredient.name</code>.<br>\n",
    "    הרי אין בכך היגיון – התכונה <var>name</var> היא תכונה שמוגדרת עבור כל מופע, ולא עבור המחלקה כולה:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ingredient.name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    ומה יקרה אם ננסה לפנות דרך המחלקה עצמה לפעולה שהוגדרה ברמת המחלקה?\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ingredient.is_healthy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כמובן!<br>\n",
    "    הפעולה <var>is_healthy</var> מצפה ל־<var>self</var>, מופע כלשהו של המחלקה, שבדרך כלל מועבר לה כשאנחנו קוראים לה בעזרת המופע:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cinnamon.is_healthy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בתא למעלה, כפי שלמדנו בפרק הקודם על מחלקות, <var>cinnamon</var> נשלח לפעולה <var>is_healthy</var> בתור הארגומנט <var>self</var>.<br>\n",
    "</p>\n",
    "\n",
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כדי לחקות את אותה ההתנהגות עבור הקריאה <code dir=\"ltr\">Ingredient.is_healthy()</code> שמצפה לקבל <var>self</var> כפרמטר,<br>\n",
    "    נעביר את <var>cinnamon</var> כארגומנט לפעולה, וזה יגרום לה להיכנס לפרמטר <var>self</var>:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ingredient.is_healthy(cinnamon)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    שימוש בפעולות בצורה הזו כרגע הוא יותר בבחינת ידע כללי שאמור לעזור לכם להבין איך המחלקה מתנהגת מאחורי הקלעים.<br>\n",
    "    בהמשך הקורס נבין טוב יותר מהם השימושיים האפשריים בפנייה לפעולות דרך המחלקה עצמה ולא דרך מופע.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">הכלה</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    לאור ההצלחה המסחררת של מחלקת \"רכיב\", ביקשה מאיתנו מנהלת המסעדה קיפף אוסין לתכנת מחלקה בשם <var>Dish</var> שתייצג מנה במסעדה.<br>\n",
    "    לכל מנה יש שם (<var>name</var>), סימון אם היא צמחונית (<var>is_vegetarian</var>) ורשימת רכיבים (<var>ingredients</var>).<br>\n",
    "    הפעולה <var>get_total_calories</var> תחזיר את סכום הקלוריות של רכיבי המנה.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"align-center\" style=\"display: flex; text-align: right; direction: rtl; clear: both;\">\n",
    "    <div style=\"display: flex; width: 10%; float: right; clear: both;\">\n",
    "        <img src=\"images/exercise.svg\" style=\"height: 50px !important;\" alt=\"תרגול\"> \n",
    "    </div>\n",
    "    <div style=\"width: 70%\">\n",
    "        <p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "            ממשו בעצמכם את מחלקת <var>Dish</var>.<br>\n",
    "            לעת עתה, התעלמו מהכמות של כל רכיב במנה.\n",
    "        </p>\n",
    "    </div>\n",
    "    <div style=\"display: flex; width: 20%; border-right: 0.1rem solid #A5A5A5; padding: 1rem 2rem;\">\n",
    "        <p style=\"text-align: center; direction: rtl; justify-content: center; align-items: center; clear: both;\">\n",
    "            <strong>חשוב!</strong><br>\n",
    "            פתרו לפני שתמשיכו!\n",
    "        </p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    חלק מהכיף האמיתי בתכנות מחלקות מסתתר בכתיבת האינטרקציה ביניהן.<br>\n",
    "    לכן התרגיל למעלה הוא מעניין – הוא משלב את המחלקה הקודמת שבנינו, <var>Ingredient</var>, עם המחלקה <var>Dish</var>.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כדי לייצג את הרכיבים בכל מנה נשתמש במופעי המחלקה <var>Ingredient</var>.<br>\n",
    "    נוכל לשמור רשימה של רכיבים כתכונה של מחלקת \"מנה\".<br>\n",
    "    במילים אחרות: לכל מנה יש רשימת רכיבים.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    נממש:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dish:\n",
    "    \"\"\"Create a new dish for the restaurant using our ingredients.\n",
    "    \n",
    "    Args:\n",
    "        name (str): The name of the dish.\n",
    "        is_vegetarian (bool): `True` if the dish is vegetarian.\n",
    "        ingredients (list of Ingredient): All the required ingredients\n",
    "                                          for the dish.\n",
    "\n",
    "    Attributes:\n",
    "        name (str): The name of the dish.\n",
    "        is_vegetarian (bool): `True` if the dish is vegetarian.\n",
    "        ingredients (list of Ingredient): All the ingredients that are\n",
    "                                          required to prepare the dish.\n",
    "    \"\"\"\n",
    "    def __init__(self, name, is_vegetarian, ingredients):\n",
    "        self.name = name\n",
    "        self.is_vegetarian = is_vegetarian\n",
    "        self.ingredients = ingredients\n",
    "    \n",
    "    def get_total_calories(self):\n",
    "        \"\"\"Calculate calories based on the list of the ingredients.\"\"\"\n",
    "        calories = 0\n",
    "        for ingredient in self.ingredients:\n",
    "            calories = calories + ingredient.calculate_calories()\n",
    "        return calories\n",
    "    \n",
    "    def __str__(self):\n",
    "        calories = self.get_total_calories()\n",
    "        return f\"{self.name} has {calories:.7} calories in it.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בקוד שלמעלה הגדרנו פעולת <code>__init__</code> שתקבל את שם המנה, משתנה בוליאני שקובע אם היא צמחונית או לא ורשימת רכיבים.<br>\n",
    "    הפעולה <var>get_total_calories</var> תעבור על הרכיבים ותסכום את מספרי הקלוריות של כל אחד מהם.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    נבדוק שהמחלקה עובדת.<br>\n",
    "    ניצור רשימת רכיבים ונעביר אותה ל־<var>Dish</var> כדי לייצר מופע של מנה:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ingredients = [\n",
    "    Ingredient('Butter', carbs=0.1, fats=81.9, proteins=0.9),\n",
    "    Ingredient('Honey', carbs=82, fats=0, proteins=0.3),\n",
    "    Ingredient('Flour', carbs=79, fats=1.8, proteins=7),\n",
    "]\n",
    "bread = Dish(\"Lembas Bread\", is_vegetarian=True, ingredients=ingredients)\n",
    "print(bread)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    העיקרון של שימוש במופעי מחלקה אחת בתוך מחלקה אחרת נקרא <dfn>הכלה</dfn> (<var>Containment</var>).<br>\n",
    "    זוהי טכניקה שימושית ונפוצה מאוד בתכנות מחלקות, ותשמש אותנו רבות ביום־יום כמתכנתים.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">תרגיל ביניים: צָב שָׁלוּחַ 2</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    מנהל הדואר הידוע והאהוב קיפיק הצב אהב את מחלקת <var>PostOffice</var> שבניתם.<br>\n",
    "    מרוב התלהבות, הוא מעוניין שגם ההודעות עצמן ייוצגו בעזרת מחלקה.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    צרו את מחלקת <var>Message</var> והחליטו אילו תכונות כדאי שיהיו לה.<br>\n",
    "    ממשו פעולת <code>__str__</code> שתציג את ההודעה בצורה נאה.<br>\n",
    "    הרצת הפונקציה <var>len</var> על מופע של הודעה יחזיר את אורך ההודעה (ללא הכותרת).\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    ודאו שהתאמתם את פעולות מחלקת <var>PostOffice</var> כך שיפעלו גם על <var>Message</var>.<br>\n",
    "    אם עולה הצורך, קראו באינטרנט על פעולות קסם.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">כימוס, הגנה ופרטיות</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    מחלקת <var>Dish</var> שכתבנו שינתה את עולם המסעדנות כולו, ואין מתכנת מסעדן שלא משתמש בה.<br>\n",
    "    הגברת קיפף אוסין משתמשת בה במסעדת הדגל שלה \"מסון קייפי\" ומעוניינת להשתמש בה במסעדה החדשה שלה, \"7 טעמים\".\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    במסעדת 7 טעמים אין אף מנה שמורכבת מיותר מ־7 רכיבים, והגברת אוסין מבקשת מאיתנו לעזור לה לאכוף זאת במחלקה.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"align-center\" style=\"display: flex; text-align: right; direction: rtl; clear: both;\">\n",
    "    <div style=\"display: flex; width: 10%; float: right; clear: both;\">\n",
    "        <img src=\"images/exercise.svg\" style=\"height: 50px !important;\" alt=\"תרגול\"> \n",
    "    </div>\n",
    "    <div style=\"width: 70%\">\n",
    "        <p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "            נסו לחשוב בעצמכם איך אתם הייתם פותרים את הבעיה.<br>\n",
    "            כיצד תשפרו את מחלקת <var>Dish</var> כך שתגביל את המשתמשים בה לעד 7 רכיבים?\n",
    "        </p>\n",
    "    </div>\n",
    "    <div style=\"display: flex; width: 20%; border-right: 0.1rem solid #A5A5A5; padding: 1rem 2rem;\">\n",
    "        <p style=\"text-align: center; direction: rtl; justify-content: center; align-items: center; clear: both;\">\n",
    "            <strong>חשוב!</strong><br>\n",
    "            פתרו לפני שתמשיכו!\n",
    "        </p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    ישנם הרבה פתרונות יצירתיים ומעניינים שיכולים לשמש אותנו במקרה שסופקו יותר מ־7 רכיבים.<br>\n",
    "    אפשר, לדוגמה, לקחת רק את 7 הרכיבים הראשונים שאנחנו מקבלים, או להשאיר את רשימת הרכיבים ריקה.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    אחת הבחירות האפשריות היא לא לקבל מלכתחילה בפעולת האתחול <code>__init__</code> את רשימת הרכיבים.<br>\n",
    "    במקרה כזה נצטרך לספק למשתמש דרך נוחה להוסיף רכיבים לתכונה <var>ingredients</var> ולהוריד רכיבים ממנה.<br>\n",
    "    נאתחל את התכונה לרשימה ריקה, ונוסיף ל־<var>Dish</var> את הפעולות <var>add_ingredient</var> ו־<var>remove_ingredient</var>.<br>\n",
    "    ברגע שהמשתמש במחלקה יקרא ל־<var>add_ingredient</var> כשיש במנה כבר 7 רכיבים, נכשיל את הוספת הרכיב העודף:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dish:\n",
    "    MAX_INGREDIENTS = 7\n",
    "    \n",
    "    \"\"\"Create a new dish for the restaurant using our ingredients.\n",
    "    \n",
    "    Args:\n",
    "        name (str): The name of the dish.\n",
    "        is_vegetarian (bool): `True` if the dish is vegetarian.\n",
    "\n",
    "    Attributes:\n",
    "        name (str): The name of the dish.\n",
    "        is_vegetarian (bool): `True` if the dish is vegetarian.\n",
    "        ingredients (list of Ingredient): All the required ingredients\n",
    "                                          for the dish.\n",
    "    \"\"\"\n",
    "    def __init__(self, name, is_vegetarian):\n",
    "        self.name = name\n",
    "        self.is_vegetarian = is_vegetarian\n",
    "        self.ingredients = []\n",
    "\n",
    "    def can_add_ingredient(self):\n",
    "        \"\"\"Return True if we should allow to add another ingredient.\"\"\"\n",
    "        return (\n",
    "            self.MAX_INGREDIENTS is None\n",
    "            or len(self.ingredients) < self.MAX_INGREDIENTS\n",
    "        )\n",
    "\n",
    "    def add_ingredient(self, ingredient):\n",
    "        \"\"\"Add an ingredient to the dish.\n",
    "        \n",
    "        If the class variable MAX_INGREDIENTS is set, and there are\n",
    "        at least MAX_INGREDIENTS ingredients in the dish, the call\n",
    "        to this function will fail.\n",
    "        \n",
    "        Args:\n",
    "            ingredient (Ingredient): An `Ingredient` instance to add.\n",
    "        \"\"\"\n",
    "        if not self.can_add_ingredient():\n",
    "            return\n",
    "        self.ingredients.append(ingredient)\n",
    "\n",
    "    def remove_ingredient(self, ingredient):\n",
    "        \"\"\"Remove an ingredient from the dish.\n",
    "        \n",
    "        Args:\n",
    "            ingredient (Ingredient): An `Ingredient` instance to add.\n",
    "\n",
    "        Raises:\n",
    "            ValueError: If the supplied ingredient is not in the\n",
    "                        ingredients list.\n",
    "        \"\"\"\n",
    "        self.ingredients.remove(ingredient)\n",
    "    \n",
    "    def get_total_calories(self):\n",
    "        \"\"\"Calculate calories based on the list of the ingredients.\"\"\"\n",
    "        calories = 0\n",
    "        for ingredient in self.ingredients:\n",
    "            calories = calories + ingredient.calculate_calories()\n",
    "        return calories\n",
    "\n",
    "    def __str__(self):\n",
    "        calories = self.get_total_calories()\n",
    "        return f\"{self.name} has {calories:.7} calories in it.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    נבדוק שהמחלקה עובדת.<br>\n",
    "    לנוחיותכם, פירטנו מעל כל חלק מה יעשה הקוד.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ניצור מנה של קוקטייל\n",
    "great_cocktail = Dish(\"Black Magic Julep\", is_vegetarian=True)\n",
    "\n",
    "# נכין את הרכיבים בצד\n",
    "ingredients = [\n",
    "    Ingredient(\"Angostura bitters\", carbs=80, fats=0, proteins=0),\n",
    "    Ingredient(\"Fernet branca\", carbs=46.41, fats=0, proteins=0),\n",
    "    Ingredient(\"Four roses\", carbs=69, fats=0, proteins=0),\n",
    "    Ingredient(\"Mint leaves\", carbs=15, fats=3.8, proteins=0.9),\n",
    "    Ingredient(\"Amaro Averna\", carbs=20.9, fats=15.7, proteins=2.8),\n",
    "    Ingredient(\"Amaro Montenegro\", carbs=54, fats=0, proteins=0),\n",
    "    Ingredient(\"Amaro Nonino\", carbs=33, fats=0, proteins=0),\n",
    "]\n",
    "\n",
    "# נצרף את 7 הרכיבים לקוקטייל\n",
    "for ingredient in ingredients:\n",
    "    great_cocktail.add_ingredient(ingredient)\n",
    "\n",
    "# נבדוק שהכל עבד כשורה\n",
    "print(len(great_cocktail.ingredients))\n",
    "print(great_cocktail)\n",
    "\n",
    "# נוסיף את הרכיב השמיני\n",
    "sugar = Ingredient(\"Sugar\", carbs=100, fats=0, proteins=0)\n",
    "great_cocktail.add_ingredient(sugar)\n",
    "\n",
    "# נוודא שלא התווסף\n",
    "print('-' * 40)\n",
    "print(\"Tried adding the 8th ingredient.\")\n",
    "print(f\"Success: {sugar in great_cocktail.ingredients}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    אם ננסה להוציא את הסוכר, נגלה שהוא אכן לא ברשימת הרכיבים:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "great_cocktail.remove_ingredient(sugar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    מזל טוב! הכל עובד וקיפף מרוצה, בינתיים.<br>\n",
    "    הכנתם לכולם Black Magic Julep כדי לחגוג את המאורע, לגמתם בשקיקה שני שלוקים ו...\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    \"יש בעיה חמורה במחלקה!\", מזדעק הסו־שף מפינת החדר. נראה שהוא טרם לגם מהמשקה שלו. הסו־שף מוסיף:<br>\n",
    "    \"משתמש שלא מכיר את המחלקה, יכול בטעות לערוך ישירות את התכונה <var>ingredient</var> השייכת למופע של המאכל שיצרנו.<br>\n",
    "    בכך הוא יעקוף את המגבלה שהצבנו בפעולה <var>add_ingredient</var>:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "great_cocktail.ingredients.append(sugar)\n",
    "print(len(great_cocktail.ingredients))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    זה אולי נשמע מקרה קצה זניח, אבל אחת ההנחות שלנו כמתכנתים היא שמותר לשנות מאפייני מחלקה ללא חשש.<br>\n",
    "    במקרה כזה, הוא יוכל בהיסח הדעת להוסיף בשגגה סוכר כמרכיב שמיני לקוקטייל!\"\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    היסטריה המונית פורצת בחדר. עלי נענע ומטריות קוקטיילים מתעופפים לכל עבר.<br>\n",
    "    בתוך שניות ספורות אתם משתלטים על המצב, ואחרי דקה אתם כבר שקועים עמוק בקריאת מאמר שמדבר על תכנות מחלקות.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <mark>מתברר שאם מוסיפים את התו <code>_</code> לפני שם התכונה, היא הופכת להיות תכונה \"<dfn>מוגנת</dfn>\" (<dfn>protected</dfn>).</mark><br>\n",
    "    מצב כזה מסמן למתכנתים אחרים שהתכונה מיועדת לשימוש פנימי של המחלקה, ושאסור לגשת אליה מבחוץ.<br>\n",
    "    \"אין לפנות לתכונה כזו בקוד שכתוב מחוץ למחלקה\", נכתב במאמר. \"לא למטרות קריאה ולא למטרות כתיבה\".<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    שיניתם את המחלקה. אף על פי שהשימוש בה נראה בדיוק אותו דבר, התכונה <var>ingredients</var> קיבלה קו תחתון לפני שמה.<br>\n",
    "    המחלקה המתוקנת שיצרתם נראית עכשיו כך:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dish:\n",
    "    MAX_INGREDIENTS = 7\n",
    "    \n",
    "    \"\"\"Create a new dish for the restaurant using our ingredients.\n",
    "    \n",
    "    Args:\n",
    "        name (str): The name of the dish.\n",
    "        is_vegetarian (bool): `True` if the dish is vegetarian.\n",
    "\n",
    "    Attributes:\n",
    "        name (str): The name of the dish.\n",
    "        is_vegetarian (bool): `True` if the dish is vegetarian.\n",
    "        _ingredients (list of Ingredient): All the required ingredients\n",
    "                                           for the dish.\n",
    "    \"\"\"\n",
    "    def __init__(self, name, is_vegetarian):\n",
    "        self.name = name\n",
    "        self.is_vegetarian = is_vegetarian\n",
    "        self._ingredients = []\n",
    "\n",
    "    def can_add_ingredient(self):\n",
    "        \"\"\"Return True if we should allow to add another ingredient.\"\"\"\n",
    "        return (\n",
    "            self.MAX_INGREDIENTS is None\n",
    "            or len(self._ingredients) < self.MAX_INGREDIENTS\n",
    "        )\n",
    "\n",
    "    def add_ingredient(self, ingredient):\n",
    "        \"\"\"Add an ingredient to the dish.\n",
    "        \n",
    "        If the class variable MAX_INGREDIENTS is set, and there are\n",
    "        at least MAX_INGREDIENTS ingredients in the dish, the call\n",
    "        to this function will fail.\n",
    "        \n",
    "        Args:\n",
    "            ingredient (Ingredient): An `Ingredient` instance to add.\n",
    "        \"\"\"\n",
    "        if not self.can_add_ingredient():\n",
    "            return\n",
    "        self._ingredients.append(ingredient)\n",
    "\n",
    "    def remove_ingredient(self, ingredient):\n",
    "        \"\"\"Remove an ingredient from the dish.\n",
    "        \n",
    "        Args:\n",
    "            ingredient (Ingredient): An `Ingredient` instance to add.\n",
    "\n",
    "        Raises:\n",
    "            ValueError: If the supplied ingredient is not in the\n",
    "                        ingredients list.\n",
    "        \"\"\"\n",
    "        self._ingredients.remove(ingredient)\n",
    "    \n",
    "    def get_total_calories(self):\n",
    "        \"\"\"Calculate calories based on the list of the ingredients.\"\"\"\n",
    "        calories = 0\n",
    "        for ingredient in self._ingredients:\n",
    "            calories = calories + ingredient.calculate_calories()\n",
    "        return calories\n",
    "\n",
    "    def __str__(self):\n",
    "        calories = self.get_total_calories()\n",
    "        return f\"{self.name} has {calories:.7} calories in it.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    לפעמים ניתקל במקרה שבו נרצה למנוע גישה ישירה לתכונות מסוימות של מחלקה מצד גורמים לא מורשים.<br>\n",
    "    פתיחת שם התכונה בתו <code>_</code> וסימונה כמוגנת, או במילים אחרות מתאימה לשימוש רק בתוך המחלקה, יכולות לשרת אותנו להשגת המטרה הזו.<br>\n",
    "    זו מוסכמה חזקה מאוד בקרב מתכנתי פייתון: עשו מה שאפשר כדי לא לגשת לתכונות ששמן מתחיל בקו תחתון מתוך קוד שנמצא מחוץ למחלקה.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    אם המשתמש במחלקה ירצה להשיג את ערכו של מופע או לשנות אותו, הוא יוכל לקרוא לפעולה שזו מטרתה.<br>\n",
    "    במקרה שלנו, הפעולות הללו הן <var>add_ingredient</var> או <var>remove_ingredient</var>.<br>\n",
    "    נוכל (וכדאי) שנממש פעולה לצפייה בתכונה, כמו <var>get_ingredients</var>.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    הגישה של החבאת נתונים מאחורי פעולות היא רעיון פופולרי מאוד בתכנות מונחה עצמים.<br>\n",
    "    לפי רעיון שנקרא \"<dfn>כימוס</dfn>\" (<dfn>Encapsulation</dfn>), על מחלקה לאגד תכונות ופעולות, ולהסתיר מידע עודף מאלו שמשתמשים במחלקה.<br>\n",
    "    הסתרת המידע משרתת שתי מטרות:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ul style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <li><em>פישוט והפחתת מורכבות</em>: נעדיף לחשוף למשתמש במחלקה רק תכונות ופעולות שחשובות עבורו, ולא פרטי מימוש.</li>\n",
    "    <li><em>שמירה על תקינות המופע</em>: נמנע מהמשתמש במחלקה לערוך מופעים בצורה לא מבוקרת, ובכך לגרום למופע להכיל מידע לא תקין.</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    ברוב שפות התכנות שאינן פייתון, שפת התכנות ממש מונעת גישה לתכונות מוגנות מתוך קוד שנמצא מחוץ למחלקה.<br>\n",
    "    בפייתון נהוג להגיד ש<q dir=\"rtl\" lang=\"he\">כולנו מבוגרים בעלי שיקול דעת</q>, ולכן פייתון לא מונעת גישה לתכונות מוגנות.<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    למרות זאת, בהקשר הזה יש לפייתון טריק מלוכלך בשרוול.<br>\n",
    "    אפשר להגדיר תכונות כ<dfn>פרטיות</dfn> (<dfn>private</dfn>) בעזרת הקידומת <code>__</code> (פעמיים קו תחתון).<br>\n",
    "    במקרה הזה, פייתון כן תתערב, וכן תנסה למנוע גישה לתכונה.<br>\n",
    "    נדגים בעזרת מחלקה פשוטה של משתמש:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class User:\n",
    "    def __init__(self, name, age, hobbies):\n",
    "        self.name = name\n",
    "        self._age = age\n",
    "        self.__hobbies = hobbies\n",
    "    \n",
    "    def __str__(self):\n",
    "        return (\n",
    "            f\"{self.name} is {self._age} years old. \"\n",
    "            + f\"He loves {self.__hobbies.lower()}.\"\n",
    "        )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    ניצור דמות שנקראת פרנקלין:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "character = User(\"Franklin\", 200, \"Lacing shoes\")\n",
    "print(character)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    וננסה לשנות לה את התכונות:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "character.name = \"Cookie Monster\"  # עם זה אין שום בעיה\n",
    "character._age = 54                # זה לא מנומס ומסוכן\n",
    "character.__hobbies = \"Cookies\"    # זה כבר ממש לא סבבה"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    אבל כשננסה להדפיס את Cookie Monster, נגלה שכל תכונות הדמות השתנו חוץ מהעובדה שהיא עדיין אוהבת לשרוך נעליים!\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(character)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    הסיבה לכך היא שכשפייתון רואה את התחילית <code>__</code> היא מבינה ש<em>ממש חשוב לכם</em> שאף גורם חיצוני למחלקה לא ייגש לתכונה.<br>\n",
    "    אף על פי שניסיון פשוט לגשת לתכונה <var dir=\"ltr\">__hobbies</var> מחוץ למחלקה לא יישא פרי, אם נחטט טוב נגלה שעדיין ישנה דרך לעשות זאת.<br>\n",
    "    מתברר שפייתון רק משנה את שם התכונה למשהו מעט מסובך יותר כדי \"להחביא\" אותה טוב יותר:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "character._User__hobbies = \"Cookies\"\n",
    "print(character)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    תכונה שמתחילה בתחילית <code>__</code> בפייתון נקראת, כאמור, \"תכונה פרטית\" (private).<br>\n",
    "    גם בה מותר להשתמש רק בתוך המחלקה, רק שהפעם פייתון עושה טריק מלוכלך כדי למנוע מכם להשתמש בתכונה בכל זאת.<br>\n",
    "    פייתון משנה את שם התכונה לקו תחתון, שם המחלקה, שני קווים תחתונים ואז שם התכונה.<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    השם המקצועי לשינוי שם משתנה כדי לפתור בעיית ארכיטקטורה הוא <dfn>name mangling</dfn>, והקיום שלו בפייתון הוא נושא טעון בקרב קהילת המפתחים בשפה.<br>\n",
    "    עקב כך, הקידומת <code>__</code> היא אחת מהיכולות היותר שנויות במחלוקת בשפה ועדיף לא להשתמש בה, אלא אם כן ממש חייבים.<br>\n",
    "    כל עוד המקרה הוא לא קיצוני מאוד, העדיפו להגן על משתנה בעזרת קידומת של קו תחתון אחד.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"align-center\" style=\"display: flex; text-align: right; direction: rtl; clear: both;\">\n",
    "    <div style=\"display: flex; width: 10%; float: right; clear: both;\">\n",
    "        <img src=\"images/exercise.svg\" style=\"height: 50px !important;\" alt=\"תרגול\" title=\"תרגול\"> \n",
    "    </div>\n",
    "    <div style=\"width: 70%\">\n",
    "        <p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "            אפשר להגדיר גם פעולות כמוגנות או כפרטיות אם נוסיף להן את התחילית <code>_</code> או <code>__</code>, בהתאמה.<br>\n",
    "            כיוון ש־<var>can_add_ingredient</var> מיועדת לשימוש פנימי, שנו את הפעולה כך שתוגדר כמוגנת.\n",
    "        </p>\n",
    "    </div>\n",
    "    <div style=\"display: flex; width: 20%; border-right: 0.1rem solid #A5A5A5; padding: 1rem 2rem;\">\n",
    "        <p style=\"text-align: center; direction: rtl; justify-content: center; align-items: center; clear: both;\">\n",
    "            <strong>חשוב!</strong><br>\n",
    "            פתרו לפני שתמשיכו!\n",
    "        </p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"align-center\" style=\"display: flex; text-align: right; direction: rtl;\">\n",
    "    <div style=\"display: flex; width: 10%; \">\n",
    "        <img src=\"images/deeper.svg?a=1\" style=\"height: 50px !important;\" alt=\"העמקה\" title=\"העמקה\"> \n",
    "    </div>\n",
    "    <div style=\"width: 90%\">\n",
    "        <p style=\"text-align: right; direction: rtl;\">\n",
    "            ישנם מקרים מיוחדים שטרם למדנו, שבהם אפשר לגשת לתכונות ולפעולות מוגנות ממחלקות אחרות.<br>\n",
    "            לעומתן, תכונות או פעולות שמוגדרות כפרטיות נגישות <em>רק</em> מתוך המחלקה שיצרה אותן.<br>\n",
    "            ההפרדה בין שני הרעיונות נפוצה בעיקר בשפות אחרות, ובפייתון נהוג להשתמש בתחילית <code>_</code> (משתנה מוגן) בשני המקרים.<br>\n",
    "            מהסיבה הזו אנשים רבים יקראו לתכונה או לפעולה עם קידומת <code>_</code> בפייתון \"תכונה פרטית\" או \"פעולה פרטית\".\n",
    "        </p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">פעולות גישה ושינוי</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כמו שראינו השבוע, פייתון מתירה כברירת מחדל גישה נוחה לתכונות של מופעים בעזרת קוד שנכתב מחוץ למחלקה.<br>\n",
    "    בניגוד לפייתון, בשפות אחרות לא נהוג לאפשר גישה ישירה לתכונות המחלקה.<br>\n",
    "    מתוך הרגל, מתכנתים שמגיעים משפות אחרות משתמשים לעיתים תכופות בהחבאת נתונים בצורה לא מידתית:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ingredient:\n",
    "    def __init__(self, name, carbs, fats, proteins):\n",
    "        self.set_name(name)\n",
    "        self.set_carbs(carbs)\n",
    "        self.set_fats(fats)\n",
    "        self.set_proteins(proteins)\n",
    "\n",
    "    def set_name(self, new_name):\n",
    "        self._name = new_name\n",
    "\n",
    "    def get_name(self):\n",
    "        return self._name\n",
    "\n",
    "    def set_carbs(self, updated_carbs):\n",
    "        self._carbs = updated_carbs\n",
    "\n",
    "    def get_carbs(self):\n",
    "        return self._carbs\n",
    "    \n",
    "    def set_fats(self, updated_fats):\n",
    "        self._fats = updated_fats\n",
    "\n",
    "    def get_fats(self):\n",
    "        return self._fats\n",
    "\n",
    "    def set_proteins(self, updated_proteins):\n",
    "        self._proteins = updated_proteins\n",
    "\n",
    "    def get_proteins(self):\n",
    "        return self._proteins\n",
    "    \n",
    "    def get_calories(self):\n",
    "        return (\n",
    "            self.get_carbs() * 4\n",
    "            + self.get_fats() * 9\n",
    "            + self.get_proteins() * 4\n",
    "        )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    הרעיון בקוד שהוצג למעלה נקרא \"<dfn>פעולות גישה ושינוי</dfn>\" (<dfn>accessor and mutator methods</dfn>), או <dfn>getters and setters</dfn>.<br>\n",
    "    אלו פעולות שמטרתן עריכת תכונות מסוימות או אחזור של הערך הנוכחי שלהן, תוך כדי ניסיון למנוע מהמשתמש במחלקה לגשת ישירות לערך התכונה.<br>\n",
    "    המטרה של מתכנת שנוהג כך היא לדאוג שהוא תמיד יוכל לשלוט על ערכי התכונות, לוודא את תקינותם ולמנוע מופע שמכיל נתונים שאינם תקינים.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    שימוש שכזה בפעולות גישה ושינוי הוא נדיר יחסית בפייתון.<br>\n",
    "    בזכות היכולת לגשת לתכונות של מופע ישירות מחוץ למחלקה, כתיבת מחלקות הופכת להיות מהירה ונעימה לשימוש.<br> \n",
    "    כתיבת getter ו־setter לכל תכונה עשויה לגרום למחלקות בפייתון להפוך למסורבלות וארוכות, והשימוש בהן נעשה לא נוח:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "strawberries = Ingredient(\"Strawberries\", carbs=8, fats=0.4, proteins=0.7)\n",
    "\n",
    "print(f\"Before: {strawberries.get_calories()}\")\n",
    "# ננסה לערוך את כמות השומנים בתותים ל־0.3 במקום\n",
    "strawberries.set_fats(strawberries.get_fats() - 0.1)\n",
    "\n",
    "print(f\"After: {strawberries.get_calories()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    עקב הסרבול שבעניין, בפייתון לרוב נעדיף להשתמש בפעולות גישה ושינוי רק כשיש צורך ממשי בהגדרת תכונות כמוגנות או כפרטיות. \n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">מונחים</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<dl style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <dt>משתני מחלקה (Class Variables)</dt>\n",
    "    <dd>\n",
    "        משתנים המוגדרים ברמת המחלקה ונגישים עבור כל המופעים שנוצרו ממנה.<br>\n",
    "        בדרך כלל אלו משתנים קבועים שהמופעים משתמשים בהם לצורכי קריאה בלבד.<br>\n",
    "        לדוגמה: משתנה בראש מחלקת \"תיבת דואר\" שמגדיר את נפח האחסון המירבי ל־5 ג'יגה בייט.\n",
    "    </dd>\n",
    "    <dt>הכלה (Containment)</dt>\n",
    "    <dd>\n",
    "        מצב שבו נעשה שימוש במופע שנוצר במחלקה A בתוך מופע של מחלקה B.<br>\n",
    "        לדוגמה: בתוך מופע של מחלקת \"הודעת דואר\", תכונת הנמען והמוען יהיו מופעים של מחלקת \"משתמש\". \n",
    "    </dd>\n",
    "    <dt>כימוס (Encapsulation)</dt>\n",
    "    <dd>\n",
    "        איגוד תכונות ופעולות תחת מחלקה, וצמצום הגישה של המשתמש במחלקה למצב הפנימי של המופעים שנוצרו ממנה.<br>\n",
    "        בפועל, ימומש על ידי הגבלה לגישה ולעריכה של תכונות ופעולות מסוימות, כך שיתאפשרו רק מקוד שנכתב בתוך המחלקה.<br>\n",
    "        עם זאת, החלטה על הסתרת תכונות רבות מדי עלולה ליצור קוד ארוך ומסורבל, ובפייתון נהוג להשתמש ברעיון בצמצום.<br>\n",
    "    </dd>\n",
    "    <dt>תכונה/פעולה מוגנת (Protected Attribute) או תכונה/פעולה פרטית (Private Attribute)</dt>\n",
    "    <dd>\n",
    "        תכונה שהגישה אליה יכולה להתבצע רק מתוך המחלקה.<br>\n",
    "        טכנית, פייתון תמיד מאפשרת למתכנת לשנות ערכים – אפילו אם הם מוגדרים כמוגנים או כפרטיים.<br>\n",
    "        מעשית, עליכם להימנע בכל דרך אפשרית משינוי של משתנה שמוגדר כמוגן או פרטי, כל עוד אתם יכולים.\n",
    "    </dd>\n",
    "    <dt>פעולת גישה ושינוי (Accessor/Mutator Method)</dt>\n",
    "    <dd>\n",
    "        פעולה שמטרתה לגשת (Accessor) או לשנות (Mutator) ערך של תכונה מסוימת, בעיקר בהקשרי תכונות מוגנות או פרטיות.<br>\n",
    "        מטרת ה־Accessor היא לאחזר את ערך התכונה המבוקשת בצורה מתאימה, לעיתים אחרי עיבוד מסוים.<br>\n",
    "        מטרת ה־Mutator היא לוודא ששינוי הערך תקין ולא מזיק למופע או משנה אותו למצב לא תקין.<br>\n",
    "        פעולות אלו נקראות גם <dfn>getters</dfn> ו־<dfn>setters</dfn>.\n",
    "    </dd>\n",
    "</dl>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">תרגיל לדוגמה</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בהמשך להצלחה המסחררת של אפליקציית צ'יקצ'וק, החלטנו להשיק את יישומון המסרים המיידיים \"מנשמעעעעעעע XPPP\".<br>\n",
    "    תחילה, ניצור מחלקה שתייצג משתמש.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    לכל משתמש יש:\n",
    "</p>\n",
    "\n",
    "<ul style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <li><em>תכונות</em>: כינוי (<var>nickname</var>) תאריך אחרון שנצפה (<var>last_seen</var>) ואנשי קשר (<var>contacts</var>).</li>\n",
    "    <li><em>פעולות</em>: התחבר (<var>connect</var>), האם מחובר? (<var>is_online</var>; בודקת אם התחבר בדקה האחרונה).</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    לכל הודעה יש:\n",
    "</p>\n",
    "\n",
    "<ul style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <li><em>תכונות</em>: תאריך שליחה (<var>send_date</var>), אם נצפתה (<var>seen</var>), מוען (שולח; <var>sender</var>), נמען (מקבל; <var>recipient</var>) ותוכן (<var>content</var>).</li>\n",
    "    <li><em>פעולות</em>: סימון הודעה כנקראה (<var>mark_as_read</var>).</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "import time\n",
    "\n",
    "\n",
    "class User:\n",
    "    \"\"\"A user can connect and can contact with other users.\n",
    "\n",
    "    Args:\n",
    "        nickname (str): The username of the user.\n",
    "\n",
    "    Attributes:\n",
    "        nickname (str): The username of the user.\n",
    "        _contacts (list of User): Other users whose added to the\n",
    "                                  user's contacts.\n",
    "        last_seen (float): The last time the user connected in seconds\n",
    "                           since the Epoch.\n",
    "    \"\"\"\n",
    "    SECONDS_UNTIL_DISCONNECTED = 60\n",
    "\n",
    "    def __init__(self, nickname):\n",
    "        self.nickname = nickname\n",
    "        self._contacts = []\n",
    "        self.last_seen = time.time()\n",
    "\n",
    "    def is_online(self):\n",
    "        \"\"\"Determine if the user is currently connected.\n",
    "\n",
    "        \"Connected user\" is a user that logged in at the last X\n",
    "        seconds, where X is a constant defined as a class variable.\n",
    "\n",
    "        Returns:\n",
    "            bool: True if the user currently connected, False otherwise.\n",
    "        \"\"\"\n",
    "        seconds_since_seen = time.time() - self.last_seen\n",
    "        return seconds_since_seen < self.SECONDS_UNTIL_DISCONNECTED\n",
    "\n",
    "    def connect(self):\n",
    "        \"\"\"Makes the user connected.\n",
    "\n",
    "        Returns:\n",
    "            None.\n",
    "        \"\"\"\n",
    "        self.last_seen = time.time()\n",
    "    \n",
    "    def add_contact(self, contact):\n",
    "        \"\"\"Add contact to the user's contacts.\n",
    "\n",
    "        Args:\n",
    "            contact (User): A user to add to the user's contacts.\n",
    "\n",
    "        Returns:\n",
    "            bool: True if the addition was successful, False otherwise.\n",
    "        \"\"\"\n",
    "        if contact in self._contacts:\n",
    "            return False\n",
    "        self._contacts.append(contact)\n",
    "        return True\n",
    "\n",
    "    def remove_contact(self, contact):\n",
    "        \"\"\"Remove a contact from the user's contacts.\n",
    "\n",
    "        Args:\n",
    "            contact (User): A user to remove from the user's contacts.\n",
    "\n",
    "        Returns:\n",
    "            bool: True if the deletion was successful, False otherwise.\n",
    "        \"\"\"\n",
    "        if contact not in self._contacts:\n",
    "            return False\n",
    "        self._contacts.remove(contact)\n",
    "        return True\n",
    "\n",
    "    def get_contacts(self):\n",
    "        \"\"\"Return the user's contacts list.\"\"\"\n",
    "        return self._contacts\n",
    "    \n",
    "    def pretty_last_seen(self, dateformat='%Y-%m-%d %H:%M:%S'):\n",
    "        \"\"\"Show prettified date of when the user last connected.\n",
    "\n",
    "        Args:\n",
    "            dateformat (str): The format in which the time will\n",
    "                              be displayed. \n",
    "\n",
    "        Returns:\n",
    "            str: Last time the user connected.\n",
    "        \"\"\"\n",
    "        localtime = time.localtime(self.last_seen)\n",
    "        return time.strftime(dateformat, localtime)\n",
    "    \n",
    "    def __str__(self):\n",
    "        \"\"\"Show the user's details.\n",
    "\n",
    "        Returns:\n",
    "            str: The user representation currently.\n",
    "        \"\"\"\n",
    "        if self.is_online():\n",
    "            seen_message = 'Online'\n",
    "        else:\n",
    "            seen_message = self.pretty_last_seen()\n",
    "        return f\"{self.nickname} ({seen_message})\"\n",
    "\n",
    "\n",
    "class Message:\n",
    "    \"\"\"A deliverable message with status.\n",
    "    \n",
    "    A message can be sent from one user to another and\n",
    "    can be mark as read by the recipient.\n",
    "    \n",
    "    Args:\n",
    "        sender (User): The message sender's user.\n",
    "        recipient (User): The message recipient's user.\n",
    "        content (str): The body of the message.\n",
    "\n",
    "    Attributes:\n",
    "        send_date (float): The time the message was sent \n",
    "                           in seconds since the Epoch.\n",
    "        seen (bool): True if the recipient saw the message.\n",
    "        sender (User): The message sender's user.\n",
    "        recipient (User): The message recipient's user.\n",
    "        content (str): The body of the message.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, sender, recipient, content):\n",
    "        self.send_date = time.time()\n",
    "        self.seen = False\n",
    "        self.sender = sender\n",
    "        self.recipient = recipient\n",
    "        self.content = content\n",
    "\n",
    "    def pretty_send_date(self, dateformat='%Y-%m-%d %H:%M:%S'):\n",
    "        \"\"\"Show prettified date of when the message was sent.\n",
    "\n",
    "        Args:\n",
    "            dateformat (str): The format in which the time will be\n",
    "                              displayed. \n",
    "\n",
    "        Returns:\n",
    "            str: The time the message was sent.\n",
    "        \"\"\"\n",
    "        localtime = time.localtime(self.send_date)\n",
    "        return time.strftime(dateformat, localtime)\n",
    "\n",
    "    def mark_as_read(self):\n",
    "        \"\"\"Mark the message as read.\n",
    "\n",
    "        Returns:\n",
    "            None.\n",
    "        \"\"\"\n",
    "        self.seen = True\n",
    "\n",
    "    def __str__(self):\n",
    "        \"\"\"Return the message's details.\n",
    "\n",
    "        Returns:\n",
    "            str: The message representation.\n",
    "        \"\"\"\n",
    "        message = (\n",
    "            f\"From: {self.sender}\\n\"\n",
    "            f\"To: {self.recipient}\\n\"\n",
    "            f\"{self.pretty_send_date()}\\n\"\n",
    "            f\"-------------------\\n\"\n",
    "            f\"Message: {self.content}\\n\"\n",
    "        )\n",
    "        if self.seen:\n",
    "            message = message + f\"(Seen)\"\n",
    "        return message.strip()\n",
    "\n",
    "\n",
    "def link_everyone(users):\n",
    "    for user in users:\n",
    "        for another_user in users:\n",
    "            if user != another_user:\n",
    "                user.add_contact(another_user)\n",
    "\n",
    "\n",
    "print(\"First example:\\n----\")\n",
    "anonymous = User(\"Zarop\")\n",
    "almog = User(\"Almog\")\n",
    "advertisement = \"Click to get your Cookie!\"\n",
    "message = Message(sender=anonymous, recipient=almog, content=advertisement)\n",
    "print(message)\n",
    "\n",
    "print(\"\\n\\nSecond example:\\n----\")\n",
    "users = [User(\"Athos\"), User(\"Porthos\"), User(\"Aramis\"), User(\"D'Artagnan\")]\n",
    "link_everyone(users)\n",
    "print(\"Contacts: \" + str(len(users[0].get_contacts())))\n",
    "message = Message(\n",
    "    sender=users[0],\n",
    "    recipient=users[1],\n",
    "    content=\"Tous pour un, un pour tous, c'est notre devise\"\n",
    ")\n",
    "print(message)\n",
    "message.mark_as_read()\n",
    "print(\"\\nAfter read:\\n\")\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    למה כדאי לשים לב בפתרון?\n",
    "</p>\n",
    "\n",
    "<ol style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <li>אנחנו משתמשים בכימוס במשורה – רק כשזה משפר את התנהגות המחלקה.</li>\n",
    "    <li>מחלקת <var>User</var> מוכלת בתוך מחלקת <var>Message</var>.</li>\n",
    "    <li>לא הרשינו למספרים להסתובב בקוד – <var>SECONDS_UNTIL_DISCONNECTED</var> הוא משתנה מחלקה קבוע שערכו 60.</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">תרגילים</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">אורטל קומבט – חלק 2</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">Player</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    במחלקת <var>Player</var> שבניתם, שנו את הפעולה <var>attack</var>.<br>\n",
    "    אם הפעולה לא מקבלת פרמטרים ואין לשחקן אויבים, היא תחזיר <samp>False</samp> במקום לזרוק <var>IndexError</var>.<br>\n",
    "    אם התקיפה הצליחה, הפעולה תחזיר <samp>True</samp>.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">Arena</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    ממשו מחלקת זירה בשם <var>Arena</var>.<br>\n",
    "    פעולת האתחול של <var>Arena</var> מקבלת את מספר השחקנים המרבי שאפשר להכניס לזירה.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    המחלקה תכיל לכל הפחות את התכונות הבאות:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ul style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <li><var>players</var> – מכילה את רשימת השחקנים בזירה.</li>\n",
    "    <li><var>next_player</var> – מכילה את השחקן שתורו לשחק כעת.</li>\n",
    "    <li><var>winner</var> – מכילה את השחקן שניצח, או <code>None</code> אם עדיין אין אחד כזה.</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    במחלקה ימומשו גם הפעולות הבאות:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ul style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <li><var>hajime</var> – מתחיל את הקרב. החל משלב זה אי אפשר להוסיף או להסיר שחקנים מהזירה.</li>\n",
    "    <li><var>get_players</var> – מחזירה את רשימת השחקנים בזירה.</li>\n",
    "    <li><var>add_player</var> – הוסף שחקן לזירה. אם הוא כבר בזירה או אם הקרב כבר התחיל, מחזירה False.</li>\n",
    "    <li><var>remove_player</var> – מקבלת שחקן ומסירה אותו מהזירה. אם הוא אינו בזירה או אם הקרב כבר התחיל, מחזירה False.</li>\n",
    "    <li><var>make_move</var> – גורמת לשחקן שתורו כעת להפעיל פעולת <var>attack</var> ללא פרמטרים.<br>\n",
    "        אם הפעולה <var>attack</var> החזירה <samp>False</samp>, השחקן יבחר אויב חי אקראי מהזירה ויתקוף אותו.<br>\n",
    "    בסוף הפעולה, התור מועבר לשחקן הבא.</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    ודאו שכל זמן שיש שחקנים בזירה, <var>next_player</var> מצביעה למופע של שחקן.<br>\n",
    "    אם אין שחקנים בזירה, בעת אתחול המחלקה למשל, שנו את ערכה של <var>next_player</var> ל־<code>None</code>.<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">רמות ונקודות ניסיון</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כאשר שחקן א גורם לשחקן ב להיות מת ברובו, שחקן א יקבל מספר נקודות ניסיון לפי הנוסחה הבאה:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ EXP_{gain} = \\frac{L_{rival} \\cdot (2 \\cdot L_{rival} + 10)^{2.5}}{5 \\cdot (L_{rival} + L_{player} + 10) ^{2.5}} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כאשר $L_{rival}$ היא הרמה של המת ברובו (שחקן ב), ו־$L_{player}$ היא הרמה של המנצח (שחקן א).<br>\n",
    "    אם השחקן מת לחלוטין ולא רק מת ברובו, השחקן שניצח אותו מקבל פי 2 נקודות ניסיון.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    מספר נקודות הניסיון שיש להשיג בסך הכול כדי להגיע לרמה $L$ הוא:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\frac{4 \\cdot ({L-1})^{2.5}}{5} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">מתחילים לשחק</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    ממשו סימולציית קרב:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ul style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <li>צרו זירה שיכולה להכיל עד 4 משתתפים, וצרפו אליה מספר כזה של שחקנים. התחילו את הקרב.</li>\n",
    "    <li>התורות במשחק עוברים משחקן אחד לשני, כך שבכל סיבוב כל אחד מהשחקנים החיים משחק פעם אחת.</li>\n",
    "    <li>אם השחקן מת ברובו – הוא יעשה <var>revive</var> כשיגיע תורו, ויתקוף מייד אחר כך. החייאה לא עולה תור.</li>\n",
    "    <li>כל שחקן יכול למות ברובו עד פעמיים – ובפעם השלישית שהוא מת הוא נחשב מת לחלוטין.</li>\n",
    "    <li>אם השחקן מת לחלוטין, פעולת <var>revive</var> על השחקן תחזיר <samp>False</samp>, תורות לא יעברו אליו ושחקנים לא יתקיפו אותו.</li>\n",
    "    <li>כאשר נשאר בזירה רק שחקן חי אחד – הוא מוכתר כמנצח של הזירה.</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    הרגישו נוח להוסיף רכיבים לכל אחת מהמחלקות שלכם.<br>\n",
    "    תכנון נכון של המחלקות יאפשר לכם לצלוח את התרגיל בקלות רבה יותר.\n",
    "</p>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}