object_oriented_programming_advanced.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0",
   "metadata": {},
   "source": [
    "# Advanced Object-oriented Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "- [References](#References)\n",
    "- [Inheritance](#Inheritance)\n",
    "  - [Single Inheritance](#Single-Inheritance)\n",
    "  - [Multiple Inheritance](#Multiple-Inheritance)\n",
    "  - [Composition](#Composition)\n",
    "  - [super()](#super())\n",
    "- [Abstract Classes](#Abstract-Classes)\n",
    "- [Decorators](#Decorators)\n",
    "  - [@classmethod](#@classmethod)\n",
    "  - [@staticmethod](#@staticmethod)\n",
    "  - [@property](#@property)\n",
    "  - [Setters & Getters](#Setters-&-Getters)\n",
    "- [Encapsulation](#Encapsulation)\n",
    "  - [Public](#Public)\n",
    "  - [Private](#Private)\n",
    "  - [Protected](#Protected)\n",
    "- [How to write better classes](#How-to-write-better-classes)\n",
    "  - [Using dataclasses](#Using-dataclasses)\n",
    "  - [Using attrs](#Using-attrs)\n",
    "- [Quiz](#Quiz)\n",
    "- [Exercises](#Exercises)\n",
    "  - [Child Eye Color](#Child-Eye-Color)\n",
    "  - [Store Inventory](#Store-Inventory)\n",
    "  - [Music Streaming Service](#Music-Streaming-Service)\n",
    "  - [Banking System](#Banking-System)\n",
    "  - [The N-Body Problem](#The-N-body-problem)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2",
   "metadata": {},
   "source": [
    "## References"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3",
   "metadata": {},
   "source": [
    "- [super()](https://docs.python.org/3/library/functions.html#super)\n",
    "- [dataclasses](https://docs.python.org/3/library/dataclasses.html)\n",
    "- [attrs](https://www.attrs.org/en/stable/index.htmlhttps://www.attrs.org/en/stable/index.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4",
   "metadata": {},
   "source": [
    "## Inheritance\n",
    "\n",
    "Inheritance is a fundamental concept in object-oriented programming (OOP).\n",
    "It allows you to create a hierarchy of classes with shared behaviors and attributes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5",
   "metadata": {},
   "source": [
    "### Single Inheritance\n",
    "Inheritance is a mechanism in OOP that allows you to create a new class by inheriting the properties and methods of an existing class.\n",
    "\n",
    "The existing class is called the **base class** or **parent class**, and the new class is referred to as the **derived class** or **child class**. \n",
    "\n",
    "The derived class inherits all the attributes and methods of the base class.\n",
    "It can also override or extend those inherited methods."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6",
   "metadata": {},
   "source": [
    "Let's create a simple example in Python.\n",
    "We first define the base class `Animal`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def speak(self):\n",
    "        print(f\"{self.name} makes a sound\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8",
   "metadata": {},
   "source": [
    "From your base class, you can define as many derived classes as you'd like.\n",
    "Simply pass the parent class name as a **parameter** in the child class definition.\n",
    "\n",
    "Here, we create two classes that inherit from `Animal`, namely `Dog` and `Cat`.\n",
    "\n",
    "Both derived classes **override** the generic `speak` method with a specific sound for each animal.\n",
    "\n",
    "They also **extend** the `Animal` class individually, with the `fetch` and `chase` functions, which are animal specific."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        print(f\"{self.name} says Woof!\")\n",
    "\n",
    "    def fetch(self, item):\n",
    "        print(f\"{self.name} fetches the {item}!\")\n",
    "\n",
    "\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        print(f\"{self.name} says Meow!\")\n",
    "\n",
    "    def chase(self, target):\n",
    "        print(f\"{self.name} chases the {target}!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10",
   "metadata": {},
   "source": [
    "Now we can create instances of `Dog` and `Cat`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11",
   "metadata": {},
   "outputs": [],
   "source": [
    "dog = Dog(\"Rex\")\n",
    "cat = Cat(\"Luna\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12",
   "metadata": {},
   "source": [
    "Let's see what happens when you call each instance's methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13",
   "metadata": {},
   "outputs": [],
   "source": [
    "dog.speak()\n",
    "dog.fetch(\"ball\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14",
   "metadata": {},
   "outputs": [],
   "source": [
    "cat.speak()\n",
    "cat.chase(\"mouse\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15",
   "metadata": {},
   "source": [
    "Of course, you can always use the base class `Animal` **as is**.\n",
    "However, in this example it doesn't do much."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16",
   "metadata": {},
   "outputs": [],
   "source": [
    "bird = Animal(\"Bird\")\n",
    "bird.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17",
   "metadata": {},
   "source": [
    "### Multiple Inheritance\n",
    "\n",
    "It is also possible for a class to be derived from **more than one base classes** in Python.\n",
    "This is called multiple inheritance.\n",
    "\n",
    "Let's see the example of a very famous dog who also happens to be a detective:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18",
   "metadata": {},
   "source": [
    "To do that, we first define a new class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Detective:\n",
    "    def __init__(self, topic):\n",
    "        self.topic = topic\n",
    "\n",
    "    def detective_intro(self):\n",
    "        print(f\"This detective solves mysteries about {self.topic}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20",
   "metadata": {},
   "source": [
    "Then, we create a derived class that inherits from two base classes. Notice that:\n",
    "- We can explicitly call the constructor of each base class, in order to pass the arguments.\n",
    "- We can directly access the inherited attributes from both base classes, just by using `self`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DetectiveDog(Dog, Detective):\n",
    "    def __init__(self, name, topic):\n",
    "        Dog.__init__(self, name)\n",
    "        Detective.__init__(self, topic)\n",
    "    \n",
    "    def detective_dog_intro(self):\n",
    "        print(f\"This detective is a dog called {self.name}. He solves mysteries about {self.topic}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22",
   "metadata": {},
   "source": [
    "We can also call all methods inherited from each parent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23",
   "metadata": {},
   "outputs": [],
   "source": [
    "scooby = DetectiveDog('Scooby Doo', 'ghosts')\n",
    "\n",
    "scooby.speak()\n",
    "scooby.detective_intro()\n",
    "scooby.detective_dog_intro()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24",
   "metadata": {},
   "source": [
    "While multiple inheritance can be powerful, it can also lead to complexities and potential conflicts, so it should only be used when really needed.\n",
    "\n",
    "In some cases, composition may be preferred over multiple inheritance to achieve better code organization and maintainability."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25",
   "metadata": {},
   "source": [
    "### Composition\n",
    "\n",
    "Composition is a concept in OOP where a class is composed of one or more objects of other classes, instead of inheriting from them.\n",
    "\n",
    "It is a way to build complex objects by combining simpler ones. Composition allows for greater **flexibility and modularity** in code compared to inheritance.\n",
    "\n",
    "In Python, composition is achieved by including instances of other classes as attributes within a class. \n",
    "These instances become part of the containing class and are used to provide specific functionalities."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26",
   "metadata": {},
   "source": [
    "Let's first create the classes for the `Engine` and the `Wheels` of a vehicle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Engine:\n",
    "    def start(self):\n",
    "        return \"Engine started\"\n",
    "\n",
    "    def stop(self):\n",
    "        return \"Engine stopped\"\n",
    "\n",
    "\n",
    "class Wheel:\n",
    "    def __init__(self, number):\n",
    "        self.number = number\n",
    "\n",
    "    def spin(self):\n",
    "        return f\"Wheel #{self.number} spinning\"\n",
    "\n",
    "    def stop(self):\n",
    "        return f\"Wheel #{self.number} stopped\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28",
   "metadata": {},
   "source": [
    "Then we can create a car, which has one engine and four wheels.\n",
    "\n",
    "Notice that `Car` **does not inherit** from classes `Engine` and `Wheel`.\n",
    "Instead, we instantiate them inside its constructor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self):\n",
    "        self.engine = Engine()\n",
    "        self.wheels = [Wheel(i+1) for i in range(4)]\n",
    "\n",
    "    def start(self):\n",
    "        print(f\"Car starting: {self.engine.start()}\")\n",
    "        for wheel in self.wheels:\n",
    "            print(wheel.spin())\n",
    "\n",
    "    def stop(self):\n",
    "        print(f\"Car stopping: {self.engine.stop()}\")\n",
    "        for wheel in self.wheels:\n",
    "            print(wheel.stop()) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = Car()\n",
    "\n",
    "car.start()\n",
    "car.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31",
   "metadata": {},
   "source": [
    "### `super()`\n",
    "\n",
    "Python's `super()` function allows us to refer the superclass implicitly, so we don’t need to write the name of superclass explicitly.\n",
    "\n",
    "It returns a proxy object that delegates method calls to a parent or sibling class.\n",
    "This is useful for accessing inherited methods that have been overridden in a class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32",
   "metadata": {},
   "source": [
    "Let's re-write class `Dog`, which is a subclass of `Animal`.\n",
    "This time it not only overwrites the method `speak()`, but it also demonstrates how to call the parent's method, with the use of `super()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        print(f\"{self.name} says Woof!\")\n",
    "\n",
    "    def parent_speak(self):\n",
    "        super().speak()\n",
    "\n",
    "dog = Dog('Max')\n",
    "dog.speak()\n",
    "dog.parent_speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34",
   "metadata": {},
   "source": [
    "## Abstract Classes\n",
    "\n",
    "Abstract classes are classes that cannot be instantiated directly.\n",
    "They are meant to be used as a blueprint for other classes.\n",
    "\n",
    "Abstract classes define methods that **must** be implemented by any concrete (non-abstract) subclass.\n",
    "In Python, you can create abstract classes using the `abc` (**Abstract Base Classes**) module.\n",
    "\n",
    "The ABC class from the abc module is used as the base class for your abstract class.\n",
    "You cannot create an instance of an abstract class, but you can create instances of concrete subclasses that inherit from the abstract class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35",
   "metadata": {},
   "source": [
    "We first create an abstract class which inherits from `ABC`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Shape(ABC):\n",
    "    @abstractmethod\n",
    "    def area(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def perimeter(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37",
   "metadata": {},
   "source": [
    "Careful, you **cannot** create an instance of an abstract class!\n",
    "The following line raises an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38",
   "metadata": {},
   "outputs": [],
   "source": [
    "shape = Shape()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39",
   "metadata": {},
   "source": [
    "Let's create two concrete subclasses of `Shape`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def area(self):\n",
    "        return 3.14 * self.radius ** 2\n",
    "\n",
    "    def perimeter(self):\n",
    "        return 2 * 3.14 * self.radius\n",
    "\n",
    "\n",
    "class Rectangle(Shape):\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": "markdown",
   "id": "41",
   "metadata": {},
   "source": [
    "Now we are allowed to create instances of the subclasses and also call their methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42",
   "metadata": {},
   "outputs": [],
   "source": [
    "circle = Circle(5)\n",
    "rectangle = Rectangle(4, 6)\n",
    "\n",
    "print(\"Circle Area:\", circle.area())\n",
    "print(\"Circle Perimeter:\", circle.perimeter())\n",
    "print(\"Rectangle Area:\", rectangle.area())\n",
    "print(\"Rectangle Perimeter:\", rectangle.perimeter())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43",
   "metadata": {},
   "source": [
    "## Decorators\n",
    "\n",
    "Decorators in Python are a powerful and flexible way to modify or extend the behavior of methods and attributes without changing their source code.\n",
    "Check out the [Advanced functions](./functions_advanced.ipynb#Decorators) notebook to learn more about decorators.\n",
    "\n",
    "Here are the most common decorators used when creating custom classes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44",
   "metadata": {},
   "source": [
    "### @classmethod\n",
    "Defines a class method, which is a method bound to the class rather than its instances.\n",
    "However, class methods can be called by both class and object.\n",
    "\n",
    "It takes the class itself (named `cls`) as its first parameter, allowing you to access and modify class-level attributes and methods.\n",
    "These changes would apply across all the instances of the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    number_of_males = 0\n",
    "    number_of_females = 0\n",
    "    number_of_total = 0\n",
    "\n",
    "    def __init__(self, gender):\n",
    "        self.gender = gender\n",
    "\n",
    "    @classmethod\n",
    "    def count(cls, gender):\n",
    "        if gender == 'M':\n",
    "            cls.number_of_males += 1\n",
    "        elif gender == 'F':\n",
    "            cls.number_of_females += 1\n",
    "        cls.number_of_total += 1\n",
    "\n",
    "    @classmethod\n",
    "    def statistics(cls):\n",
    "        male_percentage = cls.number_of_males / cls.number_of_total * 100\n",
    "        female_percentage = cls.number_of_females / cls.number_of_total * 100\n",
    "        print(f\"There are {cls.number_of_total} persons: {cls.number_of_males} are Male & {cls.number_of_females} are Female.\")\n",
    "        print(f\"So {male_percentage}% are Male & {female_percentage}% are Female.\")\n",
    "\n",
    "persons = []\n",
    "for gender in ['M', 'F', 'F', 'M', 'F']:\n",
    "    persons.append(Person(gender))\n",
    "\n",
    "for person in persons:\n",
    "    Person.count(person.gender)\n",
    "\n",
    "Person.statistics()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46",
   "metadata": {},
   "source": [
    "### @staticmethod\n",
    "Defines a static method, which is also a method bound to the class, but does not have access to the class or instance.\n",
    "Hence, it cannot modify the class state.\n",
    "\n",
    "Static methods are typically used for utility functions that are related to the class but don't need access to instance-specific data.\n",
    "A static method does not receive an implicit first argument."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47",
   "metadata": {},
   "source": [
    "As seen in the example below, static methods have limited use, because they don't have access neither to the class attributes nor to any instance of the class.\n",
    "They **cannot access** `cls` or `self`.\n",
    "\n",
    "However, they can be useful to group utilities together with a class.\n",
    "They improve code readability and allow for method overriding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MathOperations:\n",
    "\n",
    "    @staticmethod\n",
    "    def add(x, y):\n",
    "        return x + y\n",
    "\n",
    "    @staticmethod\n",
    "    def subtract(x, y):\n",
    "        return x - y\n",
    "\n",
    "print(MathOperations.add(2, 3))\n",
    "print(MathOperations.subtract(2, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49",
   "metadata": {},
   "source": [
    "### @property\n",
    "\n",
    "Defines properties in a class.\n",
    "It creates attributes that act like methods but can be accessed and assigned as regular attributes.\n",
    "\n",
    "Properties are also useful for implementing attributes that require additional logic or validation when getting or setting their values.\n",
    "They promote a cleaner way of working with attributes, while controlling their behavior behind the scenes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50",
   "metadata": {},
   "source": [
    "In this simple example, we create a class `Circle`, which has a radius and an area.\n",
    "We can create an instance of it, just like any other class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Circle:\n",
    "    def __init__(self, radius):\n",
    "        self._radius = radius\n",
    "\n",
    "    @property\n",
    "    def radius(self):\n",
    "        return self._radius\n",
    "\n",
    "    @property\n",
    "    def area(self):\n",
    "        return 3.14 * self._radius ** 2\n",
    "\n",
    "circle = Circle(5)\n",
    "print(\"Radius:\", circle.radius)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52",
   "metadata": {},
   "source": [
    "We can access the `area` property, just like any other class attribute.\n",
    "The calculation of its value is done behind the scenes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Area:\", circle.area)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54",
   "metadata": {},
   "source": [
    "### Setters & Getters\n",
    "\n",
    "Properties are a way to provide getter, setter, and deleter methods for class attributes, while maintaining a clean and consistent code.\n",
    "\n",
    "Setters and getters are methods used to manage the access and modification of class attributes, allowing control over how these attributes are set and retrieved.\n",
    "They are often used to enforce data validation or provide a way to handle attributes with additional logic.\n",
    "\n",
    "Python doesn't have explicit syntax for setters and getters like some other programming languages (e.g., Java), but it achieves similar functionality using the `@property` decorator for getters and `@<attribute_name>.setter` or `@<attribute_name>.deleter` decorator for setters and deleters.\n",
    "\n",
    "Let's expand the previous example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Circle:\n",
    "    def __init__(self, radius):\n",
    "        self._radius = radius\n",
    "\n",
    "    @property\n",
    "    def radius(self):\n",
    "        return self._radius\n",
    "\n",
    "    @radius.setter\n",
    "    def radius(self, value):\n",
    "        if value <= 0:\n",
    "            raise ValueError(\"Radius must be a positive number\")\n",
    "        self._radius = value\n",
    "\n",
    "    @radius.deleter\n",
    "    def radius(self):\n",
    "        print(\"Deleting the radius attribute\")\n",
    "        del self._radius"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56",
   "metadata": {},
   "source": [
    "Create an instance and use the getter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57",
   "metadata": {},
   "outputs": [],
   "source": [
    "circle = Circle(5)\n",
    "print(\"Radius:\", circle.radius)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58",
   "metadata": {},
   "source": [
    "Update the radius using the setter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using the setter methods\n",
    "circle.radius = 7\n",
    "print(\"Updated Radius:\", circle.radius)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60",
   "metadata": {},
   "source": [
    "What happens when we enter an invalid value?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61",
   "metadata": {},
   "outputs": [],
   "source": [
    "circle.radius = -5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62",
   "metadata": {},
   "source": [
    "Finally let's use the deleter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63",
   "metadata": {},
   "outputs": [],
   "source": [
    "del circle.radius "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64",
   "metadata": {},
   "source": [
    "We are no longer able to access the deleted attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(circle.radius)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66",
   "metadata": {},
   "source": [
    "## Encapsulation\n",
    "\n",
    "Encapsulation is one of the fundamental principles of OOP and is a concept that plays a crucial role in Python and other OOP languages.\n",
    "\n",
    "Encapsulation refers to the bundling of data (attributes) and methods (functions) that operate on that data into a single unit. \n",
    "\n",
    "It also involves controlling the access to the data and methods, restricting direct access from outside the class.\n",
    "\n",
    "The purpose of encapsulation is to hide the internal implementation details of a class and provide a simpler and cleaner way of interacting with it.\n",
    "\n",
    "By using encapsulation you can:\n",
    "- Protect the data by controlling how it is accessed and modified.\n",
    "- Enforce constraints and validation on data changes.\n",
    "- Make it easier to change the internal implementation of a class without affecting external code that uses the class.\n",
    "\n",
    "In Python, encapsulation is implemented using access modifiers and naming conventions.\n",
    "There are three commonly used access modifiers:\n",
    "\n",
    "### Public\n",
    "In Python, all attributes and methods are public by default, which means they can be accessed from anywhere.\n",
    "\n",
    "### Private\n",
    "Attributes and methods with names starting with a **double underscore** (e.g., `__variable`, `__method()`) are considered private. \n",
    "They are not intended to be accessed directly from outside the class.\n",
    "\n",
    "However, Python does not enforce strict access control, so you can still access them using **name mangling** (e.g., `_classname__variable`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.__private_var = 1\n",
    "\n",
    "    def public_method(self):\n",
    "        return self.__private_var\n",
    "\n",
    "obj = MyClass()\n",
    "\n",
    "print(obj.public_method())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68",
   "metadata": {},
   "source": [
    "### Protected\n",
    "Attributes and methods with names starting with a **single underscore** (e.g., `_variable`, `_method()`) are considered protected. \n",
    "This is a convention to indicate that they should not be accessed directly from outside the class, but there's no strict enforcement.\n",
    "\n",
    "As seen in the example below, you can access a protected attribute both ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self._protected_var = 1\n",
    "\n",
    "    def public_method(self):\n",
    "        return self._protected_var\n",
    "\n",
    "obj = MyClass()\n",
    "print(obj.public_method())\n",
    "print(obj._protected_var) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70",
   "metadata": {},
   "source": [
    "## How to write better classes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71",
   "metadata": {},
   "source": [
    "Lastly, we would like to offer some tips & tricks that will help you write your code in a cleaner and easier-to-maintain way."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72",
   "metadata": {},
   "source": [
    "### Using dataclasses\n",
    "\n",
    "Assume we are implementing a simple class to represent a `Person`, it would look something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age, height):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.height = height"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74",
   "metadata": {},
   "source": [
    "A simpler way, however, would be to import `dataclass` from the `dataclasses` module.\n",
    "\n",
    "This module provides a decorator and functions for automatically adding generated special methods such as `__init__()` and `__repr__()` to user-defined classes.\n",
    "\n",
    "This means that we no longer need to use `__init__()`, but only to specify the attributes of the class and their types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75",
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "@dataclass\n",
    "class Person:\n",
    "    name: str\n",
    "    age: int\n",
    "    height: float"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76",
   "metadata": {},
   "source": [
    "Now, with the use of these auto generated methods, we can create an instance of the class and print a representation of the object, without any additional code.\n",
    "It also simplifies object comparison."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77",
   "metadata": {},
   "outputs": [],
   "source": [
    "john = Person('John', 25, 1.75)\n",
    "jane = Person('Jane', 25, 1.75)\n",
    "\n",
    "print(john)\n",
    "print(jane)\n",
    "print(john == jane)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78",
   "metadata": {},
   "source": [
    "### Using attrs\n",
    "\n",
    "This Python package is for creating well-defined classes with a type, attributes and methods. When defining a class, it will add static methods to that class based on the attributes you declare.\n",
    "\n",
    "`attrs` will operate only on the dunder methods of your class.\n",
    "Hence, all of its tools will live in functions that operate on top of instances."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79",
   "metadata": {},
   "source": [
    "Let's rewrite the previous example, this time using `attrs`.\n",
    "You will notice that it offers the same functionalities, i.e. `__init__()`, `__repr__()`, and object comparison."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80",
   "metadata": {},
   "outputs": [],
   "source": [
    "from attrs import define\n",
    "\n",
    "@define\n",
    "class Person:\n",
    "    name: str\n",
    "    age: int\n",
    "    height: float\n",
    "\n",
    "john = Person('John', 25, 1.75)\n",
    "jane = Person('Jane', 25, 1.75)\n",
    "\n",
    "print(john)\n",
    "print(jane)\n",
    "print(john == jane)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81",
   "metadata": {},
   "source": [
    "However, `attrs` also provides **validators**.\n",
    "To use this functionality:\n",
    "- The attribute that you wish to validate needs to have a `field()` assigned\n",
    "- Use the validator decorator to define the check for that specific attribute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82",
   "metadata": {},
   "outputs": [],
   "source": [
    "from attrs import define, field\n",
    "\n",
    "@define\n",
    "class Person:\n",
    "    name: str\n",
    "    age: int = field()\n",
    "    height: float\n",
    "\n",
    "    @age.validator\n",
    "    def check(self, attribute, value):\n",
    "        if value < 1:\n",
    "            raise ValueError(\"Age must be greater than 0\")\n",
    "\n",
    "john = Person('John', 0, 1.75)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83",
   "metadata": {},
   "source": [
    "## Quiz\n",
    "\n",
    "Run the following cell to test your knowledge with a small quiz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tutorial import object_oriented_programming_advanced as oopa\n",
    "\n",
    "oopa.OopAdvanced()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86",
   "metadata": {},
   "outputs": [],
   "source": [
    "%reload_ext tutorial.tests.testsuite"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87",
   "metadata": {},
   "source": [
    "### Child Eye Color\n",
    "\n",
    "In this exercise, we will implement the following simplified theory on how to predict a child's eye color, based on the eye color of its parents.\n",
    "\n",
    "We assume that the only existing eye colors are <span style=\"color:blue\">blue</span> and <span style=\"color:brown\">brown</span>. We also assume the following rules:\n",
    "- If both parents have <span style=\"color:brown\">brown</span> eyes, their child will also have <span style=\"color:brown\">brown</span> eyes.\n",
    "- If both parents have <span style=\"color:blue\">blue</span> eyes, their child will also have <span style=\"color:blue\">blue</span> eyes.\n",
    "- If one parent has <span style=\"color:brown\">brown</span> eyes and the other one has <span style=\"color:blue\">blue</span> eyes, the dominant color will be <span style=\"color:brown\">brown</span>.\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Question</b></h4>\n",
    "    <ul>\n",
    "    <li>Complete the solution function such that it creates classes <strong>Mother</strong> and <strong>Father</strong>, each with an attribute for <strong>eye_color</strong>.</li>\n",
    "    <li>Create class <strong>Child</strong>, which inherits the eye colors of <strong>Mother</strong> and <strong>Father</strong> and based on those, calculate the child's eye color, according to the rules above.</li>\n",
    "    <li>Create two parents, each with a randomly assigned eye color, by picking one of the available two. Then create their child and return its eye color.</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "import random\n",
    "\n",
    "colors = [\"blue\", \"brown\"]\n",
    "mother_eye_color = random.choice(colors)\n",
    "father_eye_color = random.choice(colors)\n",
    "\n",
    "def solution_child_eye_color(mother_eye_color: str, father_eye_color: str) -> str:\n",
    "    # Write your solution here\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89",
   "metadata": {},
   "source": [
    "### Store Inventory\n",
    "\n",
    "Assuming there is a store selling computers, we aim to implement its inventory information system for the following products:\n",
    "\n",
    "- **Computer** with attributes: <code>name, price, quantity</code>.\n",
    "- **PC** with additional attribute: <code>expansion_slots</code>.\n",
    "- **Laptop** with additional attribute: <code>battery_life</code>.\n",
    "\n",
    "Define the <strong>Computer</strong> class and its subclasses, <strong>PC</strong> and <strong>Laptop</strong>.\n",
    "\n",
    "For each of the three classes, implement the `__init__` and `__str__` methods, for initializing and displaying the instance information respectively.\n",
    "For <strong>PC</strong> and <strong>Laptop</strong> make sure to use `super()` in both of these methods, to call the ones from <strong>Computer</strong>.\n",
    "\n",
    "- The output of Computer's `__str__` method should be: `Computer with name '<name>', price <price> CHF and quantity <quantity>.`\n",
    "- The output of PC's `__str__` method should **append** Computer's output with: ` This PC has <expansion_slots> expansion slots.`\n",
    "- The output of Laptop's `__str__` method should **append** Computer's output with: ` This laptop has a battery life of <battery_life> hours.`\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hint</b></h4>\n",
    "    An example of a PC's string representation can be: <code>Computer with name 'pc_1', price 1000 CHF and quantity 2. This PC has 3 expansion slots.</code>\n",
    "    </br>\n",
    "    <strong>Pay attention to the single quotes and the whitespace between the two sentences.</strong>\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 the instances of the two computers mentioned in the list below.\n",
    "    <strong>Pay attention to the type!</strong>\n",
    "    </br>\n",
    "    This function should return a list that collects the <strong>string representations</strong> of the two computers.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "computers = [\n",
    "    {\n",
    "        \"type\": \"PC\",\n",
    "        \"name\": \"pc_1\",\n",
    "        \"price\": 1500,\n",
    "        \"quantity\": 1,\n",
    "        \"expansion_slots\": 2\n",
    "    },\n",
    "    {\n",
    "        \"type\": \"Laptop\",\n",
    "        \"name\": \"laptop_1\",\n",
    "        \"price\": 1200,\n",
    "        \"quantity\": 4,\n",
    "        \"battery_life\": 6\n",
    "    }\n",
    "]\n",
    "\n",
    "\n",
    "def solution_store_inventory(computers: list[dict]) -> list[str]:\n",
    "    # Write your solution here\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91",
   "metadata": {},
   "source": [
    "### Music Streaming Service\n",
    "\n",
    "The basis of all music streaming service systems is a common simple structure: Artists release songs, while users can create their own playlists, with their favourite songs.\n",
    "\n",
    "To represent this structure, we can use the following entities:\n",
    "- **Song** with attributes: title, artist, album_title.\n",
    "- **Playlist** with attributes: name and songs.\n",
    "- **User** with attributes: username, playlists.\n",
    "\n",
    "Based on these, create the respective classes:\n",
    "- `Song`: should contain attributes `title` (string), `artist` (string) and `album_title` (string)\n",
    "- `Playlist`: should contain attributes `name` (string) and `songs` (a list of `Song` instances). It should also include a method for adding song a song to the playlist.\n",
    "- `User`: should contain attributes `name` (string) and `playlists` (a dict where key is the name of the playlist and value is a `Playlist` instance). It should also include a method for creating a playlist and a method for adding a specific song to a specific playlist.\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Question</b></h4>\n",
    "    Using <strong>composition</strong> in Python, create a music streaming service system that includes the classes mentioned above.\n",
    "    Create <strong>one user that has one playlist</strong>, containing the songs provided in the list below.\n",
    "    Your solution function should <strong>return the <code>User</code></strong> instance.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "song_info = [\n",
    "    {\n",
    "        \"title\": \"Bohemian Rhapsody\",\n",
    "        \"artist\": \"Queen\",\n",
    "        \"album_title\": \"A Night at the Opera\"\n",
    "    },\n",
    "    {\n",
    "        \"title\": \"We Will Rock You\",\n",
    "        \"artist\": \"Queen\",\n",
    "        \"album_title\": \"News of the World\"\n",
    "    },\n",
    "    {\n",
    "        \"title\": \"I Want to Break Free\",\n",
    "        \"artist\": \"Queen\",\n",
    "        \"album_title\": \"The Works\"\n",
    "    },\n",
    "]\n",
    "\n",
    "def solution_music_streaming_service(song_info: list[dict]):\n",
    "    # Write your solution here\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93",
   "metadata": {},
   "source": [
    "### Banking System\n",
    "\n",
    "In this exercise, we will implement a very simple banking system where there are two different types of accounts: **Salary Accounts** and **Savings Accounts**.\n",
    "\n",
    "We assume the following Classes:\n",
    "\n",
    "**Account**:\n",
    "\n",
    "An abstract base class representing a generic bank account with attributes `account_number` and `balance` and abstract methods `credit()` and `get_balance()`.\n",
    "It should also contain the method `debit()`, which, if funds are sufficient, should subtract a given amount (parameter) from the account balance.\n",
    "Method `debit()` should be common for all derived classes.\n",
    "\n",
    "**SalaryAccount**:\n",
    "\n",
    "A derived class representing a salary account that contains an additional attribute for `tax_rate` and **overrides** methods `credit()` and `get_balance()`.\n",
    "Method `credit()` should set the balance as the `gross_salary` after applying the `tax_rate` to it.\n",
    "Method `get_balance()` should simply return the account balance.\n",
    "\n",
    "**SavingsAccount**:\n",
    "\n",
    "A derived class representing a savings account that contains additional attributes for `interest_rate` and the account's `creation_year`, plus **overrides** methods `credit()` and `get_balance()`.\n",
    "Method `credit()` should simply add the given amount to the current balance.\n",
    "Method `get_balance()` should return the account balance plus interest, based on the `interest_rate` and the `years_passed` from the account's creation.\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Question</b></h4>\n",
    "    Using <strong>abstraction</strong> in Python, create a banking system based on the entities mentioned above.\n",
    "    <ul>\n",
    "      <li>\n",
    "        <strong>Initialize Accounts:</strong>\n",
    "        <p>Create a Salary Account and a Savings Account with an initial balance of 0 in each.</p>\n",
    "      </li>\n",
    "      <li>\n",
    "        <strong>Update Salary Account:</strong>\n",
    "        <p>Add an amount represented by <code>gross_salary</code> to the Salary Account's balance.</p>\n",
    "      </li>\n",
    "      <li>\n",
    "        <strong>Transfer Funds:</strong>\n",
    "        <p>Calculate a transfer amount from the Salary Account to the Savings Account using a given <code>savings_percentage</code>. Deduct this amount from the Salary Account and add it to the Savings Account.</p>\n",
    "      </li>\n",
    "      <li>\n",
    "        <strong>Project Future Balance:</strong>\n",
    "        <p>Return the projected balance of the Savings Account after a specified number of years, provided by <code>years_passed</code>.</p>\n",
    "      </li>\n",
    "    </ul>\n",
    "\n",
    "The solution function should return the balance of the Savings Account after the given number of years.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "from abc import ABC, abstractmethod\n",
    "from datetime import datetime\n",
    "\n",
    "def solution_banking_system(tax_rate: float, interest_rate: float, gross_salary: int, savings_precentage: float, years_passed: int) -> float:\n",
    "    # Write your solution here\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95",
   "metadata": {},
   "source": [
    "### The N-body problem"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96",
   "metadata": {},
   "source": [
    "On a boring and rainy Sunday afternoon, you decide that you want to attempt writing a Python program that simulates the orbits of Jupiter's moons. To start with, you decide to focus your efforts on tracking just **four** of the largest moons: Io, Europa, Ganymede, and Callisto.\n",
    "\n",
    "After a brief scan and some careful calculations, you successfully record the **position of each moon in a 3-dimensional space**. You set each moon's velocity to `0` in each direction, and the starting point for their orbits. Your next task is to simulate their motion over time, so you can avoid any potential collisions.\n",
    "\n",
    "You can simulate the motion of the moons in **time steps**. At each time step, first update the **velocity** of evey moon by computing the **gravity interaction** with the other moons. Then, once all the velocities are up to date, you can update the **position** of every moon by applying their velocities. Afterwards, your simulation can advance by one time step.\n",
    "\n",
    "For example, one possible starting configuration of the moons is\n",
    "\n",
    "```\n",
    "Ganymede: x=-1, y=0, z=2\n",
    "Io: x=2, y=-10, z=-7\n",
    "Europa: x=4, y=-8, z=8\n",
    "Callisto: x=3, y=5, z=-1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hint</b></h4>\n",
    "    Write a Python class called <code>Moon</code> that stores all the properties of a single moon. You should have <b>two lists</b> of integers, one for the positions and one for the velocities.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Moon:\n",
    "    \"\"\"A class for a moon\"\"\"\n",
    "    # Write here your implementation here of the Moon class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Question</b></h4>\n",
    "    Write a function that returns a list of string, each containing the starting position and velocity of every moon in the system\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "100",
   "metadata": {},
   "source": [
    "Each of the strings output by your solution function below should be something like\n",
    "```\n",
    "{moon_name}: x={pos_x} , y={pos_x} , z={pos_x} , vx={v_x} , vy={v_x} , vz={v_x}\n",
    "```\n",
    "\n",
    "where the `{}` contents should be replace with the actual values for **each moon**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "101",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "def solution_moons(moons: str) -> list[str]:\n",
    "    # Write your solution here\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "102",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "    <h4><b>Heads-up</b></h4>\n",
    "    Please, proceed with the next part <strong>only</strong> if you completed successfully the first part above.\n",
    "</div>\n",
    "\n",
    "To perform a simulation, proceed as follows:\n",
    "\n",
    "1. Consider every **pair** of moons. On each axis, the velocity changes by **exactly `+1` or `-1`**\n",
    "\n",
    "2. To determine the sign of the velocity change, consider the moons' positions. For example, if `G` stands for Ganymede and `C` for Callisto:\n",
    "\n",
    "    * If `Gx = 3` (the `x` position of Ganymede) and `Cx = 5`, then Ganymede's `x` velocity changes by `+1` (because `5 > 3`), and Callisto's `x` velocity must change by `-1` (because `3 < 5`).\n",
    "    * If the positions on a given axis **are the same**, then the velocity on that axis doesn't change at all.\n",
    "    \n",
    "3. Once the gravity has been calculated and the velocity updated, we should also update the position: simply **add the velocity** of each moon to its current position. For example, if Europa's position is `x=1, y=2, z=3` and its velocity `x=-2, y=0, z=3`, then the new position would be `x=-1, y=2, z=6`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "103",
   "metadata": {},
   "source": [
    "To have a complete account of the moons' orbits, you need to compute the **total energy of the system**. The total energy for a single moon is its **potential energy** multiplied by its **kinetic energy**.\n",
    "\n",
    "The energies are defined as follows:\n",
    "\n",
    "- **Kinetic energy**: it's the sum of the **absolute values** of its velocity components.\n",
    "- **Potential energy**: it's the sum of the **absolute values** of its positional coordinates.\n",
    "\n",
    "Considering again the above example as a starting point:\n",
    "\n",
    "```\n",
    "Ganymede: x=-1, y=0, z=2\n",
    "Io: x=2, y=-10, z=-7\n",
    "Europa: x=4, y=-8, z=8\n",
    "Callisto: x=3, y=5, z=-1\n",
    "```\n",
    "\n",
    "After simulating **10 time steps**, the system's configurations is\n",
    "\n",
    "```\n",
    "Ganymede: x= 2, y= 1, z=-3, vx=-3, vy=-2, vz= 1\n",
    "Io: x= 1, y=-8, z= 0, vx=-1, vy= 1, vz= 3\n",
    "Europa: x= 3, y=-6, z= 1, vx= 3, vy= 2, vz=-3\n",
    "Callisto: x= 2, y= 0, z= 4, vx= 1, vy=-1, vz=-1\n",
    "```\n",
    "\n",
    "And therefore the energy:\n",
    "\n",
    "| moon      | potential energy | kinetic     | total     |\n",
    "|-----------|-----------------|-------------|-----------|\n",
    "| Ganymede  | 2 + 1 + 3 = 6    | 3 + 2 + 1 = 6 | 6 * 6 = 36|\n",
    "| Io        | 1 + 8 + 0 = 9    | 1 + 1 + 3 = 5 | 9 * 5 = 45|\n",
    "| Europa    | 3 + 6 + 1 = 10   | 3 + 2 + 3 = 8 | 10 * 8 = 80|\n",
    "| Callisto  | 2 + 0 + 4 = 6    | 1 + 1 + 1 = 3 | 6 * 3 = 18|\n",
    "\n",
    "Sum of total energy: `36 + 45 + 80 + 18 = 179`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "104",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hint</b></h4>\n",
    "    You should create another class called <code>Universe</code> which contains all the moons in your system, and a method <code>evolve()</code> that performs the evolution of a single time step. You should also add a method that computes the total energy.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "105",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Universe:\n",
    "    \"\"\"A class for a universe\"\"\"\n",
    "    # Write here your implementation here of the Universe class "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "106",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hint</b></h4>\n",
    "    Your solution function reads an input string that represent the starting point of the Universe. It's a string like the following:\n",
    "    <pre><code>Ganymede: <span class=\"hljs-attr\">x=-1,</span> <span class=\"hljs-attr\">y=0,</span> <span class=\"hljs-attr\">z=2</span>\n",
    "Io: <span class=\"hljs-attr\">x=2,</span> <span class=\"hljs-attr\">y=-10,</span> <span class=\"hljs-attr\">z=-7</span>\n",
    "Europa: <span class=\"hljs-attr\">x=4,</span> <span class=\"hljs-attr\">y=-8,</span> <span class=\"hljs-attr\">z=8</span>\n",
    "Callisto: <span class=\"hljs-attr\">x=3,</span> <span class=\"hljs-attr\">y=5,</span> <span class=\"hljs-attr\">z=-1</span>\n",
    "</code></pre>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "107",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<h4><b>Question</b></h4>\n",
    "    What is the <b>average</b> of the total energy of the system after simulating the universe for <b>1000 time steps</b>?\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "108",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_n_body(universe_start: str) -> int:\n",
    "    # Write your solution here\n",
    "    pass"
   ]
  }
 ],
 "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.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}