content/week08/1_Inheritance.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;\">ירושה</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",
    "    בשבוע שעבר למדנו מה הן מחלקות, וסקרנו טכניקות שונות הנוגעות לכתיבת קוד בעזרתן.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    למדנו כיצד ליצור <em>מחלקה</em>, שהיא בעצם תבנית שמתארת את ה<em>תכונות</em> ואת ה<em>פעולות</em> השייכות לכל <em>מופע</em> שנוצר ממנה.<br>\n",
    "    הסברנו מהי <em>פעולת אתחול</em> (<code>__init__</code>), שרצה מייד עם יצירתו של <em>מופע</em> חדש, ודיברנו על <em>פעולות קסם</em> נוספות.<br>\n",
    "    ראינו כיצד מגדירים <em>משתני מחלקה</em>, כאלו שמשותפים לכל המופעים,<br>\n",
    "    ודיברנו גם על <em>תכונות ופעולות פרטיות ומוגנות</em>, טכניקה שמאפשרת לנו להחליט אילו תכונות ופעולות אנחנו חושפים למשתמשים שלנו.<br>\n",
    "    לסיום, דיברנו גם על רעיון ה<em>הכלה</em>, שמאפשר לנו להשתמש במופעי מחלקה אחת בתוך מופעים של מחלקה אחרת. \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": [
    "### <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",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    לכל שיר יש שם, מילים ורשימת יוצרים.<br>\n",
    "    כדי לנהל את רשימת היוצרים, צרו את הפעולות <var>add_artist</var> ו־<var>remove_artist</var> שיוסיפו ויסירו אומנים בהתאמה.<br>\n",
    "    לשיר תהיה גם פעולה שנקראת <var>count_words</var> שתחזיר את מספר המילים בשיר.<br>\n",
    "    כמו כן, לכל שיר יהיה מונה שיספור כמה פעמים הוא הודפס.<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    הדפסת שיר תיראה כך:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\"Her Majesty's\" / The Beatles\n",
    "-----------------------------\n",
    "Her Majesty's a pretty nice girl\n",
    "But she doesn't have a lot to say\n",
    "Her Majesty's a pretty nice girl\n",
    "But she changes from day to day\n",
    "\n",
    "I want to tell her that I love her a lot\n",
    "But I gotta get a bellyful of wine\n",
    "Her Majesty's a pretty nice girl\n",
    "Someday I'm going to make her mine, oh yeah\n",
    "Someday I'm going to make her mine\n",
    "-----------------------------\n",
    "Seen: 1 time(s)."
   ]
  },
  {
   "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",
    "            נסו לממש את מחלקת השיר בעצמכם. \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 Song:\n",
    "    \"\"\"Represent a Song in our lyrics site.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    name : str\n",
    "        The name of the song.\n",
    "    lyrics : str\n",
    "        The lyrics of the song.\n",
    "    artists : list of str or str, optional\n",
    "        Can be either a list, or a string separated by commas.\n",
    "\n",
    "    Attributes\n",
    "    ----------\n",
    "    name : str\n",
    "        The name of the song.\n",
    "    lyrics : str\n",
    "        The lyrics of the song.\n",
    "    _views : int\n",
    "        Views counter, which indicates how many times the users printed\n",
    "        a specific song.\n",
    "    _artists : list of str\n",
    "        A list of the song's artists.\n",
    "    \"\"\"\n",
    "    def __init__(self, name, lyrics, artists=None):\n",
    "        self.name = name\n",
    "        self.lyrics = lyrics\n",
    "        self._views = 0\n",
    "        self._artists = self._reformat_artists(artists)\n",
    "\n",
    "    def _reformat_artists(self, artists):\n",
    "        if isinstance(artists, str):\n",
    "            return self._listify_artists_from_string(artists)\n",
    "        elif artists is None:\n",
    "            return []\n",
    "        return artists\n",
    "\n",
    "    def _listify_artists_from_string(self, artists):\n",
    "        \"\"\"Create list of artists from string.\"\"\"\n",
    "        for possible_split_token in (', ', ','):\n",
    "            if possible_split_token in artists:\n",
    "                return artists.split(possible_split_token)\n",
    "        return [artists]\n",
    "\n",
    "    def add_artist(self, artist):\n",
    "        \"\"\"Add an artist to the song's artists list.\"\"\"\n",
    "        self._artists.append(artist)\n",
    "\n",
    "    def remove_artist(self, artist):\n",
    "        \"\"\"Remove an artist from the song's artists list.\"\"\"\n",
    "        if len(self._artists) <= 1 or artist not in self._artists:\n",
    "            return False\n",
    "        self._artists.remove(artist)\n",
    "\n",
    "    def get_artists(self):\n",
    "        \"\"\"Return the song's artists list.\"\"\"\n",
    "        return self._artists\n",
    "    \n",
    "    def count_words(self):\n",
    "        \"\"\"Return the word count in the song's lyrics.\"\"\"\n",
    "        return len(self.lyrics.split())\n",
    "\n",
    "    def __str__(self):\n",
    "        self._views = self._views + 1\n",
    "        artists = ', '.join(self.get_artists())\n",
    "        title = f'\"{self.name}\" / {artists}'\n",
    "        separator = \"-\" * len(title)\n",
    "        return (\n",
    "            f\"{title}\\n\"\n",
    "            + f\"{separator}\\n\"\n",
    "            + f\"{self.lyrics}\\n\"\n",
    "            + f\"{separator}\\n\"\n",
    "            + f\"Seen: {self._views} time(s).\"\n",
    "        )\n",
    "\n",
    "\n",
    "lyrics = \"\"\"\n",
    "Her Majesty's a pretty nice girl\n",
    "But she doesn't have a lot to say\n",
    "Her Majesty's a pretty nice girl\n",
    "But she changes from day to day\n",
    "\n",
    "I want to tell her that I love her a lot\n",
    "But I gotta get a bellyful of wine\n",
    "Her Majesty's a pretty nice girl\n",
    "Someday I'm going to make her mine, oh yeah\n",
    "Someday I'm going to make her mine\n",
    "\"\"\".strip()\n",
    "her_majestys = Song(\"Her Majesty's\", lyrics, \"The Beatles\")\n",
    "print(her_majestys)\n",
    "print(her_majestys.count_words())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    פעולת ה־<code dir=\"ltr\">__init__</code> של המחלקה <code>Song</code> מגדירה את השם ואת הליריקה של השיר.<br>\n",
    "    היא גם מאתחלת את מספר הצפיות בשיר ל־0, ויוצרת את רשימת האומנים של השיר.<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כדי להקל על המשתמש במחלקה, אפשרנו להעביר את שמות האומנים כרשימה, כמחרוזת מופרדת בפסיקים, או לא להכניס אומנים כלל.<br>\n",
    "    עיבוד השמות לכדי צורה אחידה, רשימה של מחרוזות, יתבצע בפעולה <code dir=\"ltr\">_reformat_artists</code>, שתחליט כיצד לפעול לפי סוג המשתנה:<br>\n",
    "    אם הועברה לפרמטר האומנים מחרוזת, נשלח אותה ל־<code dir=\"ltr\">_listify_artists_from_string</code> שתיצור מהם רשימה. אם הועבר <code>None</code>, נחזיר רשימה ריקה.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    הפעולה <var>count_words</var> מפצלת את מילות השיר לרשימה, ומחזירה את מספר האיברים ברשימה.<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בקריאה ל־<code>__str__</code> אנחנו מגדילים את ערכה של התכונה <var dir=\"ltr\">_views</var> ב־1. כך נספור את הפעמים שביקשו להדפיס שיר. \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>Song</var>.<br>\n",
    "    למעשה, בבואנו לבנות את מחלקת האקרוסטיכון <var>Acrostic</var> נגלה במהרה שהיא העתק מדויק כמעט של מחלקת <var>Song</var> שכבר כתבנו.<br>\n",
    "    חסרה לנו רק הפעולה <var>get_acrostic</var>, נניח, שתחזיר לנו את האקרוסטיכון שנמצא בשיר.<br>\n",
    "    בהינתן המצב הזה, איך יהיה נכון לכתוב את מחלקת אקרוסטיכון?\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    הפתרון הראשון שקופץ לראש הוא פשוט להוסיף למחלקה <var>Song</var> את הפעולה \"<var>get_acrostic</var>\".<br>\n",
    "    זה, כמובן, לא מתאים כל כך.<br>\n",
    "    ברוב השירים אין אקרוסטיכון, והפעולה הזו לא מתאימה להם ולא שייכת למחלקה הכללית יותר, <var>Song</var>.<br>\n",
    "    הוספת הפעולה למחלקה <var>Song</var> גם תיצור עומס מיותר במחלקה – מה יקרה כשנרצה לתמוך בחמשירים? או בשירים מעגליים?<br>\n",
    "    עד מהרה כל מופע יכלול פעולות רבות שלא קשורות אליו, והשימוש במחלקה יהפוך מסורבל מאוד.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    הפתרון השני, אם כך, הוא להעתיק את הקוד של מחלקת <var>Song</var> וליצור מחלקה כמעט זהה בשם <var>Acrostic</var>.<br>\n",
    "    במחלקה יהיו בדיוק כל התכונות והפעולות שנמצאות תחת <var>Song</var>, וכן את הפעולה \"<var>get_acrostic</var>\".<br>\n",
    "    במקרה הזה מדובר בשכפול קוד – כך שנראה שאף פתרון זה אינו מושלם.<br>\n",
    "    בכל פעם שנרצה לשנות משהו במחלקה <var>Song</var> נצטרך לשנות את שתי המחלקות,<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": [
    "## <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",
    "    נגדיר מחלקת <var>Acrostic</var> ריקה, שיורשת ממחלקת <var>Song</var>.<br>\n",
    "    כשאנחנו אומרים דבר כזה, אנחנו מתכוונים שהמחלקה הריקה <var>Acrostic</var> תקבל את כל התכונות והפעולות שנמצאות בתוך מחלקת <var>Song</var>.\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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Acrostic(Song):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    וכמו קסם, בעזרת שורה אחת פשוטה שכפלנו את התכונות והפעולות של מחלקת <var>Song</var>.<br>\n",
    "    ניצור מופע חדש של אקרוסטיכון בדיוק באותה הצורה שבה יצרנו מופע של שיר, רק שהפעם נשתמש במחלקת <var>Acrostic</var> במקום במחלקת <var>Song</var>.<br>\n",
    "    זה אפשרי כיוון ש־<var>Acrostic</var> ירשה את פעולת <code>__init__</code> של <var>Song</var>. \n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lyrics = \"\"\"A boat, beneath a sunny sky\n",
    "Lingering onward dreamily\n",
    "In an evening of July -\n",
    "Children three that nestle near,\n",
    "Eager eye and willing ear,\n",
    "\n",
    "Pleased a simple tale to hear -\n",
    "Long has paled that sunny sky:\n",
    "Echoes fade and memories die:\n",
    "Autumn frosts have slain July.\n",
    "Still she haunts me, phantomwise,\n",
    "Alice moving under skies\n",
    "Never seen by waking eyes.\n",
    "Children yet, the tale to hear,\n",
    "Eager eye and willing ear,\n",
    "\n",
    "Lovingly shall nestle near.\n",
    "In a Wonderland they lie,\n",
    "Dreaming as the days go by,\n",
    "Dreaming as the summers die:\n",
    "Ever drifting down the stream -\n",
    "Lingering in the golden gleam -\n",
    "Life, what is it but a dream?\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "song = Acrostic(\"A Boat, Beneath a Sunny Sky\", lyrics, \"Lewis Carroll\")\n",
    "print(song)\n",
    "print(song.count_words())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בדוגמה שלמעלה ראינו כיצד יוצרים מופע חדש של שיר בעזרת המחלקה <var>Acrostic</var>.<br>\n",
    "    כשמחלקה יורשת ממחלקה אחרת, אפשר להתייחס למחלקה היורשת כאילו כל התכונות של <dfn>מחלקת־העל</dfn> (<dfn>superclass</dfn>), המחלקה שממנה היא יורשת, הועתקו אליה.<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<figure>\n",
    "    <img src=\"images/inheritance.svg?v=3\" style=\"max-width: 500px; margin-right: auto; margin-left: auto; text-align: center;\" alt=\"בתמונה יש שתי תיבות. השמאלית עם הכותרת Song, ובה התכונות והפעולות השייכות למחלקה. אליה יוצא חץ מהתיבה הימנית, עם הכותרת Acrostic, ובה מופיעות אותן תכונות ופעולות בצבע אפור (כדי להמחיש שהן נלקחות מתוך המחלקה Song).\"/>\n",
    "    <figcaption style=\"margin-top: 2rem; text-align: center; direction: rtl;\">המחלקה <var>Acrostic</var> יורשת מהמחלקה <var>Song</var>.<br>פנייה לפעולה או לתכונה של המחלקה <var>Acrostic</var> הריקה, תפנה את הבקשה למחלקת־העל <var>Song</var> שממנה <var>Acrostic</var> יורשת.</figcaption>\n",
    "</figure>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כיוון ש־<var>Acrostic</var> ירשה את כל הפעולות ממחלקת־העל שלה, <var>Song</var>, ובהן גם את הפעולה <code dir=\"ltr\">__init__</code>,<br>\n",
    "    יצירת מופע חדש באמצעות קריאה ל־<var>Acrostic</var> קוראת למעשה לפעולה <code dir=\"ltr\">Song.__init__</code>.\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": [
    "help(Acrostic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    ירושה מאפשרת לנו להוסיף בקלות פעולות ל־<var>Acrostic</var>, מעבר לאלו שהיא ירשה ממחלקת <var>Song</var>.<br>\n",
    "    כדי לעשות זאת, פשוט נגדיר את הפעולה הרלוונטית במחלקה היורשת.<br>\n",
    "    נממש את הפעולה שלשמה התחלנו את כל העניין, <var>get_acrostic</var>, שתשרשר את האות הראשונה מכל שורה בשיר:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Acrostic(Song):\n",
    "    def get_acrostic(self):\n",
    "        song_lines = self.lyrics.splitlines()\n",
    "        first_chars = (line[0] for line in song_lines if line)\n",
    "        return ''.join(first_chars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    הפעולה <var>get_acrostic</var> אוספת את האות הראשונה מכל שורה, אם קיימת כזו, ומאחדת את כל האותיות שנאספו למחרוזת אחת:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "song = Acrostic(\"A Boat, Beneath a Sunny Sky\", lyrics, \"Lewis Carroll\")\n",
    "song.get_acrostic()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    שימו לב - אומנם הפעולה קיימת במחלקה <var>Acrostic</var>, אך אין זה אומר שהיא קיימת במחלקה <var>Song</var>:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "song = Song(\"A Boat, Beneath a Sunny Sky\", lyrics, \"Lewis Carroll\")\n",
    "song.get_acrostic()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    נוכל לראות שפייתון מבינה שמופע שנוצר מ־<var>Acrostic</var> הוא גם <var>Acrostic</var>, אבל הוא גם <var>Song</var>:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "song = Acrostic(\"A Boat, Beneath a Sunny Sky\", lyrics, \"Lewis Carroll\")\n",
    "print(isinstance(song, Song))\n",
    "print(isinstance(song, Acrostic))"
   ]
  },
  {
   "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": [
    "song = Song(\"A Boat, Beneath a Sunny Sky\", lyrics, \"Lewis Carroll\")\n",
    "print(isinstance(song, Song))\n",
    "print(isinstance(song, Acrostic))"
   ]
  },
  {
   "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": [
    "<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": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "לפי <a href=\"https://he.wikipedia.org/wiki/%D7%A1%D7%A1%D7%98%D7%99%D7%A0%D7%94\">ויקיפדיה</a>, ססטינה הוא שיר בעל מבנה נוקשה שמציית לכללים הבאים:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ul style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <li>בססטינה יש 39 שורות: שישה בתים של שש שורות כל אחד, ולבסוף בית של שלוש שורות.</li>\n",
    "    <li>המילה האחרונה בכל שורה בבית הראשון, מופיעה גם כמילה האחרונה בכל אחת מהשורות מהבתים הבאים אחריה. אם נסמן את שש המילים האחרונות בשש השורות של הבית הראשון באותיות אבגדהו, הרי הסדר שבו יופיעו מילים אלה בבתים הבאים הוא ואהבדג, גודאבה, הגבואד, דהאגוב, בדוהגא.</li>\n",
    "    <li>שש מילים אלה מופיעות גם בבית האחרון, שבו שלוש שורות. בשורה הראשונה יופיעו המילים בה, בשורה השנייה – דג, ובשורה השלישית – או.</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    ממשו את המחלקה <var>Sestina</var>.<br>\n",
    "    המחלקה תכיל את כל התכונות והפעולות של שיר רגיל, נוסף על הפעולה <var>is_valid</var> שתבדוק אם הסטטינה תקינה.<br>\n",
    "    בבדיקתכם, התעלמו מהחוקים הנוגעים לבית האחרון.<br>\n",
    "    הפעולה תחזיר <code><samp>True</samp></code> אם כן ו־<code><samp>False</samp></code> אם לא.<br>\n",
    "    בדקו את הפעולה שלכם על \"<a href=\"https://www.firstpost.com/blogs/neil-gaimans-ode-to-vampires-27212.html\">ססטינת ערפד</a>\" של ניל גיימן.\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>Instrumental</var>.<br>\n",
    "    <dfn>קטע כלי</dfn> (או שיר אינסטרומנטלי) הוא קטע מוזיקלי ללא שירה.<br> \n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Instrumental(Song):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    ניצור מתוך המחלקה מופע עבור הקטע של Yiruma, יצירתו המהממת River Flows in You:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "song = Instrumental(\"River Flows in You\", \"\", \"Yiruma\")\n",
    "print(song)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בשלב הזה נגלה שפעולת ה־<code dir=\"ltr\">__str__</code> עושה פחות חסד עם קטעים כליים.<br>\n",
    "    תעלול נחמד בירושה הוא היכולת לדרוס את הפעולה של מחלקת־העל בתת־מחלקה שיורשת ממנה.<br>\n",
    "    בדריסה, אנחנו \"מבטלים\" את הפעולה של מחלקת־העל (היא לא תרוץ), ומחליפים אותה בפעולה חדשה שניצור עבור תת־המחלקה.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    נדרוס את הפעולה <code dir=\"ltr\">__str__</code> ונממש צורת תצוגה שמתאימה יותר לקטעים כליים:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Instrumental(Song):\n",
    "    def __str__(self):\n",
    "        self._views = self._views + 1\n",
    "        artists = ', '.join(self.get_artists())\n",
    "        title = f'\"{self.name}\" / {artists}'\n",
    "        separator = \"-\" * len(title)\n",
    "        return f\"{title}\\n{separator}\\nSeen: {self._views} time(s).\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "song = Instrumental(\"River Flows in You\", \"\", \"Yiruma\")\n",
    "print(song)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בתא שלמעלה הגדרנו מחדש את הפעולה <code dir=\"ltr\">__str__</code> שבמחלקה <var>Instrumental</var>.<br>\n",
    "    ויתרנו על הצגת מילות השיר (כי אין כאלו) ועל הקווים המפרידים הסמוכים להם.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כמה נחמד!<br>\n",
    "    עכשיו כשנדפיס את המופע, מי שתיקרא כדי להמיר את המופע למחרוזת היא הפעולה <code dir=\"ltr\">Instrumental.__str__</code> ולא <code dir=\"ltr\">Song.__str__</code>.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    איך פייתון מחליטה לאיזו פעולה לקרוא?<br>\n",
    "    השיטה היא תמיד לחפש תחילה במחלקה שממנה נוצר המופע.<br>\n",
    "    אם לא מצאנו את הפעולה שם, נעבור לחפש אותה במחלקת־העל.<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    סדר המחלקות שבו נחפש את הפעולה קיבל את השם \"סדר בחירת פעולות\" (Method Resolution Order; או <abbr title=\"Method Resolution Order\">MRO</abbr>).<br>\n",
    "    אפשר לראות את סדר בחירת הפעולות של <var>song</var> אם נקרא ל־<code dir=\"ltr\">Instrumental.mro()</code>:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Instrumental.mro()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    זה אומר שכשאנחנו יוצרים מופע מהמחלקה <var>Instrumental</var>, פייתון תחפש פעולות ותכונות קודם כול אצלה, ורק אז במחלקה <var>Song</var>, הרי היא מחלקת־העל.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    נשים לב שבראש השרשרת עומדת המחלקה <var>object</var>.<br>\n",
    "    כשאנחנו מגדירים מחלקה \"רגילה\", ללא ירושה, פייתון אוטומטית מניחה שהיא יורשת ממחלקת <var>object</var>.<br>\n",
    "    מחלקה זו מגדירה התנהגויות בסיסיות עבור המחלקה שיצרנו.<br>\n",
    "    לדוגמה: הפעולה <code dir=\"ltr\">__init__</code> שמוגדרת ב־<var>object</var> מאפשרת לנו לאתחל מופעים חדשים מבלי שנגדיר <code dir=\"ltr\">__init__</code> במחלקה שלנו:<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Example:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e = Example()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    הפעולה <code dir=\"ltr\">__str__</code> שמוגדרת ב־<var>object</var> מאפשרת לנו לראות את הייצוג המכוער של אובייקט כשאנחנו מדפיסים אותו,<br>\n",
    "    גם בלי לממש את <code dir=\"ltr\">__str__</code> במחלקה שלנו:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"text-align: right; direction: rtl; float: right; clear: both;\">super</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    מקום נוסף לשיפור במחלקה <var>Instrumental</var> הוא פעולת ה־<code dir=\"ltr\">__init__</code>.<br>\n",
    "    כיוון שלקטעים כליים אין מילים, הפרמטר השני שאנחנו מעבירים לפעולת האתחול (<var>lyrics</var>) הוא מיותר לחלוטין.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "song = Instrumental(\"Kiss the rain\", \"\", \"Yiruma\")\n",
    "print(song)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    היה עדיף לו <code>__init__</code> של המחלקה <var>Instrumental</var> היה קצת שונה מה־<code>__init__</code> של המחלקה <var>Song</var>.<br>\n",
    "    מה עושים? את הפעולה שהורשה דורסים!<br>\n",
    "    נגדיר <code dir=\"ltr\">__init__</code> חדש ללא הפרמטר <var>lyrics</var>:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Instrumental(Song):\n",
    "    def __init__(self, name, artists=None):\n",
    "        self.name = name\n",
    "        self.lyrics = \"\"\n",
    "        self._views = 0\n",
    "        self._artists = self._reformat_artists(artists)\n",
    "\n",
    "    def __str__(self):\n",
    "        self._views = self._views + 1\n",
    "        artists = ', '.join(self.get_artists())\n",
    "        title = f'\"{self.name}\" / {artists}'\n",
    "        separator = \"-\" * len(title)\n",
    "        return f\"{title}\\n{separator}\\nSeen: {self._views} time(s).\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בקוד שלמעלה <dfn>דרסנו</dfn> את הפעולה <code dir=\"ltr\">__init__</code>.<br>\n",
    "    חדי העין מביניכם זיהו שהיא כמעט זהה לפעולת ה־<code dir=\"ltr\">__init__</code> של <var>Song</var>.<br>\n",
    "    ההבדלים הם שלא מוגדר בה הפרמטר <var>lyrics</var>, ושתכונת המופע <var>lyrics</var> מוגדרת תמיד למחרוזת ריקה. \n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    מצד אחד – השגנו את מה שרצינו. מצד שני – מטרת העל של ירושה הייתה מלכתחילה למנוע שכפול קוד.<br>\n",
    "    נצמצם את כפילות הקוד בין <code dir=\"ltr\">Instrumental.__init__</code> לבין <code dir=\"ltr\">Song.__init__</code> –<br>\n",
    "    במקום להעתיק את השורות שכתובות ב־<code dir=\"ltr\">Song.__init__</code>, נקרא לפעולת האתחול הזו מתוך <code dir=\"ltr\">Instrumental.__init__</code>:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Instrumental(Song):\n",
    "    def __init__(self, name, artists=None):\n",
    "        Song.__init__(self, name=name, lyrics=\"\", artists=artists)\n",
    "\n",
    "    def __str__(self):\n",
    "        self._views = self._views + 1\n",
    "        artists = ', '.join(self.get_artists())\n",
    "        title = f'\"{self.name}\" / {artists}'\n",
    "        separator = \"-\" * len(title)\n",
    "        return f\"{title}\\n{separator}\\nSeen: {self._views} time(s).\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    מה יקרה כעת בעת יצירת מופע חדש של <var>Instrumental</var>?<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ol style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <li>הפעולה <code dir=\"ltr\">Instrumental.__init__</code> תרוץ.</li>\n",
    "    <li>בשורה הראשונה של הפעולה, תיקרא הפעולה <code dir=\"ltr\">Song.__init__</code> כאשר מועבר לה הפרמטר <var>self</var> באופן מפורש.</li>\n",
    "    <li>כשהפעולה <code dir=\"ltr\">Song.__init__</code> תרוץ, השורה <code dir=\"ltr\">self.name = name</code> שנמצאת בתוך הפעולה תתייחס למופע שיצרנו ממחלקת <var>Instrumental</var>.<br>הפעולה מתנהגת כך כיוון שהעברנו לפרמטר <code>self</code> של הפעולה <code dir=\"ltr\">Song.__init__</code> את המופע שיצרנו במחלקת <var>Instrumental</var>.</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    עשינו פה טריק מוזר ואולי קצת מלוכלך.<br>\n",
    "    פנינו ישירות לפעולת הקסם <code dir=\"ltr\">Song.__init__</code>, ו\"השתלנו\" בה את ה־<var>self</var> שמייצג את המופע הנוכחי.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    למה עשינו זאת?<br>\n",
    "    אם נקרא ל־<code dir=\"ltr\">Song()</code>, ייווצר אוטומטית מופע חדש של שיר \"רגיל\", והוא יהיה זה שייכנס לפרמטר <var>self</var> של <code dir=\"ltr\">Song.__init__</code>.<br>\n",
    "    לעומת זאת, אם נקרא ישירות ל־<code dir=\"ltr\">Song.__init__()</code>, נוכל להעביר את הפרמטר <var>self</var> באופן מפורש, בעצמנו.<br>\n",
    "    הטריק הזה מאפשר לנו להעביר לתוך הפרמטר <var>self</var> של <code dir=\"ltr\">Song.__init__</code> מופע שיצרנו בעזרת מחלקת <var>Instrumental</var>,<br>\n",
    "    או במילים אחרות – הטריק הזה מאפשר לנו להפעיל את פעולת האתחול של <var>Song</var> עבור המופע שנוצר מ־<var>Instrumental</var>.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    למה זה שימושי?<br>\n",
    "    כיוון שאז אנחנו מנצלים את פעולת האתחול של <var>Song</var> שנראית כך:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def __init__(self, name, lyrics, artists=None):\n",
    "    self.name = name\n",
    "    self.lyrics = lyrics\n",
    "    self._views = 0\n",
    "    self._artists = self._reformat_artists(artists)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    באמצעות שורת הקוד שהוספנו ל־<var>Instrumental</var> שקוראת לפעולה הזאת, פעולת האתחול של <var>Song</var>,<br>\n",
    "    אנחנו חוסכים את שכפול הקוד בתת־המחלקה וגורמים לכך שהפעולה של מחלקת־העל תפעל ותגדיר עבורנו את תכונות המחלקה.<br>\n",
    "    זו דרך נוחה להגיד לפייתון \"אמנם דרסנו את הפעולה של מחלקת־העל, אבל עדיין נרצה לבצע <em>גם</em> את מה שמחלקת־העל עושה\".<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    זה עובד כיוון שהעברנו את <var>self</var>, המופע שלנו, לפעולה <code dir=\"ltr\">Song.__init__</code>,<br>\n",
    "    מה שיגרור את הגדרתן של <code>self.name</code>, <code>self.lyrics</code>, <code>self._views</code> ו־<code>self._artists</code> עבור המופע שנוצר מ־<var>Instrumental</var>.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    קריאה לפעולה שדרסנו במחלקת־העל היא טריק נפוץ ושימושי מאוד.<br>\n",
    "    למעשה, נהוג להשתמש בו הרבה גם על פעולות שהן לא <code dir=\"ltr\">__init__</code>.<br>\n",
    "    נוכל להחיל את אותו הטריק גם על <code dir=\"ltr\">__str__</code>, לדוגמה, ולחסוך את ההעלאה של <code dir=\"ltr\">self._views</code> ב־1:\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",
    "            ממשו בעצמכם את אותו תעלול עבור <code dir=\"ltr\">__str__</code>.<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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Instrumental(Song):\n",
    "    def __init__(self, name, artists=None):\n",
    "        Song.__init__(self, name=name, lyrics=\"\", artists=artists)\n",
    "\n",
    "    def __str__(self):\n",
    "        Song.__str__(self)\n",
    "        artists = ', '.join(self.get_artists())\n",
    "        title = f'\"{self.name}\" / {artists}'\n",
    "        separator = \"-\" * len(title)\n",
    "        return f\"{title}\\n{separator}\\nSeen: {self._views} time(s).\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בתא שלמעלה אנחנו רואים איך משתמשים בפעולה של מחלקת־העל,<br>\n",
    "    אבל עדיין מגדירים <em>גם</em> התנהגות עצמאית משל עצמנו.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כיוון שהטריק הזה נפוץ יחסית, פייתון נותנת בידינו דרך נוחה להתייחס למחלקת־העל, כשהפרמטר הראשון שנעביר לפעולה שבה הוא <var>self</var>.<br>\n",
    "    במקום לכתוב בכל פעם את הביטוי המתיש <code dir=\"ltr\">Song.__init__(self)</code>, נוכל לכתוב <code dir=\"ltr\">super().__init__()</code>.<br>\n",
    "    הפונקציה <var>super</var> מאפשרת לנו להעביר את המופע שיצרנו בתת־המחלקה, לתוך פעולה הנמצאת במחלקת־העל.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Instrumental(Song):\n",
    "    def __init__(self, name, artists=None):\n",
    "        super().__init__(name=name, lyrics=\"\", artists=artists)\n",
    "\n",
    "    def __str__(self):\n",
    "        super().__str__()\n",
    "        artists = ', '.join(self.get_artists())\n",
    "        title = f'\"{self.name}\" / {artists}'\n",
    "        separator = \"-\" * len(title)\n",
    "        return f\"{title}\\n{separator}\\nSeen: {self._views} time(s).\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "song = Instrumental(\"River Flows in You\", \"Yiruma\")\n",
    "print(song)\n",
    "print(song)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    חשוב להבין היטב את הרעיון של קריאה לפעולה במחלקת־העל מתוך הפעולה הדורסת בתת־מחלקה.<br>\n",
    "    הטכניקה הזו מאפשרת לנו למנוע שכפול קוד, ואם בעתיד תשתנה מעט הפעולה במחלקת־העל, תת־המחלקה \"תזכה\" אוטומטית בשינויים האלו.<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",
    "    כידוע לכם בכפר הדרדסים יש הרבה דרדסים \"רגילים\", אבל יש גם כמה דרדסים מפורסמים, כמו דרדסבא, דרדסית ודרדשף.<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    לכל דרדס (<var>Smurf</var>) יש את התכונה <var>name</var> שמכילה את שמו, ואת הפעולות <var>eat</var> ו־<var>sleep</var>.<br>\n",
    "    לדרדס המיוחד \"דרדסאבא\" (<var>PapaSmurf</var>) יש גם את הפעולה <var>give_order</var>, שמקבלת פעולה של דרדס רגיל ומפעילה אותו עליו.<br>\n",
    "    ל\"דרדסית\" (<var>Smurfette</var>) יש את הפעולה <var>kill_gargamel</var>, שמקבלת כפרמטר מופע שנוצר ממחלקת <var>Gargamel</var> ומשנה את התכונה <var>is_alive</var> שבו ל־<code>False</code>.<br>\n",
    "    ל\"דרדשף\" (<var>ChefSmurf</var>) יש את הפעולה <var>create_food</var>, שמקבלת את שם המנה שהוא מכין וכמה \"חתיכות\" (<var>slices</var>) הוא יצר ממנה. \n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    דרדסים ישנים 8 שעות בדיוק. דרדס שישן לא יכול לבצע פעולות אחרות אלא אם הוא דרדסבא, שהוא חזק ומהיר והוא דרדס והוא גם חזק.<br>\n",
    "    דרדס יכול לאכול מזון רק אם <var>ChefSmurf</var> הכין אותו באמצעות הפעולה <var>create_food</var>, ורק אם נשארו עוד \"חתיכות\" מאותה מנה.<br>\n",
    "    הפעולה <var>eat</var> של כל דרדס תקבל רשימה של מנות ותאכל מכולן. הרשימה יכולה להכיל כל מספר איברים שהוא.\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",
    "    בשנות ה־90 העליזות החלה להישמע ביקורת הולכת וגוברת על רעיון הירושה.<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "הביקורת העיקרית היא על כך שירושה יוצרת תלות בין מחלקת־העל לתתי־המחלקות שיורשות ממנה.<br>\n",
    "כאשר מחלקה יורשת ממחלקה אחרת, כל הפעולות והתכונות של מחלקת־העל נחשפות לתת־המחלקה.<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",
    "    נדון בבעיה זו בהרחבה בהמשך הפרק.\n",
    "</p>"
   ]
  },
  {
   "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": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בספר האלמותי של כנופיית הארבעה, \"תבניות עיצוב\" (Design Patterns), הכותבים מותחים ביקורת נוקבת על הבעיות שירושה עלולה להכניס לקוד.<br>\n",
    "    הם מציעים לבחור <a href=\"https://en.wikipedia.org/wiki/Composition_over_inheritance\">בהכלה במקום בירושה</a> כשהדבר אפשרי.\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",
    "    התסמונת מתארת בעיה נפוצה בירושה:<br>\n",
    "    שינויים במחלקת־העל עלולים לגרור תוצאות בלתי צפויות בתתי־המחלקות שיורשות ממנה, אפילו אם מחלקת העל עובדת באופן מושלם.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כדי לקבל מושג איך נראית התסמונת בעולם האמיתי, נראה דוגמה למימוש של אתר הקניות \"מוצרי לכון ובניו\".<br>\n",
    "    נגדיר מחלקה פשוטה בשם <var>Clickable</var> שמתארת עצם לחיץ. המחלקה תאפשר לנו לספור כמה פעמים לחצו על מופע מסוים:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Clickable:\n",
    "    def __init__(self):\n",
    "        self.clicks = 0\n",
    "\n",
    "    def click(self):\n",
    "        self.clicks = self.clicks + 1\n",
    "\n",
    "    def double_click(self):\n",
    "        self.clicks = self.clicks + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    באתר הקניות המדובר ישנו מופע של כפתור שנוצר מהמחלקה <var>CrazyButton</var>.<br>\n",
    "    המחלקה <var>CrazyButton</var> יורשת מהמחלקה <var>Clickable</var>.<br>\n",
    "    המיוחד במחלקת <var>CrazyButton</var> הוא שכל לחיצה נחשבת כלחיצה כפולה:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CrazyButton(Clickable):\n",
    "    def click(self):\n",
    "        self.double_click()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "buy_now = CrazyButton()\n",
    "buy_now.double_click()\n",
    "buy_now.clicks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    יום אחד, הסתכל אחיתופל המתכנת על הקוד. \"רגע! יש פה קוד כפול!\" הוא נזעק,<br>\n",
    "    \"הפעולה <var>double_click</var> במחלקה <var>Clickcable</var> עושה כמעט את מה שעושה הפעולה <var>click</var>\".<br>\n",
    "    אחיתופל ניגש בחופזה לתקן את הקוד, ולהשתמש ב־<var>click</var> פעמיים במקום בערך המפורש 2:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Clickable:\n",
    "    def __init__(self):\n",
    "        self.clicks = 0\n",
    "\n",
    "    def click(self):\n",
    "        self.clicks = self.clicks + 1\n",
    "\n",
    "    def double_click(self):\n",
    "        self.click()\n",
    "        self.click()\n",
    "\n",
    "\n",
    "class CrazyButton(Clickable):\n",
    "    def click(self):\n",
    "        self.double_click()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    ואכן, המחלקה <var>Clickable</var> עודנה עובדת מצוין: \n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "buy_now = Clickable()\n",
    "buy_now.click()\n",
    "buy_now.double_click()\n",
    "print(buy_now.clicks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    אך מה יקרה אם נרצה להשתמש ב־<var>CrazyButton</var>?\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "buy_now = CrazyButton()\n",
    "buy_now.click()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    אחיתופל אומנם תיקן את הקוד של המחלקה <var>Clickable</var>, שנראית עכשיו תקינה לחלוטין.<br>\n",
    "    הבעיה היא שבתת־המחלקה <var>CrazyButton</var> הפעולה <var>click</var> מסתמכת על המימוש של הפעולה <var>double_click</var> שבמחלקת־העל שלה.<br>\n",
    "    כך נוצרת שרשרת קריאות אין־סופית: בעת קריאה ל־<var>click</var> ב־<var>CrazyButton</var>, נקראת הפעולה <var>double_click</var>, שקוראת בחזרה לפעולה <var>click</var>, וחוזר חלילה.\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",
    "    בספר Code Complete מוצג כלל אצבע שזכה לאהדה בקרב מתכנתים רבים:<br>\n",
    "    כשמתארים קשר בין שתי מחלקות בעזרת המילים \"סוג של\" (is a), הקשר התכנותי ביניהן יהיה לרוב ירושה.<br>\n",
    "    כשמתארים קשר בין שתי מחלקות בעזרת המילה \"יש...\" (has a), הקשר התכנותי ביניהן יהיה לרוב הכלה.<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    אם אנחנו יכולים להגיד \"א הוא סוג של ב\", כאשר מדובר בשמות של מחלקות, ייתכן שנכון להשתמש בירושה.<br>\n",
    "    לדוגמה: כלב הוא סוג של חיה, ולכן ייתכן שמחלקת <var>Dog</var> תירש ממחלקת <var>Animal</var>.<br>\n",
    "    מכונית היא סוג של רכב, ולכן הגיוני שמחלקת <var>Car</var> תירש ממחלקת <var>Vehicle</var>.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    אם אנחנו יכולים להגיד \"אצל א יש ב\", כאשר מדובר בשמות של מחלקות, ייתכן שנכון להשתמש בהכלה.<br>\n",
    "    לדוגמה: למכונית יש מנוע, ולכן הגיוני שבמחלקה <var>Car</var> תופיע התכונה <var>engine</var>, שהיא מופע שנוצר מהמחלקה <var>Engine</var>.<br>\n",
    "    זה עובד על תכונות באופן כללי, ולא רק על קשר של הכלה. לכפתור באתר יש כמה לחיצות, ולכן הגיוני ש־<var>clicks</var> תהיה תכונה של המחלקה <var>Button</var>.\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",
    "    תרומתה הנודעת ביותר נקראת \"עקרון ההחלפה של ליסקוב\" שנוסח פורמלית בשנת 1987.<br>\n",
    "    בפשטות, העיקרון גורס כך:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<blockquote dir=\"rtl\" style=\"direction: rtl; text-align: right; float: right; border-right: 5px solid rgba(0,0,0,.05); border-left: 0;\">\n",
    "    <p>כל מופע שנוצר ממחלקת־על מסוימת, חייב להמשיך לעבוד כרגיל גם אם ביום בהיר אחד יחליטו ליצור אותו מתת־מחלקה שיורשת מאותה מחלקת־על.</p>\n",
    "</blockquote>\n"
   ]
  },
  {
   "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",
    "    דוגמה פופולרית שנותן רוברט מרטין (הידוע בשם העט Uncle Bob) היא שכל ריבוע הוא גם מלבן.<br>\n",
    "    חלקנו נמהר להשתמש בהורשה כדי לייצג את הרעיון הזה:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "    \n",
    "    def get_area(self):\n",
    "        return self.width * self.height\n",
    "\n",
    "    def __str__(self):\n",
    "        dimensions = f\"{self.width}x{self.height}\"\n",
    "        return f\"Size of {dimensions} is {self.get_area()}\"\n",
    "\n",
    "\n",
    "class Square(Rectangle):\n",
    "    def __init__(self, side_size):\n",
    "        super().__init__(side_size, side_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בקוד שלמעלה מימשנו מחלקת מלבן <var>Rectangle</var>, שבה התכונות \"גובה\" (<var>height</var>) ו\"רוחב\" (<var>width</var>), ואת הפעולה \"חישוב שטח\" (<var>get_area</var>).<br>\n",
    "    בקוד ישנה מחלקה נוספת בשם ריבוע (<var>Square</var>) שפעולת האתחול שלה מקבלת רק אורך של צלע אחת, שכן כל צלעותיו של ריבוע זהות.<br>\n",
    "    מחלקת הריבוע יורשת ממחלקת המלבן שבנינו.<br>\n",
    "    הרעיון יעבוד נהדר:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Rectangle(5, 6))\n",
    "print(Square(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    אבל שימו לב שאנחנו מפרים את עקרון ההחלפה של ליסקוב.<br>\n",
    "    על פי העיקרון, כל שימוש במחלקה יוכל להיות מוחלף בתת־מחלקה שיורשת ממנה.<br>\n",
    "    לפי אותו עיקרון, אנחנו אמורים להיות מסוגלים להחליף את הקריאה למחלקת מלבן בקריאה למחלקת ריבוע.<br>\n",
    "    משמע, עבור:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Rectangle(5, 6))"
   ]
  },
  {
   "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(Square(5, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_square = Square(3)\n",
    "my_square.width = 5\n",
    "print(my_square)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    לאחר עריכת רוחב הריבוע ציפינו ששטח הריבוע יהיה 25, אך ארכיטקטורת הקוד שלנו כשלה בטיפול במקרה הזה.<br>\n",
    "    הקוד שלנו שינה רק את הרוחב של הריבוע ולא את אורכו, בזמן שבריבוע דבר כזה לא אמור להתאפשר.<br>\n",
    "    בשורה התחתונה – הקוד שלנו נשבר כיוון שלא עקבנו אחרי עקרון ההחלפה.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    נוכל לתקן את הבאג בקלות יחסית אם נהפוך את <var>width</var> ואת <var>height</var> למשתנים פרטיים ב־<var>Rectangle</var>,<br>\n",
    "        אבל כדאי לשים לב שבדרך כלל אם אנחנו פונים לתקן את מחלקת־העל כדי שדברים יעבדו – סימן שמשהו בעייתי בבסיס הארכיטקטורה שלנו.<br>\n",
    "    ננסה בכל זאת:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self._width = width\n",
    "        self._height = height\n",
    "\n",
    "    def set_width(self, width):\n",
    "        self._width = width\n",
    "\n",
    "    def set_height(self, height):\n",
    "        self._height = height\n",
    "\n",
    "    def get_width(self):\n",
    "        return self._width\n",
    "\n",
    "    def get_height(self):\n",
    "        return self._height\n",
    "\n",
    "    def get_area(self):\n",
    "        return self.get_width() * self.get_height()\n",
    "\n",
    "    def __str__(self):\n",
    "        dimensions = f\"{self.get_width()}x{self.get_height()}\"\n",
    "        return f\"Size of {dimensions} is {self.get_area()}\"\n",
    "\n",
    "\n",
    "class Square(Rectangle):\n",
    "    def __init__(self, side_size):\n",
    "        super().__init__(side_size, side_size)\n",
    "\n",
    "    def set_width(self, width):\n",
    "        super().set_width(width)\n",
    "        super().set_height(width)\n",
    "\n",
    "    def set_height(self, height):\n",
    "        super().set_width(height)\n",
    "        super().set_height(height)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\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": [
    "def set_and_print(my_shape):\n",
    "    my_shape.set_height(2)\n",
    "    my_shape.set_width(3)\n",
    "    print(my_shape)\n",
    "\n",
    "\n",
    "set_and_print(Rectangle(4, 5))\n",
    "set_and_print(Square(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    המטרה הברורה של הפונקציה הייתה למצוא את השטח של הצורה לאחר שערכנו את גודלו ל־3 על 2.<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 Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "    \n",
    "    def get_area(self):\n",
    "        return self.width * self.height\n",
    "\n",
    "    def __str__(self):\n",
    "        dimensions = f\"{self.width}x{self.height}\"\n",
    "        return f\"Size of {dimensions} rectangle is {self.get_area()}\"\n",
    "\n",
    "\n",
    "class Square:\n",
    "    def __init__(self, side):\n",
    "        self.side = side\n",
    "    \n",
    "    def get_area(self):\n",
    "        return self.side ** 2\n",
    "\n",
    "    def __str__(self):\n",
    "        dimensions = f\"{self.side}x{self.side}\"\n",
    "        return f\"Size of {dimensions} square is {self.get_area()}\""
   ]
  },
  {
   "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": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    נממש תוכנה לקבלת דואר אלקטרוני, שיודעת לתמוך בקבלה ובשליחה של דואר מ־Gmail ומ־Walla – ספקי דואר אלקטרוני פופולריים.<br>\n",
    "    נתחיל במימוש מחלקה כללית עבור התוכנה שלנו.<br>\n",
    "    ההדפסות בפעולות הן לצורך ההמחשה. בדרך כלל נמליץ שלא לכלול הדפסות בתוך פעולות מחלקה או בתוך פונקציות.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EmailClient:\n",
    "    def __init__(self, username, password):\n",
    "        print(\"Setting up a new mail client...\")\n",
    "        self._inbox = []\n",
    "        self.username = username\n",
    "        self.password = password"
   ]
  },
  {
   "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 Walla(EmailClient):\n",
    "    DOMAIN = 'walla.co.il'\n",
    "\n",
    "    def read(self):\n",
    "        mail_address = f\"{self.username}@{self.DOMAIN}\"\n",
    "        print(f\"Reading mail of {mail_address} in Walla: [...]\")\n",
    "\n",
    "\n",
    "class Gmail(EmailClient):\n",
    "    DOMAIN = 'gmail.com'\n",
    "\n",
    "    def read(self):\n",
    "        mail_address = f\"{self.username}@{self.DOMAIN}\"\n",
    "        print(f\"Reading mail of {mail_address} in Gmail: [...]\")"
   ]
  },
  {
   "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": [
    "mail = Walla(username='Yam', password='correcthorsebatterystaple')\n",
    "mail.read()"
   ]
  },
  {
   "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": [
    "mail = Gmail(username='Yam', password='correcthorsebatterystaple')\n",
    "mail.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    מה יקרה אם נשתמש בהכלה במקום בירושה?<br>\n",
    "    נתחיל בהתאמת המחלקה <var>EmailClient</var>:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EmailClient:\n",
    "    def __init__(self, username, password, provider):\n",
    "        print(\"Setting up a new mail client...\")\n",
    "        self._inbox = []\n",
    "        self.username = username\n",
    "        self.password = password\n",
    "        self.provider = provider\n",
    "    \n",
    "    def read(self):\n",
    "        self.provider.read(self.username)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בקוד שלמעלה הוספנו את התכונה <var>provider</var> ל־<var>EmailClient</var>.<br>\n",
    "    תכונה זו תכיל מופע של ספק הדוא\"ל.<br>\n",
    "    המחלקות של שירותי הדוא\"ל יישארו כפי שהן, אך לא יירשו מ־<var>EmailClient</var>:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Walla:\n",
    "    DOMAIN = 'walla.co.il'\n",
    "\n",
    "    def read(self, username):\n",
    "        mail_address = f\"{username}@{self.DOMAIN}\"\n",
    "        print(f\"Reading mail of {mail_address} in Walla: [...]\")\n",
    "\n",
    "\n",
    "class Gmail:\n",
    "    DOMAIN = 'gmail.com'\n",
    "\n",
    "    def read(self, username):\n",
    "        mail_address = f\"{username}@{self.DOMAIN}\"\n",
    "        print(f\"Reading mail of {mail_address} in Gmail: [...]\")"
   ]
  },
  {
   "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": [
    "mail = EmailClient(\n",
    "    username='Yam',\n",
    "    password='correcthorsebatterystaple',\n",
    "    provider=Walla(),\n",
    ")\n",
    "\n",
    "mail.read()"
   ]
  },
  {
   "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": [
    "mail.provider = Gmail()\n",
    "mail.read()"
   ]
  },
  {
   "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": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    למדנו מהי ירושה ואיך משתמשים בה בפייתון,<br>\n",
    "    ראינו איך דורסים פעולות ותכונות בתת־המחלקה, ואיך משתמשים ב־<var>super</var> כדי להתייחס למחלקת־העל.<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",
    "    במחברת הבאה נסקור טכניקות פופולריות שנולדו בזכות רעיון הירושה, ונלמד כיצד משתמשים בהן.\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>ירושה (Inheritance)</dt>\n",
    "    <dd>\n",
    "        מנגנון של שפת התכנות שמאפשר ביסוס של מחלקה א על תכונותיה ופעולותיה של מחלקה ב.\n",
    "    </dd>\n",
    "    <dt>מחלקת־על (Superclass)</dt>\n",
    "    <dd>\n",
    "        המחלקה שממנה מתבצעת הירושה. זו המחלקה שממנה ייגזרו הפעולות והתכונות, ו\"יועתקו\" למחלקה היורשת.<br>\n",
    "        נקראת גם <dfn>מחלקת בסיס</dfn> (<dfn>base class</dfn>), <dfn>מחלקת האם</dfn> או <dfn>מחלקת האב</dfn> (<dfn>parent class</dfn>).\n",
    "    </dd>\n",
    "    <dt>תת־מחלקה (Subclass)</dt>\n",
    "    <dd>\n",
    "        המחלקה שמעתיקה את תכונותיה של מחלקה אחרת. זו המחלקה שאליה ייגזרו הפעולות והתכונות של המחלקה שממנה מתבצעת הירושה.<br>\n",
    "        נקראת גם <dfn>המחלקה הנגזרת</dfn> (<dfn>derived class</dfn>) או <dfn>מחלקת הבת</dfn> (<dfn>child class</dfn>).\n",
    "    </dd>\n",
    "    <dt>דריסה (Override)</dt>\n",
    "    <dd>\n",
    "        החלפת תכונה או פעולה של מחלקת־העל בתת־מחלקה על ידי הגדרתה מחדש בתת־המחלקה.\n",
    "    </dd>\n",
    "    <dt>מחלקת־העל השברירית (Fragile base class)</dt>\n",
    "    <dd>\n",
    "        תסמונת המתארת כיצד שינוי במחלקת־העל באופן שמסתמן כתקין עבור מחלקת־העל, עלול לשבור את תתי־המחלקות שיורשות ממנה.\n",
    "    </dd>\n",
    "    <dt>עקרון ההחלפה של ליסקוב (Liskov Substitution Principle)</dt>\n",
    "    <dd>\n",
    "        עיקרון שמציע שעבור כל קוד שעושה שימוש במחלקת־על, יהיה אפשר להחליף את ההתייחסות למחלקת־העל בתת־המחלקות היורשות ממנה.<br>\n",
    "        לפי העיקרון, אם ההחלפה אינה אפשרית, יש לשקול מחדש את קשרי הירושה בקוד.\n",
    "    </dd>\n",
    "    <dt>הכלה במקום ירושה (Composition over inheritance)</dt>\n",
    "    <dd>\n",
    "        רעיון תכנותי תיאורטי שמציע לשקול שימוש בהכלה במקום בירושה כשהדבר אפשרי.\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",
    "    לאדון פסו בגז' יש חנות גדולה לממכר ספרים.<br>\n",
    "    ניצור מחלקה בסיסית שמייצגת מוצר בחנות של פסו:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Product:\n",
    "    def __init__(self, product_id, name, price):\n",
    "        self.id = product_id\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"{self.name} - {self.price}$\""
   ]
  },
  {
   "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": [
    "import datetime\n",
    "\n",
    "\n",
    "class PhoneOrder:\n",
    "    PHONE_CALL_TOLL_IN_USD = 1.99\n",
    "    DELIVERY_PRICE_IN_USD = 5\n",
    "    VAT_IN_PERCENTS = 20\n",
    "    \n",
    "\n",
    "    def __init__(self, seller_id, buyer_id, products):\n",
    "        self.seller = seller_id\n",
    "        self.buyer = buyer_id\n",
    "        self.products = products\n",
    "        self.time = datetime.datetime.now()\n",
    "        self.price = self.calculate_price()\n",
    "        self.delivered = False\n",
    "\n",
    "    def calculate_price(self):\n",
    "        base_price = sum(product.price for product in self.products)\n",
    "        return base_price + self._calculate_extra_price(base_price)\n",
    "    \n",
    "    def _calculate_extra_price(self, base_price, include_vat=True):\n",
    "        tax = self.VAT_IN_PERCENTS / 100\n",
    "        return (\n",
    "            base_price * tax\n",
    "            + self.DELIVERY_PRICE_IN_USD\n",
    "            + self.PHONE_CALL_TOLL_IN_USD\n",
    "        )\n",
    "\n",
    "    def __str__(self):\n",
    "        return (\n",
    "            f\"Buyer #{self.buyer}, created by #{self.seller}.\\n\"\n",
    "            + f\"Delivered: {self.delivered}.\\n\"\n",
    "            + f\"{'-' * 40}\\n\"\n",
    "            + \"\\n\".join(str(product) for product in self.products)\n",
    "            + f\"\\n{'-' * 40}\\n\"\n",
    "            + f\"Total: {self.price}$\"\n",
    "        )\n",
    "\n",
    "\n",
    "book1 = Product(1, \"The Fountainhead\", 27.99)\n",
    "book2 = Product(2, \"Thinking, Fast and Slow\", 19.69)\n",
    "order = PhoneOrder(251, 666, [book1, book2])\n",
    "print(order)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    דמיינו שכעת עליכם לממש את המחלקות שאחראיות להזמנות מהסניפים ומהמרשתת.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "        עד מהרה נגלה שהקוד במחלקות הללו דומה מאוד לקוד שיצרנו במחלקת <var>PhoneOrder</var>.<br>\n",
    "    אם כך, נשמע שהדבר הנכון הוא ליצור מחלקה ששלוש המחלקות יורשות ממנה:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "\n",
    "\n",
    "class Order:\n",
    "    DELIVERY_PRICE_IN_USD = 5\n",
    "    VAT_IN_PERCENTS = 20\n",
    "\n",
    "    def __init__(self, seller_id, buyer_id, products):\n",
    "        self.seller = seller_id\n",
    "        self.buyer = buyer_id\n",
    "        self.products = products\n",
    "        self.time = datetime.datetime.now()\n",
    "        self.price = self.calculate_price()\n",
    "        self.delivered = False\n",
    "\n",
    "    def calculate_price(self):\n",
    "        base_price = sum(product.price for product in self.products)\n",
    "        return base_price + self._calculate_extra_price(base_price)\n",
    "\n",
    "    def _calculate_extra_price(\n",
    "            self, base_price, include_vat=True, include_delivery=True,\n",
    "    ):\n",
    "        tax = self.VAT_IN_PERCENTS / 100\n",
    "        price = base_price * tax\n",
    "        if include_delivery:\n",
    "            price = price + self.DELIVERY_PRICE_IN_USD\n",
    "        return price\n",
    "\n",
    "    def __str__(self):\n",
    "        return (\n",
    "            f\"Buyer #{self.buyer}, created by #{self.seller}.\\n\"\n",
    "            + f\"Delivered: {self.delivered}.\\n\"\n",
    "            + f\"{'-' * 40}\\n\"\n",
    "            + \"\\n\".join(str(product) for product in self.products)\n",
    "            + f\"\\n{'-' * 40}\\n\"\n",
    "            + f\"Total: {self.price}$\"\n",
    "        )\n",
    "\n",
    "\n",
    "class PhoneOrder(Order):\n",
    "    PHONE_CALL_TOLL_IN_USD = 1.99\n",
    "\n",
    "    def _calculate_extra_price(self, base_price, **kwargs):\n",
    "        base_price = super()._calculate_extra_price(base_price, **kwargs)\n",
    "        return base_price + self.PHONE_CALL_TOLL_IN_USD\n",
    "\n",
    "\n",
    "class OnlineOrder(Order):\n",
    "    pass\n",
    "\n",
    "\n",
    "class StoreOrder(Order):\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "        self.delivered = True\n",
    "\n",
    "    def _calculate_extra_price(self, base_price, **kwargs):\n",
    "        return super()._calculate_extra_price(\n",
    "            base_price, include_delivery=False, **kwargs,\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Show all three kinds of orders:\\n\\n\")\n",
    "\n",
    "book1 = Product(1, \"The Fountainhead\", 27.99)\n",
    "book2 = Product(2, \"Thinking, Fast and Slow\", 19.69)\n",
    "order = PhoneOrder(seller_id=251, buyer_id=666, products=[book1, book2])\n",
    "print(order)\n",
    "\n",
    "print('\\n\\n')\n",
    "order = StoreOrder(seller_id=251, buyer_id=666, products=[book1, book2])\n",
    "print(order)\n",
    "\n",
    "print('\\n\\n')\n",
    "order = OnlineOrder(seller_id=251, buyer_id=666, products=[book1, book2])\n",
    "print(order)"
   ]
  },
  {
   "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;\">היררכיה</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": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    כל קובץ הוא מסוג מסוים – טקסטואלי, בינארי או תיקייה.<br>\n",
    "    תיקייה היא קובץ שמכיל בתוכו רשימת קבצים, שיכולים להיות טקסטואליים, בינאריים או תיקיות.<br>\n",
    "    נדמיין, לדוגמה, את היררכיית התיקיות הבאה:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "week08\n",
    "│   1_Inheritance.ipynb\n",
    "│   2_Inheritance_Part_2.ipynb\n",
    "│   3_Exceptions.ipynb\n",
    "│\n",
    "├───images\n",
    "│       exercise.svg\n",
    "│       logo.jpg\n",
    "│       recall.svg\n",
    "│\n",
    "└───resources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בדוגמה שלמעלה יש 5 קבצים תחת תיקיית week08: שניים מהם תיקיות (images, resources) ו־3 מהם מחברות.<br>\n",
    "    התיקייה resources ריקה, ובתיקייה images יש את הקבצים הטקסטואליים exercise.svg ו־recall.svg ואת הקובץ הבינארי logo.jpg.<br>\n",
    "    במערכת שלנו, הנתיב לתיקיית week08 הוא <span dir=\"ltr\">/week08</span>, והנתיב לקובץ logo.jpg הוא <span dir=\"ltr\">/week08/images/logo.jpg</span>.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    צרו בתוכנה שלכם מערכת לניהול משתמשים. לכל משתמש יש שם משתמש וסיסמה.<br>\n",
    "    משתמש יכול להיות מסוג \"מנהל מערכת\" או \"משתמש רגיל\".<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    לקובץ בינארי או טקסטואלי יש משקל המיוצג בקילובייטים, תוכן, ומשתמש שיצר אותו.<br>\n",
    "    על קובץ טקסטואלי ניתן להפעיל את הפעולה <var>count</var>, שמקבלת מחרוזת לחיפוש ומחזירה כמה פעמים המחרוזת הופיעה בקובץ.<br>\n",
    "    אם הקובץ הבינארי הוא מסוג תמונה, צרו עבורו את הפעולה <var>get_dimensions</var> שמחזירה את אורך התמונה ואת רוחבה. אין צורך לממש את תוכן הפעולה עצמה.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    לכל קובץ שאינו תיקייה צריכה להיות  הפעולה <code dir=\"ltr\">.read()</code>, שאליה מעבירים כפרמטר משתמש.<br>\n",
    "    אם המשתמש הוא זה שיצר את הקובץ או שהוא מנהל המערכת, מהפעולה יוחזר תוכן הקובץ. אחרת יוחזר <code>None</code>.\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",
    "    ממשו את משחק <a href=\"https://he.wikipedia.org/wiki/%D7%94%D7%A8%D7%95%D7%A6%D7%97\">המאפיה</a>.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    המחלקה <var>Game</var> תחזיק את הנתונים על המשחק.<br>\n",
    "    היא תאפשר למשתמש חדש להצטרף למשחק בעזרת הפעולה <var>add_player</var>, כשהפרמטר שמועבר לה הוא שם השחקן.<br>\n",
    "    כשהפעולה <var>start</var> תיקרא, יחולק תפקיד לכל אחד מהשחקנים: אזרח, שוטר או איש מאפיה. רק השחקן יודע מה תפקידו במשחק.<br>\n",
    "    בגרסת המשחק שלנו, יהיה רק איש מאפיה אחד ואיש משטרה אחד.<br>\n",
    "    אם הפעולה <var>start</var> נקראה אך אין די משתתפים כך שיהיה לפחות אזרח אחד, החזירו מהפעולה <samp>False</samp> ואל תתחילו את המשחק.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    בכל סיבוב 3 חלקים – רצח על ידי המאפיה, עיכוב על ידי השוטר והצבעת האזרחים.<br>\n",
    "    כשהפעולה <var>start_round</var> נקראת, מתרחשות לפי הסדר הפעולות האלה:<br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ol style=\"text-align: right; direction: rtl; float: right; clear: both;\">\n",
    "    <li>איש המאפיה יתבקש לרצוח שחקן באמצעות הפעולה <var>kill</var> הממומשת אצל איש המאפיה. השחקן הנרצח יוצא מהמשחק.</li>\n",
    "    <li>השוטר יתבקש לעכב את השחקן שלדעתו הוא איש מאפיה בעזרת הפעולה <var>detain</var> הממומשת אצל השוטר.</li>\n",
    "    <li>כל אחד מהמשתתפים יצביע מי לדעתו הוא איש המאפיה באמצעות הפעולה <var>vote</var>.<br>\n",
    "        מי שקיבל הכי הרבה קולות בהצבעה מוצא להורג ויוצא מהמשחק. אם יש תיקו – כל השחקנים נשארים במשחק.</li>\n",
    "</ol>"
   ]
  },
  {
   "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",
    "    <em>בונוס:</em> ממשו את השאלה כבוט לטלגרם.\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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}