Python 3 - Functions and OOPs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a98edb3b",
   "metadata": {},
   "source": [
    "# Classes and Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ef9edb0",
   "metadata": {},
   "source": [
    "### Class\n",
    "\n",
    "A Class is a template/blueprint which contains instructions to build an object. and objects are created from classes which are instances of class.\n",
    "\n",
    "class has formed of following items:\n",
    "1. Attributes - \n",
    "2. Methods - Method can be used by the object to exhibit a specific behaviour.\n",
    "\n",
    "- class keyword is used to define a class in Python\n",
    "\n",
    "### Creating Objects\n",
    "An object is created by calling the class name followed by a pair of parenthesis.\n",
    "e.g. obj = ClassName()\n",
    "\n",
    "### Setting Attributes Contd..\n",
    "You can also set multiple attributes, at once, by defining the initializer method, __init__, inside the class.\n",
    "\n",
    "- This method is called by default, during an object creation.\n",
    "\n",
    "- It takes values passed inside the parenthesis, during an object creation, as it's arguments.\n",
    "\n",
    "- It also takes `self` as the first argument, which refers to the current object.\n",
    "\n",
    "\n",
    "### Documenting a Class\n",
    "Each class or a method definition can have an optional first line, known as docstring.\n",
    "\n",
    "Example\n",
    "class Person:\n",
    "    'Represents a person.'\n",
    "    def __init__(self, fname, lname):\n",
    "        'Initialises two attributes of a person.'\n",
    "        self.fname = fname\n",
    "        self.lname = lname"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "8a5dd143",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94.0\n",
      "Help on class Student in module __main__:\n",
      "\n",
      "class Student(builtins.object)\n",
      " |  Student(id, name, marks)\n",
      " |  \n",
      " |  class is used for demonstration\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, id, name, marks)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  calculate_percentage(self)\n",
      " |      method is used for demonstration\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      "\n",
      "Help on function calculate_percentage in module __main__:\n",
      "\n",
      "calculate_percentage(self)\n",
      "    method is used for demonstration\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    \"\"\"class is used for demonstration\"\"\"\n",
    "    def __init__(self, id, name ,marks):\n",
    "        self.id = id\n",
    "        self.name = name\n",
    "        self.marks = marks\n",
    "        \n",
    "    def calculate_percentage(self):\n",
    "        \"\"\"method is used for demonstration\"\"\"\n",
    "        percentage = self.marks*100/600\n",
    "        print(percentage)\n",
    "        \n",
    "    \n",
    "student_1 = Student(1, \"Shubham Sawant\", 564)\n",
    "\n",
    "student_1.calculate_percentage()\n",
    "\n",
    "help(Student)\n",
    "help(Student.calculate_percentage)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "068509a0",
   "metadata": {},
   "source": [
    "## 1. Inheritance\n",
    "\n",
    "Inheritance describes is a kind of relationship between two or more classes, abstracting common details into super class and storing specific ones in the subclass.\n",
    "\n",
    "To create a child class, specify the parent class name inside the pair of parenthesis, followed by it's name.\n",
    "\n",
    "\n",
    "Inheritance\n",
    "In Python, every class uses inheritance and is inherited from object by default.\n",
    "\n",
    "Hence, the below two definitions of MySubClass are same.\n",
    "MySubClass is known as child or subclass or derived class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9088bdc0",
   "metadata": {},
   "outputs": [],
   "source": [
    "Example\n",
    "class Child(Parent):  \n",
    "  \n",
    "  pass\n",
    "\n",
    "Every child class inherits all the behaviours exhibited by their parent \n",
    "class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cfb2153",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definition 1\n",
    "class MySuperClass:   \n",
    "    pass\n",
    "\n",
    "#Definition 2\n",
    "class MySubClass(MySuperClass):   \n",
    "    pass                    \n",
    "\n",
    "# Object is known as parent or super class.\n",
    "# MySubClass is known as child or subclass or derived class.\n",
    "# \"Pass\" Keyword is used when no implementation is to be provided inside subclass class "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13157e5b",
   "metadata": {},
   "source": [
    "### E.g. 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "defbd8fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------- Tree Object ----------------\n",
      "Mango\n",
      "NO I cannot move\n",
      "God\n",
      "YES I am Living Organism\n",
      "------------------- Animal Object ----------------\n",
      "Dog\n",
      "Yes I can move\n",
      "God\n",
      "YES I am Living Organism\n"
     ]
    }
   ],
   "source": [
    "# Parent Class Living_things which have attributes isLiving, made_by extended by Trees and Animal class. \n",
    "class Living_things:\n",
    "    def __init__(self):\n",
    "        self.isLiving = \"YES I am Living Organism\"\n",
    "        self.made_by  = \"God\"\n",
    "        \n",
    "        \n",
    "# Class Animal extending Class Living_things and inheriting its Attributes isLiving, made_by\n",
    "class Trees(Living_things):\n",
    "    # Constructor to initialize name attribute in Animal class\n",
    "    def __init__(self, name):\n",
    "        # Calling constructor method to initialize attributes in parents class\n",
    "        Living_things.__init__(self)\n",
    "        \n",
    "        self.name = name\n",
    "        self.can_move = \"NO I cannot move\"\n",
    "\n",
    "        \n",
    "# Class Animal extending Class Living_things and inheriting its Attributes isLiving, made_by\n",
    "class Animals(Living_things):\n",
    "    # Constructor to initialize name attribute in Animal class\n",
    "    def __init__(self, name):\n",
    "        # Calling constructor method to initialize attributes in parents class\n",
    "        Living_things.__init__(self)\n",
    "        \n",
    "        self.name = name\n",
    "        self.can_move = \"Yes I can move\"\n",
    "\n",
    "        \n",
    "# Creating Tree object\n",
    "print(\"------------------- Tree Object ----------------\")\n",
    "tree1 = Trees(\"Mango\")\n",
    "print(tree1.name)\n",
    "print(tree1.can_move)\n",
    "print(tree1.made_by)\n",
    "print(tree1.isLiving)\n",
    "\n",
    "# Creating Animal object\n",
    "print(\"------------------- Animal Object ----------------\")\n",
    "animal1 = Animals(\"Dog\")\n",
    "print(animal1.name)\n",
    "print(animal1.can_move)\n",
    "print(animal1.made_by)\n",
    "print(animal1.isLiving)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bf0af71",
   "metadata": {},
   "source": [
    "### E.g. 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "50610c53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------Person object---------------------------\n",
      "xyz abc\n",
      "21\n",
      "-------------------Student object---------------------------\n",
      "Shubham Sawant\n",
      "16\n",
      "Studying in Class-11\n",
      "-------------------Professional object---------------------------\n",
      "Prathmesh Kavathekar\n",
      "22\n",
      "Working Experience-0\n"
     ]
    }
   ],
   "source": [
    "# Parent Class Person is providing two functionalities as follows - \n",
    "# 1. Get Full Name of Person from Name and Last Name\n",
    "# 2. Get Age of Person from its Birth Date\n",
    "\n",
    "class Person:\n",
    "    # Constructor for Person class to initialise firstname, lastname and birthdate\n",
    "    def __init__(self, fname, lname, bdate):\n",
    "        self.firstname = fname\n",
    "        self.lastname = lname\n",
    "        self.bdate = bdate\n",
    "\n",
    "    # Method inside Person class to get Full name by concatenating first and last names\n",
    "    def full_name(self):\n",
    "        return (self.firstname +\" \"+ self.lastname)\n",
    "    \n",
    "    # Method inside Person class to get Age from birthdate\n",
    "    def getAge(self):\n",
    "        return (2021 - self.bdate)\n",
    "    \n",
    "    \n",
    "# Child Class Student extending Parent class Person and inheriting the Attributes and Characteristics from it\n",
    "# Student class have attribute std_class which gives class in school in which student is studying \n",
    "# Student class inherits the full_name, getAge characteristics from Person class\n",
    "class Student(Person):\n",
    "    # Constructor for Student class to initialize fname, lname, bdate\n",
    "    def __init__(self, fname, lname, bdate):\n",
    "        # Calling the constructor of parent class to initialize the attributes in parent class\n",
    "        Person.__init__(self, fname, lname, bdate)\n",
    "\n",
    "        self.std_class = \"Studying in Class-\" + str(2021-bdate-5)\n",
    "\n",
    "        \n",
    "# Child Class Professional extending Parent class Person and inheriting the Attributes and Characteristics from it\n",
    "# Professional class have attribute working_experience whichg gives experience of professional \n",
    "# Professional class inherits the full_name, getAge characteristics from Person class\n",
    "class Professional(Person):\n",
    "    # Constructor for Professional class to initialize fname, lname, bdate\n",
    "    def __init__(self, fname, lname, bdate):\n",
    "        Person.__init__(self, fname, lname, bdate)\n",
    "        \n",
    "        self.working_experience = \"Working Experience-\"+ str(self.getAge()-22)\n",
    "        \n",
    "        \n",
    "print(\"-------------------Person object---------------------------\")\n",
    "\n",
    "# Creating object of Person class\n",
    "me = Person(\"xyz\", \"abc\", 2000)\n",
    "\n",
    "print(me.full_name())\n",
    "print(me.getAge())\n",
    "        \n",
    "print(\"-------------------Student object---------------------------\")\n",
    "\n",
    "# Creating object of Student class\n",
    "shubham = Student(\"Shubham\", \"Sawant\", 2005)\n",
    "\n",
    "print(shubham.full_name())\n",
    "print(shubham.getAge())\n",
    "print(shubham.std_class)\n",
    "\n",
    "print(\"-------------------Professional object---------------------------\")\n",
    "\n",
    "# Creating object of Professional class\n",
    "prathmesh = Professional(\"Prathmesh\", \"Kavathekar\", 1999)\n",
    "\n",
    "print(prathmesh.full_name())\n",
    "print(prathmesh.getAge())\n",
    "print(prathmesh.working_experience)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a243f659",
   "metadata": {},
   "source": [
    "#### In the above example, Employee class utilizes __init __ method of the parent class Person to create its object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fa1ebe7",
   "metadata": {},
   "source": [
    "## 2. Polymorphism \n",
    "\n",
    "Polymorphism allows a subclass to override or change a specific behavior, exhibited by the parent class.\n",
    "\n",
    "Polymorphism is the presence of different forms like one method is implemented differently.\n",
    "\n",
    "This can be achieved by Method overriding"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23a70eae",
   "metadata": {},
   "source": [
    "#### Polymorphism with Inheritance and method overriding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d796ff1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi we are Trees class and we cannot move\n",
      "Hello!!! My name is  mango\n",
      "My Age is  100\n",
      "------------------------------------------------\n",
      "Hi we are Animals class and we can move!!!\n",
      "Hello!!! My name is  tiger\n",
      "My Age is  10\n"
     ]
    }
   ],
   "source": [
    "# Parent class living_organisms with name and age parameters and intro(), printNames(), printAge() methods\n",
    "# subclasses Animals and Trees inherits the methods printNames(), printAge() methods from super class living_organisms\n",
    "# method intro() is implemented in super class as well as it is overrriden in subclasses and after overriding the method it is implemented differently in each class\n",
    "# this intro() method is implemented differently after overriding hence called polymorphism e.g.\n",
    "\n",
    "class living_organisms:\n",
    "    # constructor\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        \n",
    "    # method which will be overriden in each subclass\n",
    "    def intro(self):\n",
    "        print(\"We are living organisms from earth\")\n",
    "        \n",
    "    # method inherited in each subclass\n",
    "    def printNames(self):\n",
    "        print(\"Hello!!! My name is \", self.name)\n",
    "        \n",
    "    # method inherited in each subclass\n",
    "    def printAge(self):\n",
    "        print(\"My Age is \", self.age)\n",
    "    \n",
    "class Animals(living_organisms):\n",
    "    # constructor\n",
    "    def __init__(self, name, age):\n",
    "        living_organisms.__init__(self, name, age)\n",
    "        \n",
    "    # intro method is implemented differently \n",
    "    def intro(self):\n",
    "        print(\"Hi we are Animals class and we can move!!!\")\n",
    "        \n",
    "\n",
    "class Trees(living_organisms):\n",
    "    # constructor\n",
    "    def __init__(self, name, age):\n",
    "        living_organisms.__init__(self, name, age)\n",
    "        \n",
    "    # intro method is implemented differently \n",
    "    def intro(self):\n",
    "        print(\"Hi we are Trees class and we cannot move\")\n",
    "        \n",
    "\n",
    "# creating Trees class instances and calling its inherited methods as well as overriden method\n",
    "tree = Trees(\"mango\", 100)\n",
    "tree.intro()\n",
    "tree.printNames()\n",
    "tree.printAge()\n",
    "\n",
    "print(\"------------------------------------------------\")\n",
    "# creating Animals class instances and calling its inherited methods as well as overriden method\n",
    "animal = Animals(\"tiger\", 10)\n",
    "animal.intro()\n",
    "animal.printNames()\n",
    "animal.printAge()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfb8c581",
   "metadata": {},
   "source": [
    "## 3. Encapsulation\n",
    "**Encapsulation** allows binding data and associated methods together in a unit i.e class.\n",
    "\n",
    "These principles together allows a programmer to define an interface for applications, i.e. to define all tasks the program is capable to execute and their respective input and output data.\n",
    "\n",
    "### E.g.\n",
    "A good example is a television set. We don’t need to know the inner workings of a TV, in order to use it. All we need to know is how to use the remote control (i.e the interface for the user to interact with the TV).\n",
    "\n",
    "\n",
    "- Direct access to data can be restricted by making required attributes or methods private, just by prefixing it's name with one or two underscores.\n",
    "\n",
    "- An attribute or a method starting with:\n",
    "\n",
    "- no underscores is a public one.\n",
    "\n",
    "- a single underscore is private, however, still accessible from outside.\n",
    "\n",
    "- double underscores is strongly private and not accessible from outside.\n",
    "\n",
    "### Attributes of Employee class is made private and is accessible outside the class only using the method Getter, Setter Methods.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "9f6fcf2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Printing the attributes of object\n",
      "\n",
      "Shubham\n",
      "Sawant\n",
      "456342\n",
      "20\n",
      "\n",
      "Modified Emp Id and Salary\n",
      "\n",
      "Shubham\n",
      "Sawant\n",
      "195578\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "# Creating Employee class and make its empid and salary attributes private by using \"__\" as first.\n",
    "# This private attributes are not accessible outside of the class directly and can be accessed with help of getter method and modification is done with setter methods\n",
    "class Employee(Person):\n",
    "    # Constructor to initialize attributes\n",
    "    def __init__(self, fname, lname, empid, salary):\n",
    "        self.fname = fname\n",
    "        self.lname = lname\n",
    "        self.__empid = empid                       # declaring attribute as private using \"__\"\n",
    "        self.__salary = salary                     # declaring attribute as private using \"__\"\n",
    "        \n",
    "    \n",
    "    # getter method for empid attribute\n",
    "    def get_empid(self):\n",
    "        return self.__empid\n",
    "    \n",
    "    # setter method for empid attribute\n",
    "    def set_empid(self, empid):\n",
    "        self.__empid = empid\n",
    "        \n",
    "    # getter method for salary attribute \n",
    "    def get_salary(self):\n",
    "        return self.__salary\n",
    "    \n",
    "    # setter method for salary attribute\n",
    "    def set_salary(self, salary):\n",
    "        self.__salary = salary\n",
    "        \n",
    "        \n",
    "\n",
    "#Creating the object\n",
    "e1 = Employee('Shubham', 'Sawant', 456342, 20)\n",
    "\n",
    "\n",
    "# Trying to access private attributes is restricted, it will throw error\n",
    "#print(e1.__empid)\n",
    "#print(e1.__salary)\n",
    "\n",
    "# We can access private attributes by using \"getter methods\"\n",
    "print(\"\\nPrinting the attributes of object\\n\")\n",
    "print(e1.fname)\n",
    "print(e1.lname)\n",
    "print(e1.get_empid())\n",
    "print(e1.get_salary())\n",
    "\n",
    "# We can modify private attributes by using \"setter methods\"\n",
    "e1.set_empid(195578)\n",
    "e1.set_salary(30)\n",
    "\n",
    "# We can access private attributes by using \"getter methods\" after modifying attributes to new values\n",
    "print(\"\\nModified Emp Id and Salary\\n\")\n",
    "print(e1.fname)\n",
    "print(e1.lname)\n",
    "print(e1.get_empid())\n",
    "print(e1.get_salary())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7b2c048",
   "metadata": {},
   "source": [
    "## 4. Abstraction\n",
    "\n",
    "- **Abstraction** means working with something you know how to use without knowing how it works internally.\n",
    "\n",
    "- An abstract class can be considered as a blueprint for other classes. It allows you to create a set of methods that must be created within any child classes built from the abstract class. \n",
    "\n",
    "- A class which contains one or more abstract methods is called an abstract class. An abstract method is a method that has a declaration but does not have an implementation. \n",
    "\n",
    "- While we are designing large functional units we use an abstract class. When we want to provide a common interface for different implementations of a component, we use an abstract class. \n",
    "\n",
    "- By default, Python does not provide abstract classes. Python comes with a module that provides the base for defining Abstract Base classes(ABC) and that module name is ABC. \n",
    "\n",
    "- ABC works by decorating methods of the base class as abstract and then registering concrete classes as implementations of the abstract base. A method becomes abstract when decorated with the keyword @abstractmethod."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "9abf39c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi I am triangle and I have 3 sides\n",
      "Hi I am square and I have 4 sides\n",
      "Hi I am pentagon and I have 5 sides\n"
     ]
    }
   ],
   "source": [
    "# Importing the abc module for abstraction\n",
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Abstract class\n",
    "class Polygon(ABC):\n",
    "    @abstractmethod         # abstract method that need to be overriden in subclasses\n",
    "    def sides(self):\n",
    "        pass\n",
    "\n",
    "# Subclass extending Abstract class as parent class\n",
    "class Triangle(Polygon):\n",
    "    # overriding abstract method\n",
    "    def sides(self):\n",
    "        print(\"Hi I am triangle and I have 3 sides\")\n",
    " \n",
    "# Subclass extending Abstract class as parent class \n",
    "class Square(Polygon):\n",
    "    # overriding abstract method\n",
    "    def sides(self):\n",
    "        print(\"Hi I am square and I have 4 sides\")\n",
    "\n",
    "# Subclass extending Abstract class as parent class\n",
    "class Pentagon(Polygon):\n",
    "    def say_hi(self):\n",
    "        print(\"Hi I am Pentagon\")\n",
    "        \n",
    "   # Try Uncommenting this method and it will not throw error because abstract method of parent class will be overriden,\n",
    "   # which is essential while creating instance of subclass extending abstract class\n",
    "   # def sides(self):\n",
    "   #     print(\"Hi I am pentagon and I have 5 sides\")\n",
    "        \n",
    "\n",
    "# Creating object of Triangle class\n",
    "tr = Triangle()\n",
    "tr.sides()\n",
    "\n",
    "# Creating object of Square class\n",
    "sq = Square()\n",
    "sq.sides()\n",
    "\n",
    "# Creating object of Pentagon class\n",
    "pe = Pentagon()\n",
    "pe.sides()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d312dd2f",
   "metadata": {},
   "source": [
    "## Exceptions\n",
    "Try executing the following two expressions\n",
    "\n",
    "10 + ( 1 / 0)\n",
    "\n",
    "36 + '20'\n",
    "\n",
    "The first one throws error message, ZeroDivisionError : division by zero, and\n",
    "\n",
    "Second one throws, TypeError : unsupported operand type(s) for +: 'int' and 'str'.\n",
    "\n",
    "In Python, every error message has two parts. The first part tells what type of exception it is and second part explains the details of error.\n",
    "\n",
    "\n",
    "### Handling Exception\n",
    "Python handles exceptions using code written inside try ... except blocks.\n",
    "\n",
    "A try block is followed by one or more except clauses.\n",
    "\n",
    "The code to be handled is written inside try clause and the code to be executed when an exception occurs is written inside except clause."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5bd2b73f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value of 'a' : 16\n",
      "oops!!!\n",
      "Out of try ... except.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    a = pow(2, 4)\n",
    "    print(\"Value of 'a' :\", a)\n",
    "    b = pow(2, 'hello')   # results in exception\n",
    "    print(\"Value of 'b' :\", b)\n",
    "except TypeError as e:\n",
    "    print('oops!!!')\n",
    "print('Out of try ... except.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c9b0fa3b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Two inputs must be integers.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    a = 2; b = 'hello'\n",
    "    if not (isinstance(a, int) and isinstance(b, int)):\n",
    "        raise TypeError('Two inputs must be integers.')\n",
    "    c = a**b\n",
    "except TypeError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a21e3671",
   "metadata": {},
   "source": [
    "## User Defined Functions\n",
    "There are many built-in exceptions in Python, which are directly or indirectly derived from Exception class.\n",
    "\n",
    "Python also allows a programmer to create custom exceptions, derived from base Exception class.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7637d540",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-11-469e3ebe8b7f>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-11-469e3ebe8b7f>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    Example 1\u001b[0m\n\u001b[1;37m            ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "Example 1\n",
    "class CustomError(Exception):\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "    def __str__(self):\n",
    "        return str(self.value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bdeba70",
   "metadata": {},
   "source": [
    "## Using 'finally' clause\n",
    "finally clause is an optional one that can be used with try ... except clauses.\n",
    "\n",
    "All the statements under finally clause are executed irrespective of exception occurrence.\n",
    "\n",
    "Example 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "03534642",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First call\n",
      "In finally clause.\n",
      "2.0\n",
      "Second call\n",
      "Dividing by Zero.\n",
      "In finally clause.\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def divide(a,b):\n",
    "    try:\n",
    "        result = a / b\n",
    "        return result\n",
    "    except ZeroDivisionError:\n",
    "        print(\"Dividing by Zero.\")\n",
    "    finally:\n",
    "        print(\"In finally clause.\")\n",
    "        \n",
    "print('First call')\n",
    "print(divide(14, 7))\n",
    "print('Second call')\n",
    "print(divide(14, 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fda0e81a",
   "metadata": {},
   "source": [
    "### Using 'else' clause\n",
    "else clause is also an optional clause with try ... except clauses.\n",
    "\n",
    "Statements under else clause are executed only when no exception occurs in try clause.\n",
    "\n",
    "Example 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7b801785",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First ELSE\n",
      "oops!!!\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    a = 14 / 7\n",
    "except ZeroDivisionError:\n",
    "    print('oops!!!')\n",
    "else:\n",
    "    print('First ELSE')\n",
    "try:\n",
    "    a = 14 / 0\n",
    "except ZeroDivisionError:\n",
    "    print('oops!!!')\n",
    "else:\n",
    "    print('Second ELSE')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "89d1ff7a",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (Temp/ipykernel_13996/1369081225.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"C:\\Users\\Shubham\\AppData\\Local\\Temp/ipykernel_13996/1369081225.py\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    len : Returns the length of an object.\u001b[0m\n\u001b[1;37m                  ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "len : Returns the length of an object.\n",
    "\n",
    "e.g : len('hello') -> 5\n",
    "type : Returns the type of an object.\n",
    "\n",
    "e.g : type([2,3]) -> <type list>\n",
    "range : R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "33b05a65",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (Temp/ipykernel_13996/3669720961.py, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"C:\\Users\\Shubham\\AppData\\Local\\Temp/ipykernel_13996/3669720961.py\"\u001b[1;36m, line \u001b[1;32m3\u001b[0m\n\u001b[1;33m    An Iterator is an object, which allows a programmer to traverse through all the elements of a collection, regardless of its specific implementation.\u001b[0m\n\u001b[1;37m       ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Iterator\n",
    "\n",
    "An Iterator is an object, which allows a programmer to traverse through all the elements of a collection, regardless of its specific implementation.\n",
    "\n",
    "Values of an Iterator can be accessed only once and in sequential order.\n",
    "\n",
    "Sample Iterator\n",
    "x = [6, 3, 1]\n",
    "s = iter(x)            \n",
    "print(next(s))      # -> 6\n",
    "print(next(s))      # -> 3\n",
    "print(next(s))      # -> 1\n",
    "print(next(s))      # -> StopIteration Error\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "5c219e58",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3,4,5,6]\n",
    "x = iter(a)\n",
    "\n",
    "while True:\n",
    "    try :\n",
    "        print(next(x))\n",
    "    \n",
    "    except StopIteration:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "99d088b7",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'generator_123' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_13996/3181218813.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mgenerator_123\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'generator_123' is not defined"
     ]
    }
   ],
   "source": [
    "a = generator_123()\n",
    "for i in a:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "08259023",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object generator_123 at 0x000001F33B920E40>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def generator_123():\n",
    "    yield 1\n",
    "    yield 2\n",
    "    yield 3\n",
    "    \n",
    "generator_123()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "082bffbc",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (Temp/ipykernel_13996/105615208.py, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"C:\\Users\\Shubham\\AppData\\Local\\Temp/ipykernel_13996/105615208.py\"\u001b[1;36m, line \u001b[1;32m3\u001b[0m\n\u001b[1;33m    A Generator object is an iterator, whose values are created at the time of accessing them.\u001b[0m\n\u001b[1;37m      ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "\n",
    "Generator\n",
    "\n",
    "A Generator object is an iterator, whose values are created at the time of accessing them.\n",
    "\n",
    "A generator can be obtained either from a generator expression or a generator function.\n",
    "\n",
    "Example\n",
    "x = [6, 3, 1]\n",
    "g = (i**2 for i in x)  # generator expression\n",
    "print(next(g))      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee1cb9c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "List Comprehensions\n",
    "Alternative to for loops.\n",
    "\n",
    "More concise, readable, efficient and mimic functional programming style.\n",
    "\n",
    "Used to:\n",
    "\n",
    "Apply a method to all or specific elements of a list, and\n",
    "\n",
    "Filter elements of a list satisfying specific criteria.\n",
    "\n",
    "Example\n",
    "x = [6, 3, 1]\n",
    "y = [ i**2 for i in x ]   # List Comprehension expression\n",
    "print(y)                  # -> [36, 9, 1] "
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}