07_Polymorphism_in_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# OOP 7: Polymorphism  in Python\n",
    "\n",
    "In this notebook, we'll explore polymorphism in Python. We'll look at how polymorphism allows different classes to be used interchangeably through a common interface, focusing on method overriding and method overloading.\n",
    "\n",
    "## Table of Contents\n",
    "\n",
    "1. [Introduction to Polymorphism](#1)\n",
    "2. [Polymorphism with Inheritance](#2)\n",
    "3. [Polymorphism with Functions](#3)\n",
    "4. [Polymorphism with Abstract Classes](#4)\n",
    "5. [Step-by-Step Example](#5)\n",
    "6. [Exercise: Implementing Polymorphism in a Data Science Context](#6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 1. Introduction to Polymorphism <a id=\"1\"></a>\n",
    "\n",
    "Polymorphism is a concept in object-oriented programming that allows methods to be used in different ways based on the object it is acting upon. It enables objects of different classes to be treated as objects of a common superclass, making code more flexible and reusable. \n",
    "\n",
    "In simple terms:\n",
    "**Polymorphism describes a pattern in object oriented programming in which classes have different functionality while sharing a common interface.**\n",
    "\n",
    "\n",
    "In this example, both `Dog` and `Cat` classes have the `speak` method. The `make_animal_speak` function can handle any object that has a speak method, demonstrating polymorphism."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    def speak(self):\n",
    "        return \"Woof!\"\n",
    "\n",
    "class Cat:\n",
    "    def speak(self):\n",
    "        return \"Meow!\"\n",
    "\n",
    "def make_animal_speak(animal):\n",
    "    print(animal.speak())\n",
    "\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "\n",
    "for animal in (dog, cat):\n",
    "    make_animal_speak(animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 2. Polymorphism with Inheritance <a id=\"2\"></a>\n",
    "\n",
    "Polymorphism often works hand-in-hand with inheritance. When a subclass overrides a method from its superclass, we can use objects of the subclass interchangeably with objects of the superclass.\n",
    "\n",
    "\n",
    "In this example, both `Circle` and `Rectangle` classes inherit from the `Shape` class and override the `area` method. The `print_area` function can handle any object that has an `area` method, demonstrating polymorphism."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Shape:\n",
    "    def area(self):\n",
    "        pass\n",
    "\n",
    "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",
    "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 print_area(shape):\n",
    "    print(f\"The area is {shape.area()}\")\n",
    "\n",
    "circle = Circle(5)\n",
    "rectangle = Rectangle(4, 6)\n",
    "\n",
    "print_area(circle)      # The area is 78.5\n",
    "print_area(rectangle)   # The area is 24"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3. Polymorphism with Functions <a id=\"3\"></a>\n",
    "\n",
    "Polymorphism can also be achieved with functions that take parameters of different types. This allows the same function to operate on different types of objects.\n",
    "\n",
    "In this example, the `add` function can handle integers, strings, and lists, demonstrating polymorphism with functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(x, y):\n",
    "    return x + y\n",
    "\n",
    "print(add(5, 10))           # 15 (int)\n",
    "print(add(\"Hello \", \"World\"))  # Hello World (str)\n",
    "print(add([1, 2], [3, 4]))  # [1, 2, 3, 4] (list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 4. Polymorphism with Abstract Classes <a id=\"4\"></a>\n",
    "\n",
    "Abstract classes provide a common interface for subclasses. Methods in abstract classes are meant to be overridden in subclasses, and the subclasses are expected to implement these methods.\n",
    "\n",
    "In this example, the `Animal` class is an abstract class with an abstract method `speak`. The `Dog` and `Cat` classes inherit from `Animal` and implement the `speak` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Animal(ABC):\n",
    "    @abstractmethod\n",
    "    def speak(self):\n",
    "        pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        return \"Woof!\"\n",
    "\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        return \"Meow!\"\n",
    "\n",
    "def make_animal_speak(animal):\n",
    "    print(animal.speak())\n",
    "\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "\n",
    "make_animal_speak(dog)  # Woof!\n",
    "make_animal_speak(cat)  # Meow!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 5. Step-by-Step Example <a id=\"5\"></a>\n",
    "\n",
    "Let's create a comprehensive example by implementing a class hierarchy for different types of plots in data visualization."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step-by-Step Example\n",
    "\n",
    "In this example, we have a base class `Plot` and three subclasses: `LinePlot`, `ScatterPlot`, and `BarPlot`. Each subclass implements the `draw` method, and the `display_plot` function demonstrates polymorphism by accepting any `Plot` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "class Plot:\n",
    "    \"\"\"\n",
    "    A base class for different types of plots.\n",
    "    \"\"\"\n",
    "    def draw(self):\n",
    "        raise NotImplementedError(\"Subclass must implement abstract method\")\n",
    "\n",
    "class LinePlot(Plot):\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def draw(self):\n",
    "        plt.plot(self.x, self.y)\n",
    "        plt.title('Line Plot')\n",
    "        plt.show()\n",
    "\n",
    "class ScatterPlot(Plot):\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def draw(self):\n",
    "        plt.scatter(self.x, self.y)\n",
    "        plt.title('Scatter Plot')\n",
    "        plt.show()\n",
    "\n",
    "class BarPlot(Plot):\n",
    "    def __init__(self, categories, values):\n",
    "        self.categories = categories\n",
    "        self.values = values\n",
    "    \n",
    "    def draw(self):\n",
    "        plt.bar(self.categories, self.values)\n",
    "        plt.title('Bar Plot')\n",
    "        plt.show()\n",
    "\n",
    "def display_plot(plot):\n",
    "    plot.draw()\n",
    "\n",
    "# Usage\n",
    "x = np.linspace(0, 10, 100)\n",
    "y = np.sin(x)\n",
    "categories = ['A', 'B', 'C']\n",
    "values = [5, 7, 3]\n",
    "\n",
    "line_plot = LinePlot(x, y)\n",
    "scatter_plot = ScatterPlot(x, y)\n",
    "bar_plot = BarPlot(categories, values)\n",
    "\n",
    "display_plot(line_plot)    # Displays Line Plot\n",
    "display_plot(scatter_plot) # Displays Scatter Plot\n",
    "display_plot(bar_plot)     # Displays Bar Plot\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 6. Exercise: Implementing Polymorphism in a Data Science Context <a id=\"6\"></a>\n",
    "\n",
    "In this exercise, you will create a class hierarchy for different types of data preprocessing operations. The base class will be `Preprocessor`, and subclasses will include `Scaler`, `Normalizer`, and `Binarizer`.\n",
    "\n",
    "Specifications:\n",
    "\n",
    "1. `Scaler`: A class that scales data to a specified range.\n",
    "2. `Normalizer`: A class that normalizes data to have a mean of 0 and standard deviation of 1.\n",
    "3. `Binarizer`: A class that binarizes data based on a specified threshold.\n",
    "\n",
    "Each subclass should implement a process method that performs the respective preprocessing operation.\n",
    "\n",
    "Example Usage:\n",
    "\n",
    "```python\n",
    "\n",
    "data = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "scaler = Scaler(data, min_val=0, max_val=1)\n",
    "normalizer = Normalizer(data)\n",
    "binarizer = Binarizer(data, threshold=3)\n",
    "\n",
    "print(scaler.process())      # Scaled data\n",
    "print(normalizer.process())  # Normalized data\n",
    "print(binarizer.process())   # Binarized data\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "# Implement the Preprocessor, Scaler, Normalizer, and Binarizer classes according to the specifications above.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "><details>\n",
    "><summary>Do you need some help?</summary>\n",
    ">Tips:\n",
    ">\n",
    ">1. Make sure to follow best practices for defining subclasses and using polymorphism.\n",
    ">2. Test each method to ensure it behaves as expected.\n",
    ">3. Use numpy functions to simplify operations where possible.\n",
    ">\n",
    "> Here is a working solution:\n",
    ">\n",
    ">``` python\n",
    ">import numpy as np\n",
    ">\n",
    ">class Preprocessor:\n",
    ">    \"\"\"\n",
    ">    A base class for different types of data preprocessing operations.\n",
    ">    \"\"\"\n",
    ">    def process(self):\n",
    ">        raise NotImplementedError(\"Subclass must implement abstract method\")\n",
    ">\n",
    ">class Scaler(Preprocessor):\n",
    ">    def __init__(self, data, min_val=0, max_val=1):\n",
    ">        self.data = data\n",
    ">        self.min_val = min_val\n",
    ">        self.max_val = max_val\n",
    ">    \n",
    ">    def process(self):\n",
    ">        data_min = np.min(self.data)\n",
    ">        data_max = np.max(self.data)\n",
    ">        scaled_data = (self.data - data_min) / (data_max - data_min) * (self.min_val - self.max_val) + self.max_val\n",
    ">        return scaled_data\n",
    ">\n",
    ">class Normalizer(Preprocessor):\n",
    ">    def __init__(self, data):\n",
    ">        self.data = data\n",
    ">    \n",
    ">    def process(self):\n",
    ">        mean = np.mean(self.data)\n",
    ">        std = np.std(self.data)\n",
    ">        normalized_data = (self.data - mean) / std\n",
    ">        return normalized_data\n",
    ">\n",
    ">class Binarizer(Preprocessor):\n",
    ">    def __init__(self, data, threshold):\n",
    ">        self.data = data\n",
    ">        self.threshold = threshold\n",
    ">    \n",
    ">    def process(self):\n",
    ">        binarized_data = np.where(self.data > self.threshold, 1, 0)\n",
    ">        return binarized_data\n",
    ">```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test your implementation with the example usage provided\n",
    "data = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "scaler = Scaler(data, min_val=0, max_val=1)\n",
    "normalizer = Normalizer(data)\n",
    "binarizer = Binarizer(data, threshold=3)\n",
    "\n",
    "print(scaler.process())      # Scaled data\n",
    "print(normalizer.process())  # Normalized data\n",
    "print(binarizer.process())   # Binarized data"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}