polymorphism.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "44d1b427",
   "metadata": {},
   "source": [
    "# POLYMORPHISM:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af204da8",
   "metadata": {},
   "source": [
    "- polymorpism means having many forms\n",
    "- it means the same function name but different function signatures \n",
    "- these function signatures can vary in term of number of arguments or in datatypes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ec2d18a",
   "metadata": {},
   "source": [
    "# In-built Polymorphic fn.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "feceaf95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# in-built polymorphic functions\n",
    "\n",
    "print(len(\"geeks\"))\n",
    "print(len([10, 20, 30]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92e57412",
   "metadata": {},
   "source": [
    "# User-defined Polymorphic function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "784e6de4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "60\n",
      "10\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "def addition(a=0, b=0, c=0):\n",
    "    return a + b + c\n",
    "\n",
    "print(addition(10, 20))\n",
    "print(addition(10, 20, 30))\n",
    "print(addition(10))\n",
    "print(addition())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ddf9730",
   "metadata": {},
   "source": [
    "# Polymorphism with class methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "29963b24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Capital: New Delhi\n",
      "CApital: Washigton\n"
     ]
    }
   ],
   "source": [
    "class India:\n",
    "    def capital(self):\n",
    "        print(\"Capital: New Delhi\")\n",
    "        \n",
    "class USA:\n",
    "    def capital(self):\n",
    "        print(\"CApital: Washigton\")\n",
    "        \n",
    "obj_i = India()\n",
    "obj_u = USA()\n",
    "\n",
    "for country in (obj_i, obj_u):\n",
    "    country.capital()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "98558152",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "country A\n",
      "country B\n",
      "country C\n"
     ]
    }
   ],
   "source": [
    "for country in (\"A\", \"B\", \"C\"):\n",
    "    print(\"country\", country)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "900985b3",
   "metadata": {},
   "source": [
    "# Polymorphism with Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "355f2413",
   "metadata": {},
   "source": [
    "- through polymorphism, we can define methods in the child class that have the same name as the methods in the parent class.\n",
    "- it is possible to modify a method in the child class that is inherited from the parent class\n",
    "- This process of reimplementing a method in the child class is known as __Method Overriding__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c7e2ee06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "here r many types of birds\n",
      "some birds fy some dont\n",
      "here r many types of birds\n",
      "sparrow can fly\n",
      "here r many types of birds\n",
      "Ostrich cant fly\n"
     ]
    }
   ],
   "source": [
    "class Bird:\n",
    "    def intro(self):\n",
    "        print(\"here r many types of birds\")\n",
    "        \n",
    "    def flight(self):\n",
    "        print(\"some birds fy some dont\")\n",
    "        \n",
    "        \n",
    "class Sparrow(Bird):\n",
    "    def flight(self):\n",
    "        print(\"sparrow can fly\")          #overriden\n",
    "\n",
    "class Ostrich(Bird):\n",
    "    def flight(self):\n",
    "        print(\"Ostrich cant fly\")\n",
    "        \n",
    "obj_b = Bird()\n",
    "obj_s = Sparrow()\n",
    "obj_o = Ostrich()\n",
    "\n",
    "obj_b.intro()\n",
    "obj_b.flight()\n",
    "\n",
    "obj_s.intro()\n",
    "obj_s.flight()\n",
    "\n",
    "obj_o.intro()\n",
    "obj_o.flight()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9979d0b9",
   "metadata": {},
   "source": [
    "# Operator Overloading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "51f79ad2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 = [1, 2, 3]\n",
    "l2 = [4, 5, 6]\n",
    "l1 + l2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c84aea60",
   "metadata": {},
   "source": [
    "- When the same inbuilt operator or the function is showing different behaviour for different objects. This is known as operator overloading."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "44fc5678",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "46\n",
      "AB\n",
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "print( 14 + 32)\n",
    "print(\"A\" + \"B\")\n",
    "print([1, 2] + [3, 4, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a58d9474",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "230\n",
      "ABCABC\n"
     ]
    }
   ],
   "source": [
    "print( 23 * 10)\n",
    "print(\"ABC\" * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9847e48b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ente value:1\n",
      "Enter value2\n",
      "<class '__main__.OperatorOverloading'>\n",
      "3\n",
      "enter value:ab\n",
      "enter value:cd\n",
      "abcd\n"
     ]
    }
   ],
   "source": [
    "class OperatorOverloading:\n",
    "    \n",
    "    def __init__(self, X):\n",
    "        self.X = X\n",
    "        \n",
    "    def __add__(self, U):              #magic function\n",
    "        return self.X + U.X\n",
    "    \n",
    "# n = int(input())    \n",
    "obj1 =  OperatorOverloading(int(input(\"Ente value:\")))\n",
    "obj2 =  OperatorOverloading(int(input(\"Enter value\")))\n",
    "print(type(obj1))\n",
    "print(obj1 + obj2)\n",
    "\n",
    "obj3 = OperatorOverloading(str(input(\"enter value:\")))\n",
    "obj4 = OperatorOverloading(str(input(\"enter value:\")))\n",
    "print(obj3 + obj4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60a35e67",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}