04_python/python_oop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Object Oriented Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Key points of the previous lectures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Study [the Pascal's triangle](https://en.wikipedia.org/wiki/Pascal%27s_triangle). Let's write a function that generates the Pascal's triangle.  \n",
    "Note, we extend the notation by adding the types of the arguments and the return value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def PascalsTriangleRow(n: int) -> list[int]:\n",
    "    \"\"\"Returns a list with the n-th row of Pascal's triangle. For negative n, returns an empty list.\"\"\"\n",
    "    \n",
    "    if n < 0:                       # for n < 0:\n",
    "        return []                   #   empty list, no values\n",
    "        #raise ValueError(\"n<0???\") #   or we could raise an exception\n",
    "    \n",
    "    vs: list[int] = []              # here we will build the output row\n",
    "    for r in range(0, n + 1):       # repeat 0..n (inclusive n):\n",
    "        for c in range(1, r):       #   to each element (except the last)\n",
    "            vs[c-1] += vs[c]        #     add the value of the next element\n",
    "        vs.insert(0,1)              # insert 1 at the beginning\n",
    "\n",
    "    return vs\n",
    "\n",
    "for n in range(-1, 10):\n",
    "    print(f\"{n}\\t{PascalsTriangleRow(n)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encapsulation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's consider a motor of a car.  \n",
    "It is a very complex system that has many parts and functions.  \n",
    "But from the point of view of a driver, it is a simple object that has some attributes (e.g. type of fuel, number of cylinders) and some methods (like start, stop, accelerate, etc). \n",
    "\n",
    "This is the idea behind Object Oriented Programming (OOP). \n",
    "We can create classes that represent objects in the real world and define their attributes and methods.  \n",
    "We can hide the complexity of the object and provide a simple interface to interact with it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes and Objects\n",
    "\n",
    "Let's study the following example relationships:\n",
    "\n",
    "- A **class** `Human` represents a human being.  \n",
    "    **Objects** (**instances**) of this class can be created to represent individual humans: `Alice`, `Bob`, `Charlie`, etc.\n",
    "- A **class** `Car` represents a car.  \n",
    "    **Objects** of this class can be created to represent individual cars: `car1`, `carOfAlice`, `secondCarOfAlice`, etc.\n",
    "- There is a **class** `List` that represents a list of elements.  \n",
    "    You have already created many **instances** of this class: `[]`, `[1, 2, 3]`, etc.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Attributes\n",
    "\n",
    "Instance attributes are the properties of an object. They are individual for each object and represent its state. For example:\n",
    "- A `Human` class can operate on the following attributes: `name`, `age`, `gender`, `height`, `weight`, `eyeColor`, etc.  \n",
    "    Each instance of the `Human` class will have its own values for these attributes.\n",
    "- A `Car` class can operate on the following attributes: `brand`, `model`, `year`, `color`, `fuelType`, `currentOdometer`, etc.  \n",
    "    Each object of the `Car` class will have its own values for these attributes.\n",
    "- A `List` class usually has an attribute `elements` that stores the elements of the list.  \n",
    "    Each instance of the `List` class will have its own list of elements.\n",
    "\n",
    "In Python, instance attributes are set in the **constructor** `__init__(self, ...)`.  \n",
    "The **object/instance** is the first argument to the constructor, named `self`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Methods are functions that operate on the object. They can change the state of the object or return some information about it. For example:\n",
    "- A `Human` class can have methods like `eat()`, `sleep()`, `work()`, `study()`, etc. which change the `self.state` attribute of the `self` human.  \n",
    "    A method `getBMI()` can return the Body Mass Index of the human based on the `self.weight` and `self.height` attributes.\n",
    "- A `Car` class can have methods like `start()`, `stop()`, `accelerate()`, `brake()`, etc. which change the `self.enginePower` attribute of the `self` car.  \n",
    "    A method `estimateRemainingKM()` can return the estimated number of kilometers the car can drive based on attributes tracking remaining fuel and typical fuel consumption.\n",
    "- A `List` class can have methods like `append()`, `pop()`, `sort()`, `reverse()`, etc. which change the `self.elements` attribute of the `self` list.  \n",
    "    A method `getLength()` can return the number of elements in the list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple lamp class (concept)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's assume that we have a remotely controlled lamp.  \n",
    "The code which turns the lamp on or off can be possibly complex (e.g. sending some messages through WiFi).  \n",
    "We want to hide this complexity and provide a simple interface.  \n",
    "We want the user to be able to turn the lamp on or off by calling a simple method.  \n",
    "Also, the user should be able to check if the lamp is on or off. Here is how we would like a user to interact with the lamp:\n",
    "\n",
    "```python\n",
    "lamp = SimpleLamp( \"Kitchen\" )    # create (construct) a lamp object, give it a name\n",
    "\n",
    "lamp.turnOn()                     # call a class method to turn the lamp on\n",
    "# ... (some time later)\n",
    "lamp.turnOff()                    # call a class method to turn the lamp off\n",
    "\n",
    "# ...\n",
    "# ... (more random on/off operations)\n",
    "# ...\n",
    "\n",
    "if lamp.isOn():                   # call a class method to check if the lamp is on\n",
    "    print(\"The lamp is on\")\n",
    "else:\n",
    "    print(\"The lamp is off\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's consider a more complex use case. We have several lamps in the house and we want to control them all:\n",
    "\n",
    "```python\n",
    "lamps = [ SimpleLamp(\"Kitchen\"), SimpleLamp(\"Living room\"), SimpleLamp(\"Bedroom\") ]\n",
    "\n",
    "for lamp in lamps:                   # iterate over all lamps\n",
    "    lamp.turnOn()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple lamp class (implementation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define the `SimpleLamp` class, step by step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleLamp:\n",
    "    def __init__(self, name):            # constructor, \"self\" is the object being created, \"name\" is the argument given by the user\n",
    "        self.name = name                 # instance attribute \"self.name\", set to the value of the argument \"name\"\n",
    "        self.isOn = False                # instance attribute \"self.isOn\", always set to False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above code defines a class `SimpleLamp`. So far, it has only one method `__init__` which is the constructor.  \n",
    "The constructor sets the `self.name` attribute of the object to the value of the `name` argument.  \n",
    "Although the class is very simple, it is already possible to create objects of this class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lamp = SimpleLamp(name=\"Desk Lamp\")      # creates a new SimpleLamp object with the name \"Desk Lamp\"\n",
    "print(lamp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When printed, the object is represented by the class name and the memory address of the object.  \n",
    "Often, we want to provide a more informative representation of the object.  \n",
    "Let's add the `__str__` method to the class. This method should return a string representation of the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleLamp:                        # we redefine the class, the above definition is overwritten\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.isOn = False\n",
    "    \n",
    "    def __str__(self):                   # special method __str__ to return a string representation of the object\n",
    "        return f\"{self.name} is {'on' if self.isOn else 'off'}\"\n",
    "\n",
    "lamp = SimpleLamp(name=\"Desk Lamp\")\n",
    "print(lamp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now add the `turnOn` and `turnOff` methods to the class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleLamp:                        # we redefine the class, the above definition is overwritten\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.isOn = False\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"{self.name} is {'on' if self.isOn else 'off'}\"\n",
    "\n",
    "    def turnOn(self):                    # method to turn the lamp on\n",
    "        self.isOn = True\n",
    "    \n",
    "    def turnOff(self):                   # method to turn the lamp off\n",
    "        self.isOn = False\n",
    "    \n",
    "lamp = SimpleLamp(name=\"Desk Lamp\")\n",
    "print(lamp)\n",
    "lamp.turnOn()\n",
    "print(lamp)\n",
    "lamp.turnOff()\n",
    "print(lamp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To check if the lamp is on or off, we can add the `isOn()` method.  \n",
    "But note, that the `self.isOn` attribute has the same name as the method. This is suboptimal.  \n",
    "Therefore, it is advisable to rename the attributes like: `self._isOn`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleLamp:                        # we redefine the class, the above definition is overwritten\n",
    "    def __init__(self, name):\n",
    "        self._name = name                # _abc attributes are intended to be private\n",
    "        self._isOn = False               # use them only inside the class, don't access from outside\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"{self._name} is {'on' if self._isOn else 'off'}\"\n",
    "\n",
    "    def turnOn(self):\n",
    "        self._isOn = True\n",
    "    \n",
    "    def turnOff(self):\n",
    "        self._isOn = False\n",
    "    \n",
    "lamp = SimpleLamp(name=\"Desk Lamp\")\n",
    "print(lamp)\n",
    "lamp.turnOn()\n",
    "print(lamp)\n",
    "lamp.turnOff()\n",
    "print(lamp)\n",
    "\n",
    "print(lamp._name)                       # this will work, but it's not recommended\n",
    "print(lamp._isOn)                       # this will work, but it's not recommended"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can add the `isOn()` method to the class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleLamp:                        # we redefine the class, the above definition is overwritten\n",
    "    def __init__(self, name):\n",
    "        self._name = name\n",
    "        self._isOn = False\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"{self._name} is {'on' if self._isOn else 'off'}\"\n",
    "\n",
    "    def turnOn(self):\n",
    "        self._isOn = True\n",
    "    \n",
    "    def turnOff(self):\n",
    "        self._isOn = False\n",
    "    \n",
    "    def isOn(self):                     # method to check if the lamp is on\n",
    "        return self._isOn\n",
    "    \n",
    "lamp = SimpleLamp(name=\"Desk Lamp\")\n",
    "print(lamp.isOn())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A real lamp would usually have a function which would execute the lamp's on/off operation (e.g. sending a message through WiFi).\n",
    "This function would usually be hidden from the user."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleLamp:                        # we redefine the class, the above definition is overwritten\n",
    "    def __init__(self, name):\n",
    "        self._name = name\n",
    "        self._isOn = False\n",
    "        self.__setLampState(on=False)    # call the private method to set the lamp state\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"{self._name} is {'on' if self._isOn else 'off'}\"\n",
    "\n",
    "    def turnOn(self):\n",
    "        self.__setLampState(on=True)     # (as above)\n",
    "    \n",
    "    def turnOff(self):\n",
    "        self.__setLampState(on=False)    # (as above)\n",
    "    \n",
    "    def isOn(self):\n",
    "        return self._isOn\n",
    "\n",
    "    def __setLampState(self, on):\n",
    "        # ...\n",
    "        # some complex code here (e.g. interfacing with a physical lamp)\n",
    "        # ...\n",
    "        print( f\">>> Sending '{'on' if on else 'off'}' to the lamp! >>>\" )\n",
    "        self._isOn = on\n",
    "    \n",
    "lamp = SimpleLamp(name=\"Desk Lamp\")\n",
    "lamp.turnOn()\n",
    "lamp.turnOff()\n",
    "#lamp.__setLampState(on=True)            # this will not work, as the method is private"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Another lamp class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's design a more complex lamp class. This lamp has regulation of brightness and color.  \n",
    "Still, the user can turn the lamp on or off and check its state.  \n",
    "If the lamp is torn off and then turned on, it should remember the previous brightness and color settings.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ColorBrightnessLamp:\n",
    "    def __init__(self, name, isOn=False, color=\"white\", brightness=100):\n",
    "        self._name = name\n",
    "        self._isOn = False\n",
    "        self._color = None\n",
    "        self._brightness = None\n",
    "        self.__setLampState(on=isOn, color=color, brightness=brightness)\n",
    "    \n",
    "    def __str__(self):\n",
    "        if not self._isOn or self._brightness == 0:\n",
    "            return f\"{self._name} is off\"\n",
    "        else:\n",
    "            return f\"{self._name} is {self._brightness}% brightness of {self._color} color\"\n",
    "\n",
    "    def turnOn(self):\n",
    "        self.__setLampState(on=True, color=self._color, brightness=self._brightness)\n",
    "    \n",
    "    def turnOff(self):\n",
    "        self.__setLampState(on=False, color=self._color, brightness=self._brightness)\n",
    "\n",
    "    def setColorBrightness(self, color=\"white\", brightness=100):\n",
    "        self.__setLampState(on=True, color=color, brightness=brightness)\n",
    "        \n",
    "    def isOn(self):\n",
    "        return self._isOn\n",
    "\n",
    "    def color(self):\n",
    "        return self._color\n",
    "    \n",
    "    def brightness(self):\n",
    "        return self._brightness\n",
    "    \n",
    "    def __setLampState(self, on, color, brightness):\n",
    "        # ...\n",
    "        # some complex code here (e.g. interfacing with a physical lamp)\n",
    "        # ...\n",
    "        print( f\">>> Sending '{'on' if on else 'off'}' to the lamp, color '{color}', brightness '{brightness}'! >>>\" )\n",
    "        self._isOn = on\n",
    "        self._color = color\n",
    "        self._brightness = brightness\n",
    "    \n",
    "lamp = ColorBrightnessLamp(name=\"Party Lamp\", color=\"blue\")\n",
    "print(lamp)\n",
    "lamp.setColorBrightness(color=\"green\", brightness=75)\n",
    "print(lamp)\n",
    "lamp.turnOff()\n",
    "print(lamp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have defined two classes: `SimpleLamp` and `ColorBrightnessLamp`.  \n",
    "We can identify common parts of these classes:\n",
    "- Both classes have a `_name` attribute.\n",
    "- Both classes have `turnOn()`, `turnOff()`, and `isOn()` methods, with the same (no) arguments.\n",
    "\n",
    "These common parts can be extracted to a common **base class** `Lamp`, from which both `SimpleLamp` and `ColorBrightnessLamp` will **inherit**.  \n",
    "The base class `Lamp` conceptually represents any lamp and has the common attributes and methods.\n",
    "\n",
    "Note, that both classes also have the `_isOn` attribute, which also could be extracted to the base class.  \n",
    "On the other side, the private `__setLampState` methods are very specific to each class, have different arguments, and should not be extracted to the base class.\n",
    "\n",
    "Moreover, in this code we will explicitly add types to the arguments and return values of the methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Lamp:                              # base class (abstract, to be subclassed)\n",
    "    def __init__(self, name:str, isOn:bool=False):\n",
    "        self._name = name\n",
    "    \n",
    "    def name(self)->str:\n",
    "        return self._name\n",
    "    \n",
    "    def turnOn(self):\n",
    "        pass                             # does nothing, to be implemented in the subclass\n",
    "    \n",
    "    def turnOff(self):\n",
    "        pass                             # this could also throw an exception, to force the subclass to implement it\n",
    "    \n",
    "    def isOn(self)->bool|None:\n",
    "        return None                      # (as above)\n",
    "        \n",
    "class SimpleLamp(Lamp):                  # subclass of Lamp (inherits from Lamp), derived class\n",
    "    def __init__(self, name:str, isOn:bool=False):\n",
    "        super().__init__(name=name)      # call the constructor of the base class, passing the name argument\n",
    "        self._isOn = None                # unknown yet, __setLampState will set it\n",
    "        self.__setLampState(on=isOn)\n",
    "    \n",
    "    def __str__(self)->str:\n",
    "        return f\"{self._name} is {'on' if self._isOn else 'off'}\"\n",
    "\n",
    "    def turnOn(self):                    # implementation of the abstract method, overrides the base class method\n",
    "        self.__setLampState(on=True)\n",
    "    \n",
    "    def turnOff(self):\n",
    "        self.__setLampState(on=False)\n",
    "    \n",
    "    def isOn(self)->bool|None:\n",
    "        return self._isOn\n",
    "\n",
    "    def __setLampState(self, on):\n",
    "        # ...\n",
    "        # some complex code here (e.g. interfacing with a physical lamp)\n",
    "        # ...\n",
    "        print( f\">>> {self.name()}: Sending '{'on' if on else 'off'}' to the lamp! >>>\" )\n",
    "        self._isOn = on\n",
    "\n",
    "class ColorBrightnessLamp(Lamp):         # subclass of Lamp (inherits from Lamp), derived class\n",
    "    def __init__(self, name:str, isOn:bool=False, color:str=\"white\", brightness:int=100):\n",
    "        super().__init__(name=name)\n",
    "        self._isOn = None\n",
    "        self._color = None\n",
    "        self._brightness = None\n",
    "        self.__setLampState(on=isOn, color=color, brightness=brightness)\n",
    "    \n",
    "    def __str__(self)->str:\n",
    "        if not self._isOn or self._brightness == 0:\n",
    "            return f\"{self._name} is off\"\n",
    "        else:\n",
    "            return f\"{self._name} is {self._brightness}% brightness of {self._color} color\"\n",
    "\n",
    "    def turnOn(self):\n",
    "        self.__setLampState(on=True, color=self._color, brightness=self._brightness)\n",
    "    \n",
    "    def turnOff(self):\n",
    "        self.__setLampState(on=False, color=self._color, brightness=self._brightness)\n",
    "\n",
    "    def setColorBrightness(self, color=\"white\", brightness=100):\n",
    "        self.__setLampState(on=True, color=color, brightness=brightness)\n",
    "        \n",
    "    def isOn(self)->bool|None:\n",
    "        return self._isOn\n",
    "\n",
    "    def color(self)->int|None:\n",
    "        return self._color\n",
    "    \n",
    "    def brightness(self)->int|None:\n",
    "        return self._brightness\n",
    "    \n",
    "    def __setLampState(self, on, color, brightness):\n",
    "        # ...\n",
    "        # some complex code here (e.g. interfacing with a physical lamp)\n",
    "        # ...\n",
    "        print( f\">>> {self.name()}: Sending '{'on' if on else 'off'}' to the lamp, color '{color}', brightness '{brightness}'! >>>\" )\n",
    "        self._isOn = on\n",
    "        self._color = color\n",
    "        self._brightness = brightness"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create several objects of the derived classes and check their behavior..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lamps:list[Lamp] = [                                 # Create several instances/objects of the derived classes\n",
    "    SimpleLamp(name=\"Desk Lamp\"), \n",
    "    ColorBrightnessLamp(name=\"Party Color Lamp\", color=\"blue\"),\n",
    "    SimpleLamp(name=\"Bedside Lamp\"),\n",
    "    ColorBrightnessLamp(name=\"Reading Color Lamp\", color=\"yellow\", brightness=50)\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can loop over all lamps and turn them all on:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for lamp in lamps:\n",
    "    lamp.turnOn()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or, we can use a comprehension to build a dictionary of lamp states or types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( {l.name():l.isOn() for l in lamps} )\n",
    "print( {l.name():type(l) for l in lamps} )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, with the `isinstance` function, we can check if an object is an instance of a given class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( {l.name():isinstance(l, Lamp) for l in lamps} )\n",
    "print( {l.name():isinstance(l, SimpleLamp) for l in lamps} )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programming-related concepts"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scope of variables"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are variables which exists or are accessible only in a part of a program.  \n",
    "Consider the code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "                             # myMean is a file-global function, it is defined from here till the end of the file\n",
    "def myMean(x):               # x is a local function parameter, it is defined within the function\n",
    "    xSum = sum(x)            # xSum is a local variable, it is defined from here till the end of the function\n",
    "    xLen = len(x)            # xLen is a local variable, it is defined from here till the end of the function\n",
    "    return xSum/xLen\n",
    "\n",
    "vs = [1,2,3]                 # vs is a file-global variable, it is defined here till the end of the file\n",
    "myMean(vs)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note, there are two different variables `x` in the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [\"a\",\"b\",\"c\"]      # x is a file-global variable, different than x in myMean\n",
    "\n",
    "                             # myMean is a file-global function, it is defined from here till the end of the file\n",
    "def myMean(x):               # x is a local function parameter, it is defined within the function\n",
    "    xSum = sum(x)            # xSum is a local variable, it is defined from here till the end of the function\n",
    "    xLen = len(x)            # xLen is a local variable, it is defined from here till the end of the function\n",
    "    return xSum/xLen\n",
    "\n",
    "vs = [1,2,3]                 # vs is a file-global variable, it is defined here till the end of the file\n",
    "myMean(vs)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also here, there are two different variables `x`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [\"a\",\"b\",\"c\"]           # x is a file-global variable\n",
    "y = [1,2,3]\n",
    "y2 = [x**2 for x in y]      # x here is local to comprehension; it is a different variable than the one above\n",
    "print(y2)\n",
    "print(x)                    # x is the same as in the top line"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Self-study tasks"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Grid printing classes (simple inheritance, overriding functions)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code:\n",
    "\n",
    "```python\n",
    "grids = [ XGrid(name=\"Small X\", size=3), Grid(name=\"Nothing\"), XGrid(name=\"Large X\", size=9) ]\n",
    "for g in grids:\n",
    "    g.print()\n",
    "```\n",
    "\n",
    "produces this output:\n",
    "\n",
    "```text\n",
    "Small X:\n",
    "\n",
    "#.#\n",
    ".#.\n",
    "#.#\n",
    "\n",
    "Nothing:\n",
    "\n",
    "\n",
    "Large X:\n",
    "\n",
    "#.......#\n",
    ".#.....#.\n",
    "..#...#..\n",
    "...#.#...\n",
    "....#....\n",
    "...#.#...\n",
    "..#...#..\n",
    ".#.....#.\n",
    "#.......#\n",
    "```\n",
    "\n",
    "*Goal:* Rewrite the `printX` function from the previous lecture as a `print` method of the `XGrid` class.  \n",
    "The `XGrid` class should inherit from `Grid`.\n",
    "\n",
    "Detailed requirements for `Grid`:\n",
    "- `Grid` should be the base class\n",
    "- the constructor of `Grid` should take an argument `name` and store its value in the instance\n",
    "- `Grid` should have a method `print`; for `Grid` it should just print the stored `name`\n",
    "\n",
    "Detailed requirements for `XGrid`:\n",
    "- `XGrid` should inherit from `Grid`\n",
    "- the constructor of `XGrid` should pass the `name` argument to the base class\n",
    "- the constructor of `XGrid` should take another argument `size` specifying number of rows and cols of the X shape\n",
    "- the `print` method of `XGrid` should first call the base `print` method and then it should print the X shape\n",
    "\n",
    "Finally, based on `XGrid` define another class `RectGrid`:\n",
    "- `RectGrid` should inherit from `Grid`\n",
    "- `RectGrid(name=\"A rectangle\", colSize=10, rowSize=5)` should specify the shape\n",
    "- define the `print` method so that it produces a \"rectangle of stars\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix class (encapsulation, incremental code development, lambdas, raising exceptions)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python `list` can be used as a model of a mathematical one-dimensional vector.  \n",
    "Design and implement a class `matrix` which could represent a mathematical two-dimensional matrix.  \n",
    "Here are some ideas and requirements (split your implementation in the suggested phases):\n",
    "\n",
    "- phase 1 (construction and memory allocation):\n",
    "    - `m = Matrix( dims=(r,c) )` should create an instance of the matrix with `r` rows and `c` columns\n",
    "    - a matrix with `r` rows an `c` columns can be stored as a `list` with `r*c` elements (conceptually, columns of the matrix are stacked into one long vector)\n",
    "    - the constructor needs to allocate a list of `r*c` elements and store it in an instance variable (`self._data`)\n",
    "    - after construction all elements of the matrix should be set to `0`\n",
    "    - the `dims` (dimensions) of the matrix need to be stored in an instance variable (`self._dims`)\n",
    "    - the code below for `phase 1` should work now\n",
    "- phase 2 (getting/setting an element):\n",
    "    - `m.set( pos=(r,c), val=v )` should set the matrix `m` element in the row `r`, column `c` to the value `v`\n",
    "    - `m.get( pos=(r,c) )` should return the value of the matrix `m` element in the row `r`, column `c`\n",
    "    - both `set` and `get` need to know how to convert row/column to the index of the `self._data` list\n",
    "    - let's have an internal function `_pos2idx(self, pos)` which performs the above calculation\n",
    "- phase 3 (checking ranges, init value):\n",
    "    - when `pos` is out of range raise `IndexError`; add this to `_pos2idx` function\n",
    "    - the error message should say what is the allowed range (e.g. `column 5 requested but only 0..3 exist in the matrix`)\n",
    "    - the constructor should have a second argument `val` with the default value of `0`; this value should be used to fill the matrix\n",
    "    - `m = Matrix( dims=(3,2), val=1 )` should create an instance of the matrix with 3 rows, 2 columns and all values equal to 1\n",
    "- phase 4 (printing):\n",
    "    - `m.print()` should print the matrix in a user readable form\n",
    "- phase 5 (string representation of the matrix) [ADVANCED]:\n",
    "    - write `__repr__(self)` method which should generate a string with text representation of the matrix\n",
    "    - note the difference: `print(self)` generates the output directly to the console whereas the `__repr__(self)` method should return a string\n",
    "    - check the function `join( sep, list )`; it might be useful in this phase\n",
    "    - implementation proposal (implement lambdas inside `__repr__`):\n",
    "        - the final text is composed by joining with `\"\\n\"` the texts of individual `rows`\n",
    "        - `rows` is created by calling `getRow(r)` for all rows `r`\n",
    "        - `getRow(r)` is a lambda function of `r` (row): it joins with `\", \"` the texts of column elements from the row `r` returned by `getColsOfRow(r)`\n",
    "        - `getColsOfRow(r)` is a lambda function of `r` (row): it returns a list of column elements from the row `r` converted to `str`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the following pieces of code for different phases of implementation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ----- phase 1 -----\n",
    "m = Matrix(dims=(2,3))\n",
    "# m._data                         # this should be a list with 6 zeroes\n",
    "# m._dims                         # this should be (2,3) tuple denoting 2 rows and 3 columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ----- phase 2 -----\n",
    "m = Matrix(dims=(2,3))\n",
    "m.set( pos=(0,0), val=10 )\n",
    "m.set( pos=(1,2), val=20 )\n",
    "# m._data                         # [10, 0, 0, 0, 0, 20] <- 10 and 20 should be there\n",
    "                                  # note, that you may use a different mapping of r,c to list\n",
    "\n",
    "m.get( pos=(1,2) )                # should be 20\n",
    "m.get( pos=(0,1) )                # should be 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ----- phase 3 -----\n",
    "m = Matrix(dims=(3,2))\n",
    "# m.set(pos=(-1,0), val=-1)       # should raise an exception\n",
    "# m.get(pos=[5,5])                # should raise an exception\n",
    "\n",
    "m = Matrix(dims=(3,2), val=10)\n",
    "# m._data                         # should be a vector of 6 values equal to 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ----- phase 4 -----\n",
    "m = Matrix(dims=(2,3), val=\".\")\n",
    "m.set( pos=(0,0), val=\"lu\" ) # left-upper\n",
    "m.set( pos=(0,2), val=\"ru\" ) # right-upper\n",
    "m.set( pos=[1,0], val=\"lb\" ) # left-bottom\n",
    "m.set( [1,2], \"rb\" )         # right-bottom\n",
    "m.print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ----- phase 5 -----\n",
    "print( m )                   # should print:\n",
    "                             # lu, ., ru\n",
    "                             # lb, ., rb\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array (more complex code) [ADVANCED]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note, that in the `Matrix` task the functions `get` and `set` require the position `pos` to be specified as a two-elements tuple instead of two separate arguments `r` and `c`. Consequently, the interface can be easily generalized to multi-dimensional arrays.  \n",
    "\n",
    "Implement a class `Array`, where the `dims` argument describes sizes in 1,2,3,... dimensions.  \n",
    "For example: `m=Array( dims=(2,3,4) )` should be a 3-dimensional array with 2 positions in dimension `0`, 3 positions in dimension `1` and 4 positions in dimension `2` (so, in total, 2*3*4=24 elements). Getting an element would become, for example: `m.get(pos=(0,1,2))`. Printing functions are more difficult to generalize - ideas are welcome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = Array(dims=(2,3,4))\n",
    "m.set( pos=(0,0,1), val=10 )\n",
    "m.set( pos=(1,2,3), val=20 )\n",
    "m.get( pos=(0,0,0) )\n",
    "# m.get( pos=(-1,-1,-1) )           # IndexError\n",
    "# m._data                           # 24 elements, 22 zeroes, one 10, one 20"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "EfDS",
   "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.13.1"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}