Day 3: Advanced Data Structures in Python like Dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "add97af9",
   "metadata": {},
   "source": [
    "# OOP Concepts in Python\n",
    "- What is OOP?\n",
    "    - Benefits of OOP\n",
    "- How to structure OOP programs\n",
    "- Building blocks of OOP\n",
    "    - Classes\n",
    "    - Methods\n",
    "    - Objects\n",
    "    - Attributes\n",
    "- Four Principles of OOP\n",
    "    - Inheritance\n",
    "        - Benefits of Inheritance\n",
    "    - Encapsulation\n",
    "        - Private/Internal Interface\n",
    "        - Public/External Interface\n",
    "        - Benefits of Encapsulation\n",
    "    - Abstraction\n",
    "        - Benefits of Abstraction\n",
    "    - Polymorphism\n",
    "        - Method Overriding\n",
    "        - Method Overloading\n",
    "        - Benefits of Polymorphism"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29312339",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6bb7924f",
   "metadata": {},
   "source": [
    "### Simple Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "568dcad7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "#     In python constructors are defined using a special method called `__inti__`\n",
    "#     In constructor, we are passing two default parameters\n",
    "    def __init__(self, x=0,y=0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "#     Here x is a global as well as local, \n",
    "#     we can access it anywhere in the body of the function\n",
    "    \n",
    "#     If we want to create another constructor in the class, then\n",
    "#     second constructor automatically overwrite the first constructor\n",
    "    def __init__():\n",
    "        pass\n",
    "        \n",
    "    def __str__(self):\n",
    "        return '[' + str(self.x) + ','+str(self.y) + ']'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "644cefe8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p1 :  0\n",
      "p2 :  2\n"
     ]
    }
   ],
   "source": [
    "# creating object/instance variable of the class\n",
    "# p1 is a reference/pointer variable\n",
    "p1 = Point()\n",
    "print(\"p1 : \", p1.x)\n",
    "\n",
    "p2 = Point(2,4)\n",
    "print(\"p2 : \", p2.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "16063efb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Point at 0x7ff54c3e4a30>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p2\n",
    "# this shows that p2 is a reference object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5cefd179",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p1 : [0,0]\n",
      "p2 : [2,4]\n",
      "[0,0]\n",
      "[2,4]\n"
     ]
    }
   ],
   "source": [
    "# string representation of reference variable p1 is \n",
    "print('p1 :', p1.__str__())\n",
    "\n",
    "# string representation of ther reference variable p2 is \n",
    "print('p2 :',p2.__str__())\n",
    "\n",
    "print(p1)\n",
    "print(p2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd176df7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "98dbb069",
   "metadata": {},
   "source": [
    "## Composition\n",
    "Creating instance of a class into another class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "87118292",
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating a triangle using Shape class with the help of Point class\n",
    "class Shape:\n",
    "    \n",
    "#     constructor\n",
    "    def __init__(self, points):\n",
    "        self.points = points\n",
    "        \n",
    "#     def display(self):\n",
    "#         return \"return of the function\"\n",
    "    def __str__(self):\n",
    "        ret = \"\"\n",
    "        for i in self.points:\n",
    "            ret += str(i) + \"->\"\n",
    "        print(type(ret))\n",
    "        return ret[:-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "9b690ab0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "[2,3]->[4,7]->[1,9]\n"
     ]
    }
   ],
   "source": [
    "# creating instances of the point class\n",
    "p1 = Point(2,3)\n",
    "p2 = Point(4,7)\n",
    "p3 = Point(1,9)\n",
    "\n",
    "p = [p1,p2,p3]\n",
    "\n",
    "# createing instance of shape class\n",
    "sh = Shape(p)\n",
    "print(sh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "29cc2325",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can add methods/functions to \n",
    "# the class even after it has been defined/declared\n",
    "\n",
    "def print_points(self):\n",
    "    for i in self.points:\n",
    "        print(i)\n",
    "        \n",
    "# now we can assign this function to over class\n",
    "Shape.print_points = print_points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "98b790dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2,3]\n",
      "[4,7]\n",
      "[1,9]\n"
     ]
    }
   ],
   "source": [
    "sh.print_points()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd2d8980",
   "metadata": {},
   "source": [
    "## First Class : Coin Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "ca96aa2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This side is up :  Heads\n",
      "I am tossing the coin ..... None\n",
      "This side is up :  Heads\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "# create a coin class which is used to clip a coin\n",
    "class Coin:\n",
    "    \n",
    "#     creating initializer/constructor of the class\n",
    "    def __init__(self):\n",
    "#         sideup is a data attribute\n",
    "        self.sideup = 'Heads'\n",
    "    \n",
    "#     create a method used to flip the coin\n",
    "    def toss(self):\n",
    "        if random.randint(0,1) == 0:\n",
    "            self.sideup = 'Heads'\n",
    "        else:\n",
    "            self.sideup = 'Tails'\n",
    "        \n",
    "#     get coin side\n",
    "    def get_side(self):\n",
    "        return self.sideup\n",
    "    \n",
    "    \n",
    "def main():\n",
    "#     creating instance/object of the class\n",
    "    flip_coin = Coin()\n",
    "    \n",
    "#     display the side of the coin that is facing up\n",
    "    print(\"This side is up : \", flip_coin.get_side())\n",
    "    \n",
    "    \n",
    "#     toss the coin\n",
    "    print(\"I am tossing the coin .....\", flip_coin.toss())\n",
    "    \n",
    "    \n",
    "#     now again get top side of the coin\n",
    "    print(\"This side is up : \", flip_coin.get_side())\n",
    "    \n",
    "main()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a12ca67",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "23f860a6",
   "metadata": {},
   "source": [
    "## Inheritance\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "46f8d640",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2,3]\n",
      "[4,7]\n",
      "[1,9]\n"
     ]
    }
   ],
   "source": [
    "class Triangle(Shape):   # Triangle class is inherits from Shape class\n",
    "    pass\n",
    "\n",
    "# creating instance of the Triangle class\n",
    "t = Triangle(p) # here p is a list of references variable of class Point\n",
    "t.print_points()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77e9bef0",
   "metadata": {},
   "source": [
    "#### Area of triangle\n",
    "![](https://media.geeksforgeeks.org/wp-content/cdn-uploads/20201022210708/AreofTriangle.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6cc47e57",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "4cebd9fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "[2,3]\n",
      "[4,7]\n",
      "[1,9]\n"
     ]
    }
   ],
   "source": [
    "def get_Area(self):\n",
    "    vertices = self.points\n",
    "    print(len(vertices))\n",
    "    li = []\n",
    "    for i in range(len(vertices)):\n",
    "        print(vertices[i])\n",
    "        \n",
    "#         print(type(i))\n",
    "#         print(i)\n",
    "#         pass\n",
    "        \n",
    "        \n",
    "Triangle.get_Area = get_Area\n",
    "t.get_Area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9d4656e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10276977",
   "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
}