Python_Multiple_Multilevel_inheritance.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f290b26e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Student Details\n",
      "---------------\n",
      "Name :- Sunil\n",
      "Age :- 39\n",
      "Gender :- Male\n",
      "Student ID :- 1234\n",
      "Fees :- 12000\n",
      "\n",
      "Employee Details\n",
      "---------------\n",
      "Name :- Raviteja\n",
      "Age :- 45\n",
      "Gender :- Male\n",
      "Employee ID :- 4567\n",
      "Salary :- 80000\n"
     ]
    }
   ],
   "source": [
    "class person: # Parent Class\n",
    "    def __init__(self, name , age , gender):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.gender = gender\n",
    " \n",
    "    def PersonInfo(self):\n",
    "        print('Name :- {}'.format(self.name))\n",
    "        print('Age :- {}'.format(self.age))\n",
    "        print('Gender :- {}'.format(self.gender))\n",
    "\n",
    "class student(person): # Child Class\n",
    "    def __init__(self,name,age,gender,studentid,fees):\n",
    "        person.__init__(self,name,age,gender)\n",
    "        self.studentid = studentid\n",
    "        self.fees = fees\n",
    "\n",
    "    def StudentInfo(self):\n",
    "        print('Student ID :- {}'.format(self.studentid))\n",
    "        print('Fees :- {}'.format(self.fees))\n",
    "        \n",
    "class teacher(person): # Child Class\n",
    "    def __init__(self,name,age,gender,empid,salary):\n",
    "        person.__init__(self,name,age,gender)\n",
    "        self.empid = empid\n",
    "        self.salary = salary\n",
    "\n",
    "    def TeacherInfo(self):\n",
    "        print('Employee ID :- {}'.format(self.empid))\n",
    "        print('Salary :- {}'.format(self.salary))\n",
    "\n",
    "stud1 = student('Sunil' , 39 , 'Male' , 1234 , 12000)\n",
    "print('Student Details')\n",
    "print('---------------')\n",
    "stud1.PersonInfo() \n",
    "stud1.StudentInfo()\n",
    "print()\n",
    "teacher1 = teacher('Raviteja' , 45 , 'Male' , 4567 , 80000)\n",
    "print('Employee Details')\n",
    "print('---------------')\n",
    "teacher1.PersonInfo() \n",
    "teacher1.TeacherInfo()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9d21770",
   "metadata": {},
   "source": [
    "## Multi-level Inheritance\n",
    "- In this type of inheritance, a class can inherit from a child class or derived class.\n",
    "- Multilevel Inheritance can be of any depth in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "442c2d94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Contractual Employee Details\n",
      "****************************\n",
      "Name :- Sunil\n",
      "Age :- 36\n",
      "Gender :- Male\n",
      "Employee ID :- 456\n",
      "Salary :- 80000\n",
      "Contract Expiry :- 21-12-2024\n",
      "\n",
      " \n",
      "\n",
      "Fulltime Employee Details\n",
      "****************************\n",
      "Name :- Rahul\n",
      "Age :- 22\n",
      "Gender :- Male\n",
      "Employee ID :- 567\n",
      "Salary :- 70000\n",
      "Work Experience :- 12\n"
     ]
    }
   ],
   "source": [
    "class person: # Parent Class\n",
    "    def __init__(self, name , age , gender):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.gender = gender\n",
    "\n",
    "    def PersonInfo(self):\n",
    "        print('Name :- {}'.format(self.name))\n",
    "        print('Age :- {}'.format(self.age))\n",
    "        print('Gender :- {}'.format(self.gender))\n",
    "        \n",
    "class employee(person): # Child Class\n",
    "    def __init__(self,name,age,gender,empid,salary):\n",
    "        person.__init__(self,name,age,gender)\n",
    "        self.empid = empid\n",
    "        self.salary = salary\n",
    "    def employeeInfo(self):\n",
    "        print('Employee ID :- {}'.format(self.empid))\n",
    "        print('Salary :- {}'.format(self.salary))\n",
    "        \n",
    "class fulltime(employee): # Grand Child Class\n",
    "    def __init__(self,name,age,gender,empid,salary,WorkExperience):\n",
    "        employee.__init__(self,name,age,gender,empid,salary)\n",
    "        self.WorkExperience = WorkExperience\n",
    "    def FulltimeInfo(self):\n",
    "        print('Work Experience :- {}'.format(self.WorkExperience))\n",
    "class contractual(employee): # Grand Child Class\n",
    "    def __init__(self,name,age,gender,empid,salary,ContractExpiry):\n",
    "        employee.__init__(self,name,age,gender,empid,salary)\n",
    "        self.ContractExpiry = ContractExpiry\n",
    "    def ContractInfo(self):\n",
    "        print('Contract Expiry :- {}'.format(self.ContractExpiry))\n",
    "\n",
    "print('Contractual Employee Details')\n",
    "print('****************************')\n",
    "contract1 = contractual('Sunil' , 36 , 'Male' , 456 , 80000,'21-12-2024')\n",
    "contract1.PersonInfo()\n",
    "contract1.employeeInfo()\n",
    "contract1.ContractInfo()\n",
    "print('\\n \\n')\n",
    "print('Fulltime Employee Details')\n",
    "print('****************************')\n",
    "fulltim1= fulltime('Rahul' , 22 , 'Male' , 567 , 70000, 12)\n",
    "fulltim1.PersonInfo()\n",
    "fulltim1.employeeInfo()\n",
    "fulltim1.FulltimeInfo()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c345b78",
   "metadata": {},
   "source": [
    "# Multiple Inheritance\n",
    "- Multiple inheritance is a feature in which a class (derived class) can inherit attributes and\n",
    "- methods from more than one parent class.\n",
    "- The derived class inherits all the features of the base case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4409af96",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My Name is :  Sunil\n",
      "My Father name is : Shahaji\n",
      "Mother name is : Mangal\n"
     ]
    }
   ],
   "source": [
    "# Super Class\n",
    "class Father:\n",
    "    def __init__(self):\n",
    "        self.fathername = str()\n",
    "# Super Class\n",
    "class Mother:\n",
    "    def __init__(self):\n",
    "        self.mothername = str()\n",
    " \n",
    " \n",
    "# Sub Class\n",
    "class Son(Father, Mother):\n",
    "    name = str()\n",
    "    def show(self):\n",
    "        print('My Name is : ',self.name)\n",
    "        print(\"My Father name is :\", self.fathername)\n",
    "        print(\"Mother name is :\", self.mothername)\n",
    "s1 = Son()\n",
    "s1.name = 'Sunil'\n",
    "s1.fathername = \"Shahaji\"\n",
    "s1.mothername = \"Mangal\"\n",
    "s1.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "47916f9d",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'CurrentDate' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[4], line 7\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m,time):\n\u001b[0;32m      6\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtime \u001b[38;5;241m=\u001b[39m time\n\u001b[1;32m----> 7\u001b[0m \u001b[38;5;28;01mclass\u001b[39;00m \u001b[38;5;21;01mtimestamp\u001b[39;00m(\u001b[43mCurrentDate\u001b[49m,CurrentTime):\n\u001b[0;32m      8\u001b[0m     \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m,date,time):\n\u001b[0;32m      9\u001b[0m         CurrentDate\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m,date)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'CurrentDate' is not defined"
     ]
    }
   ],
   "source": [
    "class Date:\n",
    "    def __init__(self,date):\n",
    "        self.date = date \n",
    "class Time:\n",
    "    def __init__(self,time):\n",
    "        self.time = time\n",
    "class timestamp(CurrentDate,CurrentTime):\n",
    "    def __init__(self,date,time):\n",
    "        CurrentDate.__init__(self,date)\n",
    "        CurrentTime.__init__(self,time)\n",
    "        DateTime = self.date + ' ' + self.time\n",
    "        print(DateTime)\n",
    "datetime1 = timestamp( '2024-01-01', '23:59:55')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c93e7e3",
   "metadata": {},
   "source": [
    "## Method Overriding\n",
    "- Overriding is a very important part of object oreinted programming because it makes inheritance exploit its full power.\n",
    "- Overriding is the ability of a class (Sub Class / Child Class / Derived Class) to change the implementation of a method     provided by one of its parent classes.\n",
    "- When a method in a subclass has the same name, same parameter and same return type as a method in its super-class, then     the method in the subclass is said to override the method in the super-class.\n",
    "- The version of a method that is executed will be determined by the object that is used to invoke it.\n",
    "- If an object of a parent class is used to invoke the method, then the version in the parent class will be executed, but     if an object of the subclass is used to invoke the method, then the version in the child class will be executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b09f34a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class person: # Parent Class\n",
    "    def __init__(self, name , age , gender):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.gender = gender\n",
    " \n",
    "    def greet(self):\n",
    "        print(\"Hello Person\")\n",
    "\n",
    "class student(person): # Child Class\n",
    "    def __init__(self,name,age,gender,studentid,fees):\n",
    "        person.__init__(self,name,age,gender)\n",
    "        self.studentid = studentid\n",
    "        self.fees = fees\n",
    "    def greet(self):\n",
    "        print(\"Hello Student\")\n",
    "\n",
    "stud = student('Sunil' , 39 , 'Male' , 45 , 345678)\n",
    "stud.greet() # greet() method defined in subclass will be triggered \n",
    "person1 = person('SUNIL' , 62 , 'Male')\n",
    "person1.greet() # greet() method defined in superclass will be triggered"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50028ed8",
   "metadata": {},
   "source": [
    "# Container\n",
    "- Containers are data structures that hold data values.\n",
    "- They support membership tests which means we can check whether a value exists in the container or not.\n",
    "- Generally containers provide a way to access the contained objects and to iterate over them.\n",
    "- Examples of containers include tuple, list, set, dict, str."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b34ecef5",
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = ['Sunil' , 'Rahul' , 'Anil' , 'Santosh' ,'Sambhaji']\n",
    "'Ketan' in list1 # Membership check using 'in' operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bafbccf6",
   "metadata": {},
   "outputs": [],
   "source": [
    "'rahul' in list1 # Membership check using 'in' operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94ed115c",
   "metadata": {},
   "outputs": [],
   "source": [
    "'Rahul' in list1 # Membership check using 'in' operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b9a8bda",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 'Sunil' in list1 # If the condition returns true the program does nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5edba829",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 'Sunil' in list1 # If the condition returns false, Assert will stop the program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44423281",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 'sunil1' in list1 # If the condition returns false, Assert will stop the program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86a0cff5",
   "metadata": {},
   "outputs": [],
   "source": [
    "mydict = {'Name':'Sunil' , 'ID': 12345 , 'DOB': 1984 , 'Address' : 'Tasgaon'}\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59c49a53",
   "metadata": {},
   "outputs": [],
   "source": [
    "'Sunil' in mydict # Dictionary membership will always check the keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e77711d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "'Name' in mydict # Dictionary membership will always check the keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54280e39",
   "metadata": {},
   "outputs": [],
   "source": [
    "'DOB' in mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2661c05d",
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr = 'sunil'\n",
    "'su' in mystr # Check if substring is present"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3de5d195",
   "metadata": {},
   "source": [
    "# Iterable & Iterator\n",
    "- An iterable is an object that can be iterated upon. It can return an iterator object with the purpose of traversing         through all the elements of an iterable.\n",
    "- An iterable object implements __iter()__ which is expected to return an iterator object. The iterator object uses the       __next()__ method. \n",
    "- Every time next() is called next element in the iterator stream is returned. \n",
    "- When there are no more elements available StopIteration exception is encountered. So any object that has a __next()__       method is called an iterator\n",
    "- Python lists, tuples, dictionaries and sets are all examples of iterable objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f1fc31a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rahul\n",
      "Anil\n",
      "Sunil\n",
      "Santosh\n",
      "Tushar\n"
     ]
    }
   ],
   "source": [
    "mylist = ['Rahul' , 'Anil' , 'Sunil' , 'Santosh', 'Tushar']\n",
    "list_iter = iter(mylist) # Create an iterator object using iter()\n",
    "print(next(list_iter)) # return first element in the iterator stream\n",
    "print(next(list_iter)) # return next element in the iterator stream\n",
    "print(next(list_iter))\n",
    "print(next(list_iter))\n",
    "print(next(list_iter))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a137dcd9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rahul\n",
      "Anil\n",
      "Sunil\n",
      "Santosh\n",
      "Tushar\n"
     ]
    }
   ],
   "source": [
    "mylist = ['Rahul' , 'Anil' , 'Sunil' , 'Santosh', 'Tushar']\n",
    "list_iter = iter(mylist) # Create an iterator object using iter()\n",
    "print(list_iter.__next__()) # return first element in the iterator stream\n",
    "print(list_iter.__next__()) # return next element in the iterator stream\n",
    "print(list_iter.__next__())\n",
    "print(list_iter.__next__())\n",
    "print(list_iter.__next__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "bec7f533",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rahul\n",
      "Anil\n",
      "Sunil\n",
      "Santosh\n",
      "Tushar\n"
     ]
    }
   ],
   "source": [
    "mylist = ['Rahul' , 'Anil' , 'Sunil' , 'Santosh', 'Tushar']\n",
    "list_iter = iter(mylist) # Create an iterator object using iter()\n",
    "for i in list_iter:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b0139e88",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rahul\n",
      "Anil\n",
      "Sunil\n",
      "Santosh\n",
      "Tushar\n"
     ]
    }
   ],
   "source": [
    "# Looping Through an Iterable (list) using for loop\n",
    "mylist = ['Rahul' , 'Anil' , 'Sunil' , 'Santosh', 'Tushar']\n",
    "for i in mylist:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "29741e51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rahul\n",
      "Anil\n",
      "Sunil\n",
      "Santosh\n",
      "Tushar\n"
     ]
    }
   ],
   "source": [
    "# Looping Through an Iterable (tuple) using for loop\n",
    "mytuple = ('Rahul' , 'Anil' , 'Sunil' , 'Santosh', 'Tushar')\n",
    "for i in mytuple:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0ac70aaa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H e l l o   P y t h o n "
     ]
    }
   ],
   "source": [
    "# Looping Through an Iterable (string) using for loop\n",
    "mystr = \"Hello Python\"\n",
    "for i in mystr:\n",
    "    print(i,end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "84ef2df8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    "# This iterator produces all natural numbers from 1 to 10.\n",
    "class myiter:\n",
    "    def __init__(self):\n",
    "        self.num = 0\n",
    " \n",
    "    def __iter__(self):\n",
    "        self.num = 1\n",
    "        return self\n",
    " \n",
    "    def __next__(self):\n",
    "        if self.num <= 10:\n",
    "            val = self.num\n",
    "            self.num += 1\n",
    "            return val\n",
    "        else:raise StopIteration\n",
    "mynum = myiter()\n",
    "iter1 = iter(mynum)\n",
    "for i in iter1:\n",
    "    print(i,end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "59825fe7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 2 3 5 8 13 21 34 "
     ]
    }
   ],
   "source": [
    "#This iterator will produce fibonacci numbers\n",
    "class myfibonacci:\n",
    "    def __init__(self):\n",
    "        self.prev = 0\n",
    "        self.cur = 0\n",
    " \n",
    "    def __iter__(self):\n",
    "        self.prev = 0\n",
    "        self.cur = 1\n",
    "        return self\n",
    " \n",
    "    def __next__(self):\n",
    "        if self.cur <= 50:\n",
    "            val = self.cur\n",
    "            self.cur += self.prev\n",
    "            self.prev = val\n",
    "            return val\n",
    "        else:\n",
    "            raise StopIteration\n",
    "myfibo = myfibonacci()\n",
    "iter1 = iter(myfibo)\n",
    "for i in iter1:\n",
    "    print(i,end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4370f93c",
   "metadata": {},
   "source": [
    "# Generator\n",
    "- Python generators are easy way of creating iterators. \n",
    "- It generates values one at a time from a given sequence instead of returning the entire sequence at once.\n",
    "- It is a special type of function which returns an iterator object.\n",
    "- In a generator function, a yield statement is used rather than a return statement.\n",
    "- The generator function cannot include the return keyword. \n",
    "- If we include it then it will terminate the execution of the function.\n",
    "- The difference between yield and return is that once yield returns a value the function is paused and the control is       transferred to the caller.\n",
    "- Local variables and their states are remembered between successive calls. \n",
    "- In case of the return statement value is returned and the execution of the function is terminated.\n",
    "- Methods like iter() and next() are implemented automatically in generator function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d2166e5",
   "metadata": {},
   "source": [
    "## - Simple generators can be easily created using generator expressions. \n",
    "- Expressions create anonymous generator functions like lambda.\n",
    "- The syntax for generator expression is similar to that of a list comprehension but the only\n",
    "  difference is square brackets are replaced with round parentheses. Also list comprehension\n",
    "- produces the entire list while the generator expression produces one item at a time which is\n",
    "  more memory efficient than list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5b1be08d",
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (3793505318.py, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[13], line 3\u001b[1;36m\u001b[0m\n\u001b[1;33m    n = 1\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "# Simple generator function that will generate numbers from 1 to 5.\n",
    "def mygen():\n",
    "n = 1\n",
    "yield n\n",
    "n += 1\n",
    "yield n\n",
    " n += 1\n",
    "yield n\n",
    " n += 1\n",
    "yield n\n",
    "n += 1\n",
    "yield n\n",
    " \n",
    "mygen1 = mygen()\n",
    "print(next(mygen1))\n",
    "print(next(mygen1))\n",
    "print(next(mygen1))\n",
    "print(next(mygen1))\n",
    "print(next(mygen1)) #Function will terminate here as all 5 values have been retur\n",
    "print(next(mygen1)) # As function is already terminated, StopIteration is raise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f504672e",
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (3271344530.py, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[14], line 4\u001b[1;36m\u001b[0m\n\u001b[1;33m    yield i\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "# Simple generator function that will generate natural numbers from 1 to 20.\n",
    "def mygen():\n",
    "    for i in range(1,20):\n",
    "    yield i\n",
    "mygen1 = mygen()\n",
    "for i in mygen1:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "fb259e85",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'myfibonacci' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[15], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m list1 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\u001b[43mmyfibo\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m) \u001b[38;5;66;03m# Store the fibonacci series in a list\u001b[39;00m\n\u001b[0;32m      2\u001b[0m list1\n",
      "\u001b[1;31mTypeError\u001b[0m: 'myfibonacci' object is not callable"
     ]
    }
   ],
   "source": [
    "list1 = list(myfibo()) # Store the fibonacci series in a list\n",
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4400a557",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2 = [i**2 for i in range(10)] # List comprehension\n",
    "list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9b0f9380",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x0000025EF65E1120>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gen2 = (i**2 for i in range(10)) # Generator expression\n",
    "gen2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ed30ea5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "print(next(gen2))\n",
    "print(next(gen2))\n",
    "print(next(gen2))\n",
    "print(next(gen2))\n",
    "print(next(gen2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6f3f353a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 "
     ]
    }
   ],
   "source": [
    "gen2 = (i for i in range(40) if i%2 == 0) # Generator expression to generate even numbers\n",
    "gen2\n",
    "for i in gen2:\n",
    "    print(i,end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "791ef900",
   "metadata": {},
   "source": [
    "# Decorator\n",
    "- Decorator is very powerful and useful tool in Python as it allows us to wrap another function in\n",
    "  order to extend the behavior of wrapped function without permanently modifying it.\n",
    "- In Decorators functions are taken as the argument into another function and then called inside the wrapper function.\n",
    "- Advantages -\n",
    "  1.Logging & debugging\n",
    "  2.Access control and authentication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "d2b44dd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result is :-  2\n",
      "Result is :-  -2\n"
     ]
    }
   ],
   "source": [
    "def subtract(num1 , num2):\n",
    "    res = num1 - num2\n",
    "    print('Result is :- ', res)\n",
    "\n",
    "subtract(4,2)\n",
    "subtract(2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "5c42d4f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result is :-  2\n"
     ]
    }
   ],
   "source": [
    "''' We now want subtract() function to always subtract lower number from higher order\n",
    " So when we pass (2,4) it should perform 4-2 not 2-4. To acheive this we will''' \n",
    " \n",
    "def sub_decorator(func):\n",
    "    def wrapper(num1,num2):\n",
    "        if num1 < num2:\n",
    "            num1,num2 = num2,num1\n",
    "            return func(num1,num2)\n",
    "    return wrapper\n",
    " \n",
    "sub = sub_decorator(subtract)\n",
    "sub(2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "2c93ec9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result is :-  2\n"
     ]
    }
   ],
   "source": [
    "@sub_decorator # we can use @ syntax for decorating a function in one step\n",
    "def subtract(num1 , num2):\n",
    "    res = num1 - num2\n",
    "    print('Result is :- ', res)\n",
    "subtract(2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "6c6ca823",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linux installation has started \n",
      "\n",
      "Windows installation has started \n",
      "\n",
      "Mac installation has started \n",
      "\n",
      "\n",
      "Please accept terms & conditions\n",
      "Linux installation has started \n",
      "\n"
     ]
    }
   ],
   "source": [
    "def InstallLinux():\n",
    "    print('Linux installation has started \\n')\n",
    "\n",
    "def InstallWindows():\n",
    "    print('Windows installation has started \\n')\n",
    "\n",
    "def InstallMac():\n",
    "    print('Mac installation has started \\n')\n",
    "\n",
    "InstallLinux()\n",
    "InstallWindows()\n",
    "InstallMac()\n",
    "print()\n",
    "''' Now suppose if we want to print message :- \"Please accept terms & conditions\"\n",
    " then easy way will be to create one decorator function which will present this'''\n",
    " \n",
    "def InstallDecorator(func):\n",
    "    def wrapper():\n",
    "        print('Please accept terms & conditions')\n",
    "        return func()\n",
    "    return wrapper()\n",
    "@InstallDecorator # we can use @ syntax for decorating a function in one step\n",
    "def InstallLinux():\n",
    "    print('Linux installation has started \\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "71363447",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please accept terms & conditions...\n",
      "\n",
      "Please enter correct license key...\n",
      "\n",
      "Please enter partitioning choice...\n",
      "\n",
      "Linux installation has started \n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Apply multiple decorator on a single function\n",
    "def InstallDecorator1(func):\n",
    "    def wrapper():\n",
    "        print('Please accept terms & conditions...\\n')\n",
    "        func()\n",
    "    return wrapper\n",
    "def InstallDecorator2(func):\n",
    "    def wrapper():\n",
    "        print('Please enter correct license key...\\n')\n",
    "        return func()\n",
    "    return wrapper\n",
    "def InstallDecorator3(func):\n",
    "    def wrapper():\n",
    "        print('Please enter partitioning choice...\\n')\n",
    "        return func()\n",
    "    return wrapper\n",
    "@InstallDecorator1\n",
    "@InstallDecorator2\n",
    "@InstallDecorator3\n",
    "def InstallLinux():\n",
    "    print('Linux installation has started \\n')\n",
    "    \n",
    "InstallLinux()"
   ]
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}