python-oop-tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python OOP Tutorial\n",
    "\n",
    "Altran. June 2020.\n",
    "\n",
    "_Created by Miguel Blanco Marcos_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Table of Contents:\n",
    "\n",
    " 1. Object Oriented Programming\n",
    " 2. Introduction to Classes in Python\n",
    "   - Attributes\n",
    "   - Methods\n",
    " 3. Dunder Methods\n",
    "   - Operator Overloading\n",
    " 4. Decorators\n",
    " 5. Inheritance\n",
    "   - Multiple Inheritance\n",
    " 6. Excercises\n",
    " 7. Additional Resources\n",
    " \n",
    " \n",
    " ## 1. Object Oriented Programming\n",
    "\n",
    " * Object Oriented Programming (OOP) is a programming paradigm in which programs are desgined by making use of objects which interact with each other\n",
    "\n",
    " * Objects are composed of:\n",
    "   * *Attributes* (*fields*, *data*, *properties*): variables within the object for storing information\n",
    "   * *Methods* (*functions*, *subroutines*, *procedures*): functions within the object for manipulating internal or external data\n",
    " \n",
    " * We define objects through classes. Each object is an *instance* of a particular class\n",
    " \n",
    " * OOP focuses on creating easily reusable code. DRY: Don't Repeat Yourself\n",
    " \n",
    " \n",
    " ## 2. Introduction to Classes in Python\n",
    "\n",
    " * In Python, we define *classes*. \n",
    " * An object in Python is an *instance* of a class. \n",
    " * Each object can have *attributes* and *methods*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Define a class\n",
    "class Vector:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Vector object at 0x0000017A92F99708>\n",
      "<class '__main__.Vector'>\n"
     ]
    }
   ],
   "source": [
    "# Create an object by instantiating the class\n",
    "v = Vector()\n",
    "\n",
    "# Let's look at the object and its class\n",
    "print(v)\n",
    "print(type(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Attributes\n",
    "\n",
    "Attributes are the data storage inside the classes.\n",
    "\n",
    " * **Class Attributes**: the same for every instance of the class. \n",
    "   * Should not be accessed or modified outside of the class.\n",
    "   * Accessible from every instance of the class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cartesian\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "class Vector:\n",
    "    system = \"Cartesian\"\n",
    "    dimensions = 2\n",
    "    \n",
    "v = Vector()  # Instantiation of Vector class\n",
    "print(v.system)\n",
    "print(v.dimensions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    " * **Instance Attributes**: different for each instance of the class. \n",
    "   * In Python, we use the `self` keyword for creating and referencing them within the class definition.\n",
    "   * They can be created at instantiation, or later.\n",
    "   * They can be modified and deleted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The vector v points to (2, 3).\n",
      "The vector w points to (-1, 6).\n"
     ]
    }
   ],
   "source": [
    "class Vector:\n",
    "    system = \"Cartesian\"\n",
    "    dimensions = 2\n",
    "    \n",
    "    def __init__(self, x, y):  # This function is called at instantiation of the class\n",
    "        self.x = x  # This defines an instance attribute. `self` is how the object refers to itself\n",
    "        self.y = y\n",
    "        \n",
    "v = Vector(2, 3)  # Instantiation of Vector class\n",
    "w = Vector(-1, 6)\n",
    "\n",
    "print(f\"The vector v points to ({v.x}, {v.y}).\")\n",
    "print(f\"The vector w points to ({w.x}, {w.y}).\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# The value of instance attributes can be modified\n",
    "print(v.x)\n",
    "v.x = 4\n",
    "print(v.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Methods\n",
    "\n",
    " * Methods are functions belonging to the class \n",
    " * They process data internal and/or external to the object\n",
    " * They can modify internal attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The vector v points to (2, 3).\n",
      "The angle with the x axis is 0.9828 rads\n",
      "The vector v points to (6, -2).\n"
     ]
    }
   ],
   "source": [
    "from math import atan\n",
    "\n",
    "class Vector:\n",
    "    system = \"Cartesian\"\n",
    "    dimensions = 2\n",
    "    \n",
    "    def __init__(self, x, y):  # Init is actually a special kind of method\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def displace_by(self, dx, dy): # This method takes in external data and madifies attributes\n",
    "        self.x += dx\n",
    "        self.y += dy\n",
    "    \n",
    "    def angle_with_axis(self):  # This method does not take external data, and does not modify attributes\n",
    "        return atan(self.y / self.x)\n",
    "        \n",
    "v = Vector(2, 3)\n",
    "print(f\"The vector v points to ({v.x}, {v.y}).\")\n",
    "\n",
    "# Note that the `self` argument in the displace_by method is v, and is skipped inside the parenthesis\n",
    "print(f\"The angle with the x axis is {v.angle_with_axis():.4} rads\")  \n",
    "\n",
    "v.displace_by(4, -5)  \n",
    "print(f\"The vector v points to ({v.x}, {v.y}).\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 3. Dunder Methods\n",
    "\n",
    " * *Dunder* (\"Double Underscores\") methods are special predefined methods\n",
    " * They are used to emulate the behaviour of the predefined types in your classes\n",
    " * They are not meant to be called directly in the code\n",
    " * Some common dunder methods:\n",
    "   * `__init__`: used when instantiating a class\n",
    "   * `__len__`: called when using the len() function\n",
    "   * `__str__`: nice string representation obtained with str()\n",
    "   * `__getitem__`: for getting components with `object[i]`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "class Vector:\n",
    "    system = \"Cartesian\"\n",
    "    dimensions = 2\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def __str__(self):  # We must return a string type\n",
    "        return f\"({self.x}, {self.y})\"\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.dimensions  # Access class attribute\n",
    "    \n",
    "    def displace_by(self, dx, dy):\n",
    "        self.x += dx\n",
    "        self.y += dy\n",
    "    \n",
    "    def angle_with_axis(self):\n",
    "        return math.atan(self.y / self.x)\n",
    "    \n",
    "v = Vector(2, 3)\n",
    "print(v)\n",
    "print(len(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Operator Overloading\n",
    "\n",
    " * In Python, operators (`+`, `**`, `/`, etc.) have multiple meanings depending on context\n",
    " * By default, operators do not work with user defined classes\n",
    " * We can define a custom behaviour for them through *operator overloading*\n",
    " * This is done with special dunder methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    system = \"Cartesian\"\n",
    "    dimensions = 2\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def __str__(self):\n",
    "        return f\"({self.x}, {self.y})\"\n",
    "    \n",
    "    def __add__(self, other):  # Takes 2 and only 2 arguments\n",
    "        x = self.x + other.x\n",
    "        y = self.y + other.y\n",
    "        return Vector(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 9)\n"
     ]
    }
   ],
   "source": [
    "v = Vector(2, 3)\n",
    "w = Vector(-1, 6)\n",
    "print(v + w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    system = \"Cartesian\"\n",
    "    dimensions = 2\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def __str__(self):\n",
    "        return f\"({self.x}, {self.y})\"\n",
    "    \n",
    "    def  __mul__(self, other):\n",
    "        scalar_prod = self.x * other.x + self.y * other.y\n",
    "        return scalar_prod  # External operation: returns an object not of the original class\n",
    "    \n",
    "    def  __neg__(self):  # Takes only one argument\n",
    "        x = -self.x\n",
    "        y = -self.y\n",
    "        return Vector(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-16\n"
     ]
    }
   ],
   "source": [
    "v = Vector(2, 3)\n",
    "w = Vector(-1, 6)\n",
    "print(-v * w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 4. Decorators\n",
    "\n",
    " * Decorators are functions \n",
    " * They wrap over another function and add functionality to it\n",
    " * There are some predefined decorators used in classes:\n",
    "   * `@property`: customize how to *get*, *set* and *delete* an attribute\n",
    "   * `@classmethod`: is not connected to the instance, only the class, and can modify its attributes\n",
    "   * `@staticmethod`: cannot access instance or class, is just an utility function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    system = \"Cartesian\"\n",
    "    dimensions = 2\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        self._magnitude = (self.x**2 + self.y**2)**0.5  # This attribute is private\n",
    "        \n",
    "    def __str__(self):  # We must return a string type\n",
    "        return f\"({self.x}, {self.y})\"\n",
    "    \n",
    "    @property\n",
    "    def magnitude(self):\n",
    "        return self._magnitude  # The getter for magnitude just returns the private value\n",
    "    \n",
    "    @magnitude.setter\n",
    "    def magnitude(self, value):  # The setter checks validity and modifies other attributes\n",
    "        assert value >= 0\n",
    "        self.x = self.x * value / self._magnitude\n",
    "        self.y = self.y * value / self._magnitude\n",
    "        self._magnitude = value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n",
      "(8.0, 6.0)\n"
     ]
    }
   ],
   "source": [
    "v = Vector(4, 3)\n",
    "print(v.magnitude)  # No parentheses or underscore!\n",
    "\n",
    "v.magnitude = 10\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 5. Inheritance\n",
    "\n",
    " * We can define a class as the 'child' of another class\n",
    " * The child will inherit all the functionality from the parent\n",
    " * Then, we can add additional funcionality to the child \n",
    " * We can also modify the inherited functionality by overriding it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# The parent class\n",
    "class Vector:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"({self.x}, {self.y})\"\n",
    "\n",
    "# The child class\n",
    "class Versor(Vector):  # Versor is a child of Vector\n",
    "    def __init__(self, x, y):  # Versor overrides Vector`s __init__ method\n",
    "        m = (x**2 + y**2)**0.5\n",
    "        super().__init__(x/m, y/m)  # super() returns the parent class and can gives access to the original methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0.6, 0.8)\n"
     ]
    }
   ],
   "source": [
    "v = Versor(3, 4)\n",
    "print(v)  # Versor has inherited __str__ from Vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    " * It is possible to inherit from built-in types (e.g., `int` or `dict`)\n",
    " * In fact, all objects in python, including functions, inherit from the `object` class\n",
    " * A child class can be the parent of a different class, chaining inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(isinstance(v, Versor))\n",
    "print(isinstance(v, Vector))\n",
    "print(isinstance(v, object))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Multiple Inheritance\n",
    "\n",
    " * A class can inherit from more than one parent\n",
    " * They inherit methods and attributes from all parents\n",
    " * Conflicts are solved through the *Method Resolution Order (MRO)*\n",
    "   * Basically, the order in which the parents are named\n",
    "   * This order can be checked by calling the `.mro()` method on the class (not instances of it!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello there!\n",
      "Bye!\n"
     ]
    }
   ],
   "source": [
    "class Parent1:\n",
    "    def say_hello(self):\n",
    "        print(\"Hello there!\")\n",
    "        \n",
    "class Parent2:\n",
    "    def say_hello(self):\n",
    "        print(\"Good morning!\")\n",
    "        \n",
    "    def say_goodbye(self):\n",
    "        print(\"Bye!\")\n",
    "\n",
    "class Child(Parent1, Parent2):  # Parent1 methods will override Parent2\n",
    "    pass\n",
    "\n",
    "c = Child()\n",
    "c.say_hello()    # Parent1 overrides the method from Parent2\n",
    "c.say_goodbye()  # This is inherited from Parent2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[__main__.Child, __main__.Parent1, __main__.Parent2, object]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Child.mro()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 6. Exercises\n",
    "\n",
    " 1. Implement the `Die` class (*dado* in spanish):\n",
    "    * It has a `sides` instance attribute which contains the number of sides. It must be defined at instantiation\n",
    "    * It has a `throw` method which returns (not print) a random number in the range $[1, sides]$, inclusive\n",
    "    * It has a `throw_n_times` method with argument `n` which returns a list of length `n` with results from throwing the die. Use the `throw` method within this other method to implement it.\n",
    "    * It has a `__repr__` method which returns a string: $D4$, $D6$... depending on the number of sides\n",
    "    * Test the class by creating an instance and using both methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# Hint\n",
    "from random import randint\n",
    "print(randint(3, 6))  # Prints random integer between in the range [3, 6] (INCLUSIVE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 1. Write your code here! if you need more cells use Inser -> Insert Cell Below"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 2. Implement the `Rectangle` class:\n",
    "    * It has the `width` and `height` attributes\n",
    "    * It has a `@property` called `area` that returns the area of the rectangle\n",
    "    * It has a `__repr__` method. You decide what to return here\n",
    " \n",
    " \n",
    " 3. Implement the `Square` class as a child of `Rectangle`:\n",
    "    * Override the `__init__` method so that it only takes one argument instead of 2\n",
    "    * Do not override or rewrite the `area` property from `Rectangle`, but make sure that it still works properly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2. Write your code here! if you need more cells use Inser -> Insert Cell Below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 3. Write your code here! if you need more cells use Inser -> Insert Cell Below"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 7. Additional Resources\n",
    "\n",
    " * Official documentation on Python classes: https://docs.python.org/3/tutorial/classes.html\n",
    " * Brief but comprehensive tutorials on Python OOP: https://www.programiz.com/python-programming/object-oriented-programming\n",
    " * Another great tutorial: https://realpython.com/python3-object-oriented-programming/\n",
    " * YouTube playlist: https://www.youtube.com/watch?v=ZDa-Z5JzLYM&list=PL-osiE80TeTsqhIuOqKhwlXsIBIdSeYtc"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}