object_oriented_programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0",
   "metadata": {},
   "source": [
    "# Object-oriented Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1",
   "metadata": {},
   "source": [
    "# Table of Contents\n",
    "  - [Object-oriented Programming](#Object-oriented-Programming)\n",
    "    - [References](#References)\n",
    "    - [A `class` as a blueprint of objects](#A-class-as-a-blueprint-of-objects)\n",
    "    - [Properties and methods](#Properties-and-methods)\n",
    "    - [Python's *special methods*](#Python's-*special-methods*)\n",
    "      - [`__str__` and `__repr__`](#__str__-and-__repr__)\n",
    "      - [Exercise 1: Ice cream scoop 🌶️](#Exercise-1:-Ice-cream-scoop-🌶️)\n",
    "      - [Exercise 2: Ice cream bowl 🌶️🌶️](#Exercise-2:-Ice-cream-bowl-🌶️🌶️)\n",
    "      - [Comparison methods](#Comparison-methods)\n",
    "      - [Exercise 3: Ice cream shop 🌶️🌶️🌶️](#Exercise-3:-Ice-cream-shop-🌶️🌶️🌶️)\n",
    "    - [The `@property` keyword](#The-@property-keyword)\n",
    "    - [Quick glossary](#Quick-glossary)\n",
    "    - [Quiz](#Quiz)\n",
    "    - [Exercise 4: Intcode computer 🌶️🌶️🌶️🌶️](#Exercise-4:-Intcode-computer-🌶️🌶️🌶️🌶️)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2",
   "metadata": {},
   "source": [
    "## References"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3",
   "metadata": {},
   "source": [
    "- [Python classes (read)](https://www.py4e.com/html3/14-objects)\n",
    "- [Python classes (video lecture)](https://www.py4e.com/lessons/Objects#)\n",
    "- [Python Data Model](https://docs.python.org/3/reference/datamodel.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4",
   "metadata": {
    "tags": []
   },
   "source": [
    "## A `class` as a blueprint of objects"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5",
   "metadata": {},
   "source": [
    "Object-oriented programming (OOP) is probably the most well-know approach to programming. Almost every programming language in some way or another supports this paradigm.\n",
    "\n",
    "The idea behind OOP is simple: instead of defining our functions in one part of the code, and the data on which those functions operate in a separate part of the code, we define them together.\n",
    "\n",
    "The concept of **object** is the heart of OOP, and the fundamental building block is the **class**. We have already seen many types of objects, each belonging to different classes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "data = \"Python\", 2023, True, 3.14159, (1, 2.0, \"3.0\"), {\"a\": 10, \"b\": 11}\n",
    "\n",
    "for d in data:\n",
    "    print(type(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7",
   "metadata": {},
   "source": [
    "In Python, to create a custom class we use the `class` keyword, and we can initialize class attributes in the special method `__init__`.\n",
    "\n",
    "For example, let's create a class that represents a rectangle as a geometrical entity:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9",
   "metadata": {},
   "source": [
    "The first argument (`self`) is automatically filled in by Python and contains **the object being created**. It's the way a class can modify itself, in some sense.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Note</b></h4>\n",
    "    Using the name <code>self</code> is just a convention (although a good one, and you should use it to make your code more understandable by others), you could really call it whatever (valid) name you want\n",
    "</div>\n",
    "\n",
    "We create **instances** of the `Rectangle` class by calling it with arguments that are passed to the `__init__` method as the second and third arguments.\n",
    "\n",
    "You **don't** have to pass `self` when creating a new instance of a class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r1 = Rectangle(10, 20)\n",
    "r2 = Rectangle(3, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r1.width  # this will return the `self.width` value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r2.height  # this will return the `self.height` value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Properties and methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14",
   "metadata": {},
   "source": [
    "`width` and `height` are attributes of the `Rectangle` class. But since they are just values (they are **not** functions), we call them **properties**.\n",
    "\n",
    "Attributes that are callables (that is, functions) are called **methods**.\n",
    "\n",
    "Properties and methods together are called **attributes** of a class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15",
   "metadata": {},
   "source": [
    "You'll note that we were able to retrieve the `width` and `height` attributes (properties) using a dot notation, where we specify the object we are interested in, then a dot, then the attribute we are interested in."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16",
   "metadata": {},
   "source": [
    "We can add callable attributes to our class (methods), that will also be referenced using the dot notation.\n",
    "\n",
    "Again, the methods will require the first argument to be the object being used when the method is called, that is, `self`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "        \n",
    "    def area(self):\n",
    "        return self.width * self.height\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 2 * (self.width + self.height)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r1 = Rectangle(10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r1.area()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20",
   "metadata": {},
   "source": [
    "When we ran the above line of code, our object was `r1`, so when `area` was called, Python called the method `area` in the `Rectangle` class automatically, passing `r1` as the argument to the `self` parameter."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Python's *special methods*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22",
   "metadata": {},
   "source": [
    "Special methods are methods that Python defines automatically. If you define a custom class, then you are responsible of defining the **expected behavior** of these methods. Otherwise, Python will fallback to the default, built-in definition, or it will raise an error if it doesn't know what to do.\n",
    "\n",
    "These are also called **dunder methods**, that is, \"double-underscore methods\", because their names look like `__method__`. There are special **attributes** as well."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23",
   "metadata": {
    "tags": []
   },
   "source": [
    "### `__str__` and `__repr__`\n",
    "\n",
    "For example, we can obtain a string representation of an integer using the built-in `str` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24",
   "metadata": {},
   "outputs": [],
   "source": [
    "str(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25",
   "metadata": {},
   "source": [
    "What happens if we try this with our `Rectangle` object?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "str(r1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27",
   "metadata": {},
   "source": [
    "Not exactly what we might have expected. On the other hand, how is Python supposed to know how to display our rectangle as a string?\n",
    "\n",
    "We could write a method in the class such as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "        \n",
    "    def area(self):\n",
    "        return self.width * self.height\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 2 * (self.width + self.height)\n",
    "    \n",
    "    def to_str(self):\n",
    "        return 'Rectangle (width={0}, height={1})'.format(self.width, self.height)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29",
   "metadata": {},
   "source": [
    "So now we could get a string from our object as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r1 = Rectangle(10, 20)\n",
    "r1.to_str()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31",
   "metadata": {},
   "source": [
    "However, using the built-in `str` function still does not work 🤔"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "str(r1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33",
   "metadata": {},
   "source": [
    "This is where these special methods come in. When we call `str(r1)`, Python will first look to see if our class (`Rectangle`) has a special method called `__str__`.\n",
    "\n",
    "If the `__str__` method is present, then Python will call it and return that value.\n",
    "\n",
    "There's actually another one called `__repr__` which is related, but we'll just focus on `__str__` for now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "        \n",
    "    def area(self):\n",
    "        return self.width * self.height\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 2 * (self.width + self.height)\n",
    "    \n",
    "    def __str__(self):\n",
    "        \"\"\"A string representation of a Rectangle\"\"\"\n",
    "        return f'Rectangle (width={self.width}, height={self.height})'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r1 = Rectangle(10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "str(r1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37",
   "metadata": {},
   "source": [
    "However, in Jupyter, look what happens here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39",
   "metadata": {},
   "source": [
    "As you can see we still get the default. That's because here Python is **not** converting `r1` to a string, but instead looking for a string *representation* of the object. It is looking for the [`__repr__` method](https://docs.python.org/3/reference/datamodel.html#object.__repr__), which is defined as\n",
    "\n",
    "> the “official” string representation of an object\n",
    "\n",
    "Ideally, the `__repr__` method should return a **valid Python expression** that can be used to recreate an instance of the object. If it's not possible, it should return a simple string. For this tutorial, we can define a `__repr__` method that behaves **identically** to the `__str__` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "        \n",
    "    def area(self):\n",
    "        return self.width * self.height\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 2 * (self.width + self.height)\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'Rectangle (width={self.width}, height={self.height})'\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return self.__str__()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Exercise 1: Ice cream scoop 🌶️"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42",
   "metadata": {},
   "outputs": [],
   "source": [
    "%reload_ext tutorial.tests.testsuite"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43",
   "metadata": {},
   "source": [
    "Define a class `Scoop` that represents a single scoop of ice cream. Each scoop should have a **single** attribute, `flavor`, a string that you can initialize when you create the instance of `Scoop`.\n",
    "\n",
    "Define also a `__str__` method to return a string reprensentation of a scoop. The output should be `Ice cream scoop with flavor '<flavor>'`, where `<flavor` is the actual scoop's flavor. **Pay attention to the single quotes!**\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Question</b></h4>\n",
    "    Complete the solution function such that it creates an instance of the <code>Scoop</code> class for every flavor contained in the argument <code>flavors</code>. This function should return a list that collects the <strong>string representations</strong> of the ice cream scoops.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_ice_cream_scoop(flavors: tuple[str]) -> list[str]:\n",
    "\n",
    "    class Scoop:\n",
    "        \"\"\"A class representing a single scoop of ice cream\"\"\"\n",
    "        # Write your class implementation here\n",
    "\n",
    "    # Write your solution here\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Exercise 2: Ice cream bowl 🌶️🌶️"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46",
   "metadata": {},
   "source": [
    "Create a class `Bowl` that can hold many ice cream scoops, as many as you like. You *should use* the custom class you created in the previous exercise.\n",
    "\n",
    "The `Bowl` class should have a method called `add_scoops()` that accepts **variable number** of scoops.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hint</b></h4>\n",
    "    In the <code>__init__</code> method of the <code>Bowl</code> class, you should define an attribute that acts as a container to hold the scoops you might want to add.\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Question</b></h4> \n",
    "    Complete the solution function such that it creates a bowl of scoops with  every flavor contained in the argument <code>flavors</code>. The output of this function should be a <strong>string</strong> that reports the content of the bowl you just created.\n",
    "</div>\n",
    "\n",
    "For example:\n",
    "\n",
    "```\n",
    "Ice cream bowl with chocolate, vanilla, stracciatella scoops\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "        \n",
    "def solution_ice_cream_bowl(flavors: tuple[str]) -> str:\n",
    "\n",
    "    class Bowl:\n",
    "        \"\"\"A class representing a bowl of ice cream scoops\"\"\"\n",
    "        # Write your class implementation here\n",
    "\n",
    "    # Write your solution here\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Comparison methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49",
   "metadata": {},
   "source": [
    "How about the comparison operator, such as `==`? How can we tell Python how it should compare two different rectangles?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r1 = Rectangle(10, 20)\n",
    "r2 = Rectangle(10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51",
   "metadata": {},
   "outputs": [],
   "source": [
    "r1 == r2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52",
   "metadata": {},
   "source": [
    "As you can see, Python does not consider `r1` and `r2` as equal (using the `==` operator). Again, how is Python supposed to know that two rectangle objects with the same height and width should be considered equal?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53",
   "metadata": {},
   "source": [
    "We just need to tell Python how to do it, using the special method `__eq__`. Let's see how:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "        \n",
    "    def area(self):\n",
    "        return self.width * self.height\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 2 * (self.width + self.height)\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'Rectangle (width={self.width}, height={self.height})'\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return self.__str__()\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        \n",
    "        # This statement is for debugging purposes. We will remove it later\n",
    "        print(f'self={self}, other={other}')\n",
    "        \n",
    "        # Make sure we are comparing a Rectangle with another Rectangle\n",
    "        if isinstance(other, Rectangle):\n",
    "            return (self.width, self.height) == (other.width, other.height)\n",
    "        else:\n",
    "            return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r1 = Rectangle(10, 20)\n",
    "r2 = Rectangle(10, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56",
   "metadata": {},
   "source": [
    "We now have two **different** objects, two instances of our `Rectangle` class. In fact, we can check that the two objects are different with the `is` operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(f\"Is r1 the same as r2? {r1 is r2}. No! Because their IDs are {id(r1)} (r1) and {id(r2)} (r2)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58",
   "metadata": {},
   "source": [
    "However, they are **equal** according to our `__eq__` function: rectangles are considered equal if their widths and heights are equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r1 == r2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r3 = Rectangle(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r1 == r3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62",
   "metadata": {},
   "source": [
    "And if we try to compare our Rectangle to a different type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r1 == 100, type(r1), type(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64",
   "metadata": {},
   "source": [
    "That's because our `Rectangle` class automatically returns `False` if we try to compare for equality an instance of `Rectangle` and any other Python object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65",
   "metadata": {},
   "source": [
    "Here's our final class, without any `print` statement – remember, we should try to avoid side-effects when they are **not** necessary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "        \n",
    "    def area(self):\n",
    "        return self.width * self.height\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 2 * (self.width + self.height)\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'Rectangle (width={self.width}, height={self.height})'\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return self.__str__()\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        if isinstance(other, Rectangle):\n",
    "            return (self.width, self.height) == (other.width, other.height)\n",
    "        else:\n",
    "            return False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67",
   "metadata": {},
   "source": [
    "What about `<`, `>`, `<=`, etc.?\n",
    "\n",
    "Again, Python has special methods we can use to provide that functionality.\n",
    "\n",
    "These are `__lt__`, `__gt__`, `__le__` methods. There are [many more](https://docs.python.org/3/reference/datamodel.html)!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Note</b></h4>\n",
    "    While we can define custom methods for the comparison operators, it doesn't mean it makes sense. In this example with the <code>Rectangle</code> class, the meaning of the greater/less than operations is not formally defined. We chose to compare the rectangles areas but that's completely arbitrary.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "        \n",
    "    def area(self):\n",
    "        return self.width * self.height\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 2 * (self.width + self.height)\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'Rectangle (width={self.width}, height={self.height})'\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return self.__str__()\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        if isinstance(other, Rectangle):\n",
    "            return (self.width, self.height) == (other.width, other.height)\n",
    "        else:\n",
    "            return False\n",
    "    \n",
    "    def __lt__(self, other):\n",
    "        if isinstance(other, Rectangle):\n",
    "            return self.area() < other.area()\n",
    "        else:\n",
    "            return NotImplemented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r1 = Rectangle(100, 200)\n",
    "r2 = Rectangle(10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71",
   "metadata": {},
   "outputs": [],
   "source": [
    "r1 < r2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72",
   "metadata": {},
   "outputs": [],
   "source": [
    "r2 < r1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73",
   "metadata": {},
   "source": [
    "What about `>`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74",
   "metadata": {},
   "outputs": [],
   "source": [
    "r1 > r2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75",
   "metadata": {},
   "source": [
    "How did that work? We did not define a `__gt__` method.\n",
    "\n",
    "Well, Python decided that, since `r1 > r2` was not implemented, it would give `r2 < r1` a try. And since, `__lt__` **is** defined, it worked! It just a matter of swapping the terms in the comparison. Clever, eh? 😎"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76",
   "metadata": {},
   "source": [
    "Of course, `<=` is not going to magically work!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77",
   "metadata": {},
   "outputs": [],
   "source": [
    "r1 <= r2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78",
   "metadata": {},
   "source": [
    "### Exercise 3: Ice cream shop 🌶️🌶️🌶️"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79",
   "metadata": {},
   "source": [
    "Create a class `Shop` that sells many ice cream flavours. \n",
    "\n",
    "The `Shop` class should implement the comparison methods `__eq__`, `__lt__`, `__le__`.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hints</b></h4>\n",
    "    <ul>\n",
    "        <li>In the <code>__init__</code> method of the <code>Shop</code> class, you should define an attribute that acts as a container to hold the available flavours.</li>\n",
    "        <li>You can use  <code>__eq__</code> and  <code>__lt__</code> to define <code>__le__</code>.</li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Question</b></h4> \n",
    "    Complete the solution function so that it creates two ice cream shops. <code>Shop 1</code> should sell the flavors provided by the parameter <code>flavor_1</code> and <code>Shop 2</code> should sell the flavors provided by the parameter <code>flavor_2</code>. The output of this function should be a <strong>boolean value</strong>: Does <code>Shop 1</code> sell <strong>fewer or the same</strong> number of flavors as <code>Shop 2</code>?\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_ice_cream_shop(flavors_1: list[str], flavors_2: list[str]) -> bool:\n",
    "\n",
    "    class Shop:\n",
    "        \"\"\"A class representing an ice cream shop\"\"\"\n",
    "        # Write your class implementation here\n",
    "\n",
    "    # Write your solution here\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81",
   "metadata": {
    "tags": []
   },
   "source": [
    "## The `@property` keyword"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82",
   "metadata": {},
   "source": [
    "A question you might have about our `Rectangle` class is the following: why should we **call** a function to return its area? Isn't area a **property** of a rectangle?\n",
    "\n",
    "Unfortunately, Python doesn't think the same way. If we try to do"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r1.area"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84",
   "metadata": {},
   "source": [
    "It would tell us that `r1.area` is in fact an object. It's actually a **function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(f\"r1.area is a {type(r1.area)}. Is is a function? {callable(r1.area)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86",
   "metadata": {},
   "source": [
    "Python provides you the special keyword `@property`. We are not going into the details of what this keyword does, but here's how you can use it in your classes to make them more \"user-friendly\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "    \n",
    "    @property\n",
    "    def area(self):\n",
    "        return self.width * self.height\n",
    "    \n",
    "    @property\n",
    "    def perimeter(self):\n",
    "        return 2 * (self.width + self.height)\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'Rectangle (width={self.width}, height={self.height})'\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return self.__str__()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88",
   "metadata": {},
   "source": [
    "You can simply add `@property` **just above** the line that defines your property. For example, the `def area()` or `def perimeter()` functions above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "r1 = Rectangle(1, 10)\n",
    "r2 = Rectangle(10, 20)\n",
    "\n",
    "print(f\"Perimeters: r1={r1.perimeter}, r2={r2.perimeter}\")\n",
    "print(f\"Areas: r1={r1.area}, r2={r2.area}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90",
   "metadata": {},
   "source": [
    "If you want to learn more about the `@property` keyword, you can check out [this link](https://docs.python.org/3/library/functions.html#property). **Beware**, it's rather advanced stuff! If it's your first time with Python, just skip it for the time being."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Quick glossary\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92",
   "metadata": {},
   "source": [
    "\n",
    "| Term | Definition |\n",
    "| --- | --- |\n",
    "| Class | A blueprint for creating objects that define their attributes and methods. |\n",
    "| Instance | An individual occurrence of a class, created from the blueprint of the class. |\n",
    "| Method | A function defined within a class that performs some action on an instance of that class or the class itself. |\n",
    "| Attribute | A variable that is bound to a class or instance and holds some value or reference. |\n",
    "| `__init__` | A special method that is automatically called when an instance of a class is created, used for initializing the instance's attributes. |\n",
    "| `__str__/__repr__` | Special methods used for defining a string representation of a class or instance, used for debugging or displaying information about the object. `__str__` is used for human-readable output, while `__repr__` is used for machine-readable output. |\n",
    "| `@property` | A special keyword used to define a method that can be accessed like an attribute, allowing for dynamic attribute behavior. |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93",
   "metadata": {
    "tags": []
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94",
   "metadata": {},
   "source": [
    "## Quiz\n",
    "\n",
    "Run the following cell to test your knowledge with a small quiz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tutorial import object_oriented_programming as oop\n",
    "\n",
    "oop.OopQuiz()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Exercise 4: Intcode computer 🌶️🌶️🌶️🌶️\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "    <h4><b>Note</b></h4>\n",
    "    This is a recap exercise of intermediate difficulty.\n",
    "    If you <strong>never</strong> used classes or objects before, please try to solve and understand the previous exercises first.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97",
   "metadata": {},
   "source": [
    "An **Intcode program** is a list of integers separated by commas (e.g. `1,0,0,3,99`). The first number is called \"position `0`\". Each number represents either an **opcode** or a **position**.\n",
    "\n",
    "An opcode indicates what to do and it's either `1`, `2`, or `99`. The meaning of each opcode is the following:\n",
    "\n",
    "1. `99` means that the program should immediately terminate. No instruction will be executed after encountering this opcode.\n",
    "\n",
    "2. `1` **adds** together numbers read from **two positions** and stores the result in a **third position**. The three integers **immediately after** the opcode indicates these three positions. For example, the Intcode program `1,10,20,30` should be executed as: read the values at positions `10` and `20`, add those values, and then overwrite the value at position `30`.\n",
    "\n",
    "3. `2` works exactly like opcode `1`, but it **multiplies** the two inputs instead of adding them. Again, the three integers following the opcode indicates **where** the inputs and outputs are, not their **values**.\n",
    "\n",
    "Finally, when the computer is done with an opcode, it moves to the next one by stepping **forward 4 positions**.\n",
    "\n",
    "For example, consider the following program\n",
    "\n",
    "```\n",
    "1,9,10,3,2,3,11,0,99,30,40,50\n",
    "```\n",
    "\n",
    "which can be splitted into multiple lines to indicate the 4 instructions (opcodes):\n",
    "\n",
    "```\n",
    "1,9,10,3,\n",
    "2,3,11,0,\n",
    "99,\n",
    "30,40,50\n",
    "```\n",
    "\n",
    "The first line represents the **sum** (opcode `1`) of the values stored at positions `9` (that is `30`) and `10` (that is `40`). The result (`70`) is then stored at position `3`. Afterward, the program becomes:\n",
    "\n",
    "```\n",
    "1,9,10,70,\n",
    "2,3,11,0,\n",
    "99,\n",
    "30,40,50\n",
    "```\n",
    "\n",
    "Stepping forward by 4 positions, we end up on the second line, which represents a **multiplication** operation (opcode `2`). Take the values at positions `3` and `11`, multiply them, and save the result at position `0`. You obtain:\n",
    "\n",
    "```\n",
    "3500,9,10,70,\n",
    "2,3,11,0,\n",
    "99,\n",
    "30,40,50\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Question</b></h4>\n",
    "    What value is left at position <code>0</code> after the program stops?\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99",
   "metadata": {},
   "source": [
    "Here are the initial and final states of a few small programs:\n",
    "\n",
    "- `1,0,0,0,99` becomes `2,0,0,0,99`, so the value at `0` is `2`\n",
    "- `2,3,0,3,99` becomes `2,3,0,6,99` (value at `0` is `2`)\n",
    "- `1,1,1,4,99,5,6,0,99` becomes `30,1,1,4,2,5,6,0,99` (value at `0` is `30`)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "100",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hint</b></h4>\n",
    "    <ul>\n",
    "        <li>Write a Python class called <code>Computer</code> with a method called <code>run()</code></li>\n",
    "        <li>The class <code>__init__()</code> method should process your input string and assign the attribute <code>program</code>, which should be a <b>list</b> of integers</li>\n",
    "        <li>The solution function takes a <strong>single parameter</strong>: the string representing your intcode program. It should return a <strong>single value</strong>, an integer number</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "101",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest    \n",
    "def solution_intcode_computer(intcode: str) -> int:\n",
    "    class Computer:\n",
    "        \"\"\"An Intcode computer class\"\"\"\n",
    "        # Write your class implementation here\n",
    "\n",
    "    # Write your solution function here\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "102",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}