hw15.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c0012810",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Country(object):\n",
    "    pass\n",
    "\n",
    "# the same as\n",
    "\n",
    "class Country:\n",
    "    pass "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "20576183",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(object, object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1a901c7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "c = Country()\n",
    "\n",
    "print(isinstance(c, object))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4d6bca8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(isinstance(None, object))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37c031ca",
   "metadata": {},
   "source": [
    "#### Parent vs Child class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ca8224fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Country(object):\n",
    "    system = 'Common system' \n",
    "    \n",
    "    def __init__(self, name, population):\n",
    "        self.name = name\n",
    "        self.population = population\n",
    "\n",
    "    # magic method\n",
    "    def __str__(self):\n",
    "        return f'Country: {self.name} with population {self.population}'\n",
    "\n",
    "    def make_declaration(self, speech):\n",
    "        return f'{self.name} declare: {speech}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8f755e40",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Republic(Country):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "69b08994",
   "metadata": {},
   "outputs": [],
   "source": [
    "congo = Republic('Congo', 5_000_000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2491f5fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5000000"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "congo.population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f7399d77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Congo'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "congo.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "270ba164",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Common system'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "congo.system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "1f35df86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Country: Congo with population 5000000\n"
     ]
    }
   ],
   "source": [
    "print(congo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "68958e6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Republic(Country):\n",
    "    system = 'Republic system' # Змінили атрибут классу\n",
    "    test_new_attr = 'New value'\n",
    "\n",
    "class Federation(Country):\n",
    "    system = 'Federation system' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e5ec79ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "germany = Federation('Germany', 80_000_000)\n",
    "korea = Republic('Korea', 50_000_000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "68e22976",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Germany:  Federation system Name: Germany\n",
      "Korea:  Republic system Name: Korea\n"
     ]
    }
   ],
   "source": [
    "print('Germany: ', germany.system, 'Name:', germany.name)\n",
    "print('Korea: ', korea.system, 'Name:', korea.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "677153d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Republic at 0x10e258760>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "korea"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6cdfd5d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'make_declaration', 'name', 'population', 'system', 'test_new_attr']\n"
     ]
    }
   ],
   "source": [
    "print(dir(korea))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "b3c0133b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Federation'>\n"
     ]
    }
   ],
   "source": [
    "print(type(germany))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "87561a2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Питання, що поверне?\n",
    "#print(isinstance(germany, Federation))\n",
    "#print(isinstance(germany, Republic))\n",
    "#print(isinstance(germany, Country))\n",
    "print(isinstance(germany, object))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc6f7617",
   "metadata": {},
   "source": [
    "### Extending functionality of a parent class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ac05881e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Empire(Country):\n",
    "    # system = 'Empire system'\n",
    "    def __init__(self, name, population, lifetime):\n",
    "        super().__init__(name, population)\n",
    "        self.lifetime = lifetime\n",
    "    \n",
    "    def fail(self):\n",
    "        declaration = super().make_declaration('We fail!')\n",
    "        print(declaration)\n",
    "        print('The end')\n",
    "        print('¯7_(ツ)_/¯')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "952db1b6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "8b448328",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Some empire declare: We fail!\n",
      "The end\n",
      "¯7_(ツ)_/¯\n"
     ]
    }
   ],
   "source": [
    "some_empire = Empire('Some empire', 300_000_00, 30)\n",
    "some_empire.fail()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eafbc6cc",
   "metadata": {},
   "source": [
    "## Multiple inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ea96246",
   "metadata": {},
   "outputs": [],
   "source": [
    "class A():\n",
    "    pass\n",
    "\n",
    "class B():\n",
    "    pass\n",
    "\n",
    "class C(A, B):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fe92b11",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "fba4a1cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    pass\n",
    "\n",
    "class B(A):\n",
    "    pass\n",
    "\n",
    "class C(B):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be53188f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "213e0d73",
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    pass\n",
    "\n",
    "class B(A):\n",
    "    pass\n",
    "\n",
    "class C(A):\n",
    "    pass\n",
    "\n",
    "class D(B, C):\n",
    "    pass\n",
    "\n",
    "\n",
    "# mro = [D, B, C, A]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f882e7bc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "65ae1359",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[__main__.D, __main__.B, __main__.C, __main__.A, object]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D.mro()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e84effc",
   "metadata": {},
   "source": [
    "#### Composition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "95d2dc6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Statement:\n",
    "    pass\n",
    "\n",
    "class Law(Statement):\n",
    "    pass\n",
    "\n",
    "class Union:\n",
    "    def __init__(self, creation_date: int, countries: list[Country], law: Law):\n",
    "        self.countries  = countries\n",
    "        self.law = law\n",
    "        self.creation_date = creation_date\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ca0daf9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "4c600542",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Wheel:\n",
    "    pass\n",
    "\n",
    "class Vehicle:\n",
    "    pass\n",
    "\n",
    "class Ship(Vehicle):\n",
    "    pass\n",
    "\n",
    "class Bus(Vehicle):\n",
    "    def __init__(self, wheels: list[Wheel]):\n",
    "        self.wheels = wheels\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "73c3180b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Member number: 1 country.name: Germany\n",
      "Member number: 2 country.name: Spain\n",
      "Created an union on 1956\n"
     ]
    }
   ],
   "source": [
    "spain = Country('Spain', 44_000_000)\n",
    "eu_law = Law()\n",
    "european_union = Union(1956, [germany, spain], eu_law)\n",
    "european_union2 = Union(1956, [germany, spain], eu_law)\n",
    "for i, country in enumerate(european_union.countries):\n",
    "    print(f'Member number: {i+1} country.name: {country.name}')\n",
    "print(f'Created an union on {european_union.creation_date}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4a07a80",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "68618323",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Rectangle vs Square ?\n",
    "\n",
    "class Rectangle:\n",
    "    def __init__(self, length, height):\n",
    "        self._length = length\n",
    "        self._height = height\n",
    "\n",
    "    # @property\n",
    "    def area(self):\n",
    "        return self._length * self._height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "d720f53c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Square(Rectangle):\n",
    "    def __init__(self, side_size):\n",
    "        super().__init__(side_size, side_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "1a13a15a",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = Square(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "62022258",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "print(s.area())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "2135f93e",
   "metadata": {},
   "outputs": [],
   "source": [
    "rectangle = Rectangle(2, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "6ed16c7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert rectangle.area() == 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "c5942f95",
   "metadata": {},
   "outputs": [],
   "source": [
    "square = Square(2)\n",
    "assert square.area() == 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e637a56",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "f78c9df7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, length, height):\n",
    "        self._length = length\n",
    "        self._height = height\n",
    "\n",
    "    @property\n",
    "    def area(self):\n",
    "        return self._length * self._height\n",
    "    \n",
    "    # Додаємо resize \n",
    "    def resize(self, new_length, new_height):\n",
    "        self._length = new_length\n",
    "        self._height = new_height\n",
    "        \n",
    "\n",
    "class Square(Rectangle):\n",
    "    def __init__(self, side_size):\n",
    "        super().__init__(side_size, side_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "19de64c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "rectangle = Rectangle(2, 4)\n",
    "\n",
    "rectangle.resize(3, 5)\n",
    "print(rectangle.area == 15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "e4c8c9ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Square area: 15\n"
     ]
    }
   ],
   "source": [
    "square = Square(2) # Проблема\n",
    "square.resize(3, 5)\n",
    "print(f'Square area: {square.area}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "300d8958",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Змінити \n",
    "class Square:\n",
    "    def __init__(self, length):\n",
    "        self._length = length\n",
    "\n",
    "    @property\n",
    "    def area(self):\n",
    "        return self._length * self._length\n",
    "    \n",
    "        \n",
    "class Rectangle(Square):\n",
    "    def __init__(self, length, weight):\n",
    "        super().__init__(length)\n",
    "        self.weight = weight\n",
    "        \n",
    "  #  @property \n",
    "  #  def area(self):\n",
    "   # return self.length * self.weight\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "4d0789e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "square = Square(2)\n",
    "print(square.area)\n",
    "res = Rectangle(3, 5)\n",
    "# print(res.area())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3ce15fc",
   "metadata": {},
   "source": [
    "1. Liskov principle is a principle that states that if S is a subtype of T, then objects of type T can be replaced with objects of type S without altering the correctness of the program. \n",
    "\n",
    "After that, we should evaluate the following principles:\n",
    "\n",
    "**Evaluate B is an A:** Think about this relationship and justify it. Does it make sense?\n",
    "\n",
    "**Evaluate A is a B:** Reverse the relationship and justify it. Does it also make sense?\n",
    "\n",
    "If you can justify both relationships, then you should never inherit those classes from one another.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "ae7ae54a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Mark:\n",
    "    pass\n",
    "\n",
    "class Student:\n",
    "    def __init__(self, marks: list[Mark]) -> None:\n",
    "        self.marks = marks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f3d1505",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "519a48e1",
   "metadata": {},
   "source": [
    "## Practice\n",
    "\n",
    "1. Write a Python class named Circle constructed by a radius and two methods which will compute the area and the perimeter of a circle.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1f655db1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28.26\n",
      "18.84\n"
     ]
    }
   ],
   "source": [
    "class Circle:\n",
    "    PI = 3.14\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "    def get_area(self):\n",
    "        return Circle.PI * self.radius ** 2\n",
    "    def get_perimeter(self):\n",
    "        return Circle.PI * 2 * self.radius\n",
    "\n",
    "c = Circle(3)\n",
    "\n",
    "print(c.get_area())\n",
    "print(c.get_perimeter())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e15bdff4",
   "metadata": {},
   "source": [
    "2. Write a Python program to crate two empty classes, Student and Marks. Now create some instances and check whether they are instances of the said classes or not. Also, check whether the said classes are subclasses of the built-in object class or not.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7f714824",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    pass\n",
    "\n",
    "class Marks:\n",
    "    pass\n",
    "\n",
    "s, m = Student(), Marks()\n",
    "\n",
    "print(isinstance(s, Student))\n",
    "print(isinstance(m, Marks))\n",
    "print(issubclass(Student, object))\n",
    "print(issubclass(Marks, object))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d54666af",
   "metadata": {},
   "source": [
    "3. A Bank\n",
    "    1. Using the Account class as a base class, write two derived classes called SavingsAccount and CurrentAccount. A SavingsAccount object, in addition to the attributes of an Account object, should have an interest attribute and a method which adds interest to the account. A CurrentAccount object, in addition to the attributes of an Account object, should have an overdraft limit attribute.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "96f7160d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "15\n",
      "12\n",
      "Initial balance is 100, overdraft limit is 10\n",
      "Your balance now is 85\n",
      "85\n",
      "Your balance now is -5\n",
      "-5\n",
      "100\n",
      "105.0\n"
     ]
    }
   ],
   "source": [
    "class Account:\n",
    "    def __init__(self, initial_balance):\n",
    "        self.balance = initial_balance\n",
    "    def add_funds(self, amt):\n",
    "        self.balance += amt\n",
    "    def withdraw(self, amt):\n",
    "        if amt > self.balance:\n",
    "            self.add_funds(-self.balance)\n",
    "            print(f'You have withdrawn all your money: {self.balance}')\n",
    "        else:\n",
    "            self.add_funds(-amt)\n",
    "\n",
    "class SavingAccount(Account):\n",
    "    def __init__(self, initial_balance, interest_rate: float):\n",
    "        '''interest_rate: fraction, not percents'''\n",
    "        super().__init__(initial_balance)\n",
    "        self.interest_rate = interest_rate\n",
    "    def add_interests(self):\n",
    "        self.balance = self.balance * (1 + self.interest_rate)\n",
    "\n",
    "class CurrentAccount(Account):\n",
    "    def __init__(self, initial_balance, overdraft_limit):\n",
    "        super().__init__(initial_balance)\n",
    "        self.overdraft_limit = overdraft_limit\n",
    "        self.overdraft = 0\n",
    "    def withdraw(self, amt):\n",
    "        balance_total = self.balance + self.overdraft_limit\n",
    "        \n",
    "        # exceed limitation\n",
    "        if amt >= balance_total:\n",
    "            self.add_funds(-balance_total)\n",
    "            self.overdraft_limit = self.overdraft_limit\n",
    "            self.balance = -self.overdraft_limit\n",
    "            print(f\"You've reached your overdraft limit of {self.overdraft_limit}. Your balance after this withdrawal is {self.balance}\")\n",
    "        \n",
    "        # within the limit\n",
    "        else:\n",
    "            self.add_funds(-amt)\n",
    "            print(f\"Your balance now is {self.balance}\")\n",
    "\n",
    "\n",
    "acc = Account(10)\n",
    "print(acc.balance)\n",
    "acc.add_funds(5)\n",
    "print(acc.balance)\n",
    "acc.withdraw(3)\n",
    "print(acc.balance)\n",
    "\n",
    "\n",
    "ca = CurrentAccount(100, 10)\n",
    "print(f\"Initial balance is {ca.balance}, overdraft limit is {ca.overdraft_limit}\")\n",
    "\n",
    "ca.withdraw(15)\n",
    "print(ca.balance)\n",
    "\n",
    "ca.withdraw(90)\n",
    "print(ca.balance)\n",
    "\n",
    "sa = SavingAccount(100, 0.05)\n",
    "print(sa.balance)\n",
    "sa.add_interests()\n",
    "print(sa.balance)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd32ab9a",
   "metadata": {},
   "source": [
    "\n",
    "    2. Now create a Bank class, an object of which contains an array of Account objects. Accounts in the array could be instances of the Account class, the SavingsAccount class, or the CurrentAccount class. Create some test accounts (some of each type).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a38206dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<__main__.CurrentAccount at 0x1c0fbc963d0>,\n",
       " <__main__.SavingAccount at 0x1c0fc1b48d0>]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Нижче два варіанти реалізації виходячи із неоднозначності поставленої задачі.\n",
    "# Варіант 1 - мені здається, що саме цей варіант мався на увазі.\n",
    "# прошу підтвердити або спростувати мені в повідомленнях або коментарях до завдання на Notion\n",
    "\n",
    "class Bank:\n",
    "    list_of_accounts = []\n",
    "    def __init__(self, account):\n",
    "        Bank.list_of_accounts.append(account)\n",
    "\n",
    "\n",
    "Bank(ca)\n",
    "Bank(sa)\n",
    "\n",
    "Bank.list_of_accounts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "e28bb367",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<__main__.CurrentAccount at 0x1c0fbc963d0>,\n",
       " <__main__.SavingAccount at 0x1c0fc1b48d0>]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Варіант 2\n",
    "\n",
    "class Bank:\n",
    "    def __init__(self, list_of_accounts: list):\n",
    "        self.list_of_accounts = list_of_accounts\n",
    "    def add_account(self, account):\n",
    "        self.list_of_accounts.append(account)\n",
    "\n",
    "bank = Bank([])\n",
    "bank.add_account(ca)\n",
    "bank.add_account(sa)\n",
    "\n",
    "bank.list_of_accounts"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6af492b3",
   "metadata": {},
   "source": [
    "\n",
    "    3. Write an update method in the Bank class. It iterates through each account, updating it in the following ways: Savings accounts get interest added (via the method you already wrote); CurrentAccounts get a letter sent if they are in overdraft. (use print to 'send' the letter).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "09af290e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your balance is -5, please refill to prevent closing of the account\n",
      "Interests added for account <__main__.SavingAccount object at 0x000001C0FC1B48D0>, the balance is 121.55062500000001\n"
     ]
    }
   ],
   "source": [
    "class Bank:\n",
    "    list_of_accounts = []\n",
    "    def __init__(self, account):\n",
    "        Bank.list_of_accounts.append(account)\n",
    "    \n",
    "    @classmethod\n",
    "    def update(cls):\n",
    "        for acc in cls.list_of_accounts:\n",
    "            if isinstance(acc, SavingAccount):\n",
    "                acc.add_interests()\n",
    "                print(f'Interests added for account {acc}, the balance is {acc.balance}')\n",
    "            if isinstance(acc, CurrentAccount):\n",
    "                if acc.balance < 0:\n",
    "                    print(f'Your balance is {acc.balance}, please refill to prevent closing of the account')\n",
    "\n",
    "Bank(ca)\n",
    "Bank(sa)\n",
    "\n",
    "# Bank.list_of_accounts\n",
    "\n",
    "Bank.update()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d23223e7",
   "metadata": {},
   "source": [
    "\n",
    "    4. The Bank class requires methods for opening and closing accounts, and for paying a dividend into each account."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a9df4f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Account:\n",
    "    def __init__(self, balance, account_number):\n",
    "        self._balance = balance\n",
    "        self._account_number = account_number\n",
    "    \n",
    "    @classmethod\n",
    "    def create_account(cls, account_number):\n",
    "        return cls(0.0, account_number)\n",
    "    \n",
    "    def deposit(self, amount):\n",
    "        if amount > 0:\n",
    "            self._balance += amount\n",
    "        else:\n",
    "            raise ValueError('Amount must be positive')\n",
    "\n",
    "    def withdraw(self, amount):\n",
    "        if amount > 0:\n",
    "            self._balance -= amount\n",
    "        else:\n",
    "            raise ValueError('Amount must be positive')\n",
    "\n",
    "    def get_balance(self):\n",
    "        return self._balance\n",
    "    \n",
    "    def get_account_number(self):\n",
    "        return self._account_number\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'Account number: {self._account_number}, balance: {self._balance}'\n"
   ]
  }
 ],
 "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.11.0"
  },
  "vscode": {
   "interpreter": {
    "hash": "c261aea317cc0286b3b3261fbba9abdec21eaa57589985bb7a274bf54d6cc0a7"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}