Exp_5_Python23_24.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8mNvZ4r2O6xD"
      },
      "source": [
        "**EXP 5**\n",
        "AIM: Write python programs to implement Classes & objects, Constructors, Inheritance & Polymorphism."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fFxyWonZhhBd"
      },
      "source": [
        "**Introduction to Object-Oriented Programming in Python:**\n",
        "\n",
        "\n",
        " In programming languages, mainly there are two approaches that are used to write program or code.\n",
        "\n",
        "\n",
        "1.  Procedural Programming\n",
        "2.  Object-Oriented Programming\n",
        "\n",
        "\n",
        "\n",
        "The procedure we are following till now is the “Procedural Programming” approach. So, in this session, we will learn about Object Oriented Programming (OOP). The basic idea of object-oriented programming (OOP) in Python is to use classes and objects to represent real-world concepts and entities.\n",
        "\n",
        "A class is a blueprint or template for creating objects. It defines the properties and methods that an object of that class will have. Properties are the data or state of an object, and methods are the actions or behaviors that an object can perform.\n",
        "\n",
        "An object is an instance of a class, and it contains its own data and methods. For example, you could create a class called \"Person\" that has properties such as name and age, and methods such as speak() and walk(). Each instance of the Person class would be a unique object with its own name and age, but they would all have the same methods to speak and walk.\n",
        "\n",
        "One of the key features of OOP in Python is encapsulation, which means that the internal state of an object is hidden and can only be accessed or modified through the object's methods. This helps to protect the object's data and prevent it from being modified in unexpected ways.\n",
        "\n",
        "Another key feature of OOP in Python is inheritance, which allows new classes to be created that inherit the properties and methods of an existing class. This allows for code reuse and makes it easy to create new classes that have similar functionality to existing classes.\n",
        "\n",
        "Polymorphism is also supported in Python, which means that objects of different classes can be treated as if they were objects of a common class. This allows for greater flexibility in code and makes it easier to write code that can work with multiple types of objects.\n",
        "\n",
        "In summary, OOP in Python allows developers to model real-world concepts and entities using classes and objects, encapsulate data, reuse code through inheritance, and write more flexible code through polymorphism."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JWZZISVRhhBf"
      },
      "source": [
        "**Python Class and Objects**\n",
        "\n",
        "A class is a blueprint or a template for creating objects, providing initial values for state (member variables or attributes), and implementations of behavior (member functions or methods). The user-defined objects are created using the class keyword.\n",
        "\n",
        "Creating a Class:\n",
        "Let us now create a class using the class keyword."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Uvd92varhhBf"
      },
      "outputs": [],
      "source": [
        "class Details:\n",
        "    name = \"Sharvari\"\n",
        "    age = 32"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2kGS7ArkhhBg"
      },
      "source": [
        "Creating an Object:\n",
        "Object is the instance of the class used to access the properties of the class Now lets create an object of the class."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nVRW0DARhhBg"
      },
      "outputs": [],
      "source": [
        "obj1 = Details()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MyzegpMfhhBg"
      },
      "source": [
        "class Details:\n",
        "    name = \"Sharvari\"\n",
        "    age = 32\n",
        "\n",
        "obj1 = Details()\n",
        "print(obj1.name)\n",
        "print(obj1.age)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1_VN-SpVhhBg"
      },
      "source": [
        "**self parameter**\n",
        "\n",
        "The self parameter is a reference to the current instance of the class, and is used to access variables that belongs to the class.\n",
        "\n",
        "It must be provided as the extra parameter inside the method definition.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "g6cvxcInhhBh"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "My name is Rohan and I'm 20 years old.\n"
          ]
        }
      ],
      "source": [
        "class Details:\n",
        "    name = \"Rohan\"\n",
        "    age = 20\n",
        "\n",
        "    def desc(self):\n",
        "        print(\"My name is\", self.name, \"and I'm\", self.age, \"years old.\")\n",
        "\n",
        "obj1 = Details()\n",
        "obj1.desc()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0t2ctlPPhhBh"
      },
      "source": [
        "**Constructors**\n",
        "\n",
        "A constructor is a special method in a class used to create and initialize an object of a class. There are different types of constructors. Constructor is invoked automatically when an object of a class is created.\n",
        "\n",
        "A constructor is a unique function that gets called automatically when an object is created of a class. The main purpose of a constructor is to initialize or assign values to the data members of that class. It cannot return any value other than None.\n",
        "\n",
        "Syntax of Python Constructor\n",
        "\n",
        "def __init__(self):\n",
        "\n",
        "> initializations\n",
        "\n",
        "\n",
        "\n",
        "init is one of the reserved functions in Python. In Object Oriented Programming, it is known as a constructor.\n",
        "\n",
        "> Types of Constructors in Python\n",
        "\n",
        "1.   Parameterized Constructor\n",
        "2.   Default Constructor\n",
        "\n",
        "\n",
        "Parameterized Constructor in Python\n",
        "When the constructor accepts arguments along with self, it is known as parameterized constructor.\n",
        "\n",
        "These arguments can be used inside the class to assign the values to the data members.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "yEMzWwUThhBh"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Crab belongs to the Crustaceans group.\n"
          ]
        }
      ],
      "source": [
        "class Details:\n",
        "    def __init__(self, animal, group):\n",
        "        self.animal = animal\n",
        "        self.group = group\n",
        "\n",
        "obj1 = Details(\"Crab\", \"Crustaceans\")\n",
        "print(obj1.animal, \"belongs to the\", obj1.group, \"group.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s1RqCM7GhhBh"
      },
      "source": [
        "**Default Constructor in Python**\n",
        "When the constructor doesn't accept any arguments from the object and has only one argument, self, in the constructor, it is known as a Default constructor.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3NcVHQd0hhBh"
      },
      "outputs": [],
      "source": [
        "class Details:\n",
        "  def __init__(self):\n",
        "    print(\"animal Crab belongs to Crustaceans group\")\n",
        "obj1=Details()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "neBP9DD2hhBi"
      },
      "source": [
        "**Getters**\n",
        "Getters in Python are methods that are used to access the values of an object's properties. They are used to return the value of a specific property, and are typically defined using the @property decorator. Here is an example of a simple class with a getter method:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "lXjhyxowhhBi"
      },
      "outputs": [],
      "source": [
        "class MyClass:\n",
        "    def __init__(self, value):\n",
        "        self._value = value\n",
        "\n",
        "    @property\n",
        "    def value(self):\n",
        "        return self._value"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N8rC-BbghhBi"
      },
      "source": [
        "In this example, the MyClass class has a single property, _value, which is initialized in the init method. The value method is defined as a getter using the @property decorator, and is used to return the value of the _value property.\n",
        "\n",
        "To use the getter, we can create an instance of the MyClass class, and then access the value property as if it were an attribute:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "bZt3-iy5hhBi"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "obj = MyClass(10)\n",
        "obj.value"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1gb-FnENhhBi"
      },
      "source": [
        "**Setters**\n",
        "It is important to note that the getters do not take any parameters and we cannot set the value through getter method.For that we need setter method which can be added by decorating method with @property_name.setter\n",
        "\n",
        "Here is an example of a class with both getter and setter:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7uedlmzohhBi"
      },
      "outputs": [],
      "source": [
        "class MyClass:\n",
        "    def __init__(self, value):\n",
        "        self._value = value\n",
        "\n",
        "    @property\n",
        "    def value(self):\n",
        "        return self._value\n",
        "\n",
        "    @value.setter\n",
        "    def value(self, new_value):\n",
        "        self._value = new_value"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3vY7DPnWhhBi"
      },
      "outputs": [],
      "source": [
        "obj = MyClass(10)\n",
        "obj.value = 20\n",
        "obj.value"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DJrjTaZUhhBi"
      },
      "source": [
        "In conclusion, getters are a convenient way to access the values of an object's properties, while keeping the internal representation of the property hidden. This can be useful for encapsulation and data validation."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tioSuFVChhBi"
      },
      "source": [
        "**Inheritance in python**\n",
        "\n",
        "When a class derives from another class. The child class will inherit all the public and protected properties and methods from the parent class. In addition, it can have its own properties and methods,this is called as inheritance.\n",
        "\n",
        "Python Inheritance Syntax\n",
        "class BaseClass:\n",
        "  Body of base class\n",
        "class DerivedClass(BaseClass):\n",
        "  Body of derived class\n",
        "\n",
        "Derived class inherits features from the base class where new features can be added to it. This results in re-usability of code.\n",
        "\n",
        "Types of inheritance:\n",
        "Single inheritance\n",
        "Multiple inheritance\n",
        "Multilevel inheritance\n",
        "Hierarchical Inheritance\n",
        "Hybrid Inheritance"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P4IPFe2RhhBi"
      },
      "source": [
        "Single Inheritance:\n",
        "Single inheritance enables a derived class to inherit properties from a single parent class, thus enabling code reusability and the addition of new features to existing code.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yIuR_-9QhhBj"
      },
      "outputs": [],
      "source": [
        "class Parent:\n",
        "    def func1(self):\n",
        "        print(\"This function is in parent class.\")\n",
        "\n",
        "class Child(Parent):\n",
        "    def func2(self):\n",
        "        print(\"This function is in child class.\")\n",
        "\n",
        "object = Child()\n",
        "object.func1()\n",
        "object.func2()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2ns11ACmhhBj"
      },
      "source": [
        "Multiple Inheritance:\n",
        "When a class can be derived from more than one base class this type of inheritance is called multiple inheritances. In multiple inheritances, all the features of the base classes are inherited into the derived class.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "lFHK4y60hhBj"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Father name is : Daddy\n",
            "Mother name is : Mommy\n"
          ]
        }
      ],
      "source": [
        "class Mother:\n",
        "    mothername = \"\"\n",
        "\n",
        "    def mother(self):\n",
        "        print(self.mothername)\n",
        "\n",
        "\n",
        "class Father:\n",
        "    fathername = \"\"\n",
        "\n",
        "    def father(self):\n",
        "        print(self.fathername)\n",
        "\n",
        "\n",
        "class Son(Mother, Father):\n",
        "    def parents(self):\n",
        "        print(\"Father name is :\", self.fathername)\n",
        "        print(\"Mother name is :\", self.mothername)\n",
        "s1 = Son()\n",
        "s1.fathername = \"Daddy\"\n",
        "s1.mothername = \"Mommy\"\n",
        "s1.parents()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fYBGEM_uhhBj"
      },
      "source": [
        "Multilevel Inheritance :\n",
        "In multilevel inheritance, features of the base class and the derived class are further inherited into the new derived class. This is similar to a relationship representing a child and a grandfather."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "0qBinJXThhBj"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Lal mani\n",
            "Grandfather name : Lal mani\n",
            "Father name : Rampal\n",
            "Son name : Prince\n"
          ]
        }
      ],
      "source": [
        "class Grandfather:\n",
        "\n",
        "    def __init__(self, grandfathername):\n",
        "        self.grandfathername = grandfathername\n",
        "\n",
        "\n",
        "class Father(Grandfather):\n",
        "    def __init__(self, fathername, grandfathername):\n",
        "        self.fathername = fathername\n",
        "        Grandfather.__init__(self, grandfathername)\n",
        "class Son(Father):\n",
        "    def __init__(self, sonname, fathername, grandfathername):\n",
        "        self.sonname = sonname\n",
        "        Father.__init__(self, fathername, grandfathername)\n",
        "\n",
        "    def print_name(self):\n",
        "        print('Grandfather name :', self.grandfathername)\n",
        "        print(\"Father name :\", self.fathername)\n",
        "        print(\"Son name :\", self.sonname)\n",
        "s1 = Son('Prince', 'Rampal', 'Lal mani')\n",
        "print(s1.grandfathername)\n",
        "s1.print_name()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U-OE9oZ8hhBj"
      },
      "source": [
        "Hierarchical Inheritance:\n",
        "When more than one derived class are created from a single base this type of inheritance is called hierarchical inheritance. In this program, we have a parent (base) class and two child (derived) classes.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "_VMIUlZEhhBj"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "This function is in parent class.\n",
            "This function is in child 1.\n",
            "This function is in parent class.\n",
            "This function is in child 2.\n"
          ]
        }
      ],
      "source": [
        "class Parent:\n",
        "    def func1(self):\n",
        "        print(\"This function is in parent class.\")\n",
        "\n",
        "class Child1(Parent):\n",
        "    def func2(self):\n",
        "        print(\"This function is in child 1.\")\n",
        "\n",
        "class Child2(Parent):\n",
        "    def func3(self):\n",
        "        print(\"This function is in child 2.\")\n",
        "\n",
        "object1 = Child1()\n",
        "object2 = Child2()\n",
        "object1.func1()\n",
        "object1.func2()\n",
        "object2.func1()\n",
        "object2.func3()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tx8xdG9LhhBj"
      },
      "source": [
        "Hybrid Inheritance:\n",
        "Inheritance consisting of multiple types of inheritance is called hybrid inheritance."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "KvNGvzZDhhBj"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "This function is in school.\n",
            "This function is in student 1. \n"
          ]
        }
      ],
      "source": [
        "class School:\n",
        "    def func1(self):\n",
        "        print(\"This function is in school.\")\n",
        "\n",
        "\n",
        "class Student1(School):\n",
        "    def func2(self):\n",
        "        print(\"This function is in student 1. \")\n",
        "\n",
        "\n",
        "class Student2(School):\n",
        "    def func3(self):\n",
        "        print(\"This function is in student 2.\")\n",
        "\n",
        "\n",
        "class Student3(Student1, School):\n",
        "    def func4(self):\n",
        "        print(\"This function is in student 3.\")\n",
        "\n",
        "object = Student3()\n",
        "object.func1()\n",
        "object.func2()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "_0PHK7FShhBj"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The name of Employee: 400 is Rohan Das\n",
            "The name of Employee: 4100 is Harry\n",
            "The default langauge is Python\n"
          ]
        }
      ],
      "source": [
        "class Employee:\n",
        "  def __init__(self, name, id):\n",
        "    self.name = name\n",
        "    self.id = id\n",
        "\n",
        "  def showDetails(self):\n",
        "    print(f\"The name of Employee: {self.id} is {self.name}\")\n",
        "\n",
        "class Programmer(Employee):\n",
        "  def showLanguage(self):\n",
        "    print(\"The default langauge is Python\")\n",
        "\n",
        "\n",
        "e1 = Employee(\"Rohan Das\", 400)\n",
        "e1.showDetails()\n",
        "e2 = Programmer(\"Harry\", 4100)\n",
        "e2.showDetails()\n",
        "e2.showLanguage()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Js5_04yyQBoG"
      },
      "source": [
        "**Super keyword in Python**\n",
        "\n",
        "> The super() keyword in Python is used to refer to the parent class. It is especially useful when a class inherits from multiple parent classes and you want to call a method from one of the parent classes.\n",
        "\n",
        "When a class inherits from a parent class, it can override or extend the methods defined in the parent class. However, sometimes you might want to use the parent class method in the child class. This is where the super() keyword comes in handy.\n",
        "\n",
        "Here's an example of how to use the super() keyword in a simple inheritance scenario:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "5KD-k_HsQLkP"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "This is the child method.\n",
            "This is the parent method.\n"
          ]
        }
      ],
      "source": [
        "class ParentClass:\n",
        "    def parent_method(self):\n",
        "        print(\"This is the parent method.\")\n",
        "\n",
        "class ChildClass(ParentClass):\n",
        "    def child_method(self):\n",
        "        print(\"This is the child method.\")\n",
        "        super().parent_method()\n",
        "\n",
        "child_object = ChildClass()\n",
        "child_object.child_method()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Msr3ENPiQkTK"
      },
      "source": [
        "In this example, we have a ParentClass with a parent_method and a ChildClass that inherits from ParentClass and overrides the child_method. When the child_method is called, it first prints \"This is the child method.\" and then calls the parent_method using the super() keyword.\n",
        "\n",
        "The super() keyword is also useful when a class inherits from multiple parent classes. In this case, you can specify the parent class from which you want to call the method.\n",
        "\n",
        "Here's an example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "sU08hl9KQnhr"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "This is the child method.\n",
            "This is the parent method of ParentClass1.\n"
          ]
        }
      ],
      "source": [
        "class ParentClass1:\n",
        "    def parent_method(self):\n",
        "        print(\"This is the parent method of ParentClass1.\")\n",
        "\n",
        "class ParentClass2:\n",
        "    def parent_method(self):\n",
        "        print(\"This is the parent method of ParentClass2.\")\n",
        "\n",
        "class ChildClass(ParentClass1, ParentClass2):\n",
        "    def child_method(self):\n",
        "        print(\"This is the child method.\")\n",
        "        super().parent_method()\n",
        "\n",
        "child_object = ChildClass()\n",
        "child_object.child_method()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jp9lad3TQu1P"
      },
      "source": [
        "In this example, the ChildClass inherits from both ParentClass1 and ParentClass2. The child_method calls the parent_method of the first parent class using the super() keyword.\n",
        "\n",
        "In conclusion, the super() keyword is a useful tool in Python when you want to call a parent class method in a child class. It can be used in inheritance scenarios with a single parent class or multiple parent classes."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X96Gyyj9RARb"
      },
      "source": [
        "Method Overriding in Python\n",
        "Method overriding is a powerful feature in object-oriented programming that allows you to redefine a method in a derived class. The method in the derived class is said to override the method in the base class. When you create an instance of the derived class and call the overridden method, the version of the method in the derived class is executed, rather than the version in the base class.\n",
        "\n",
        "In Python, method overriding is a way to customize the behavior of a class based on its specific needs. For example, consider the following base class:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lJcjT6fSRDj1"
      },
      "outputs": [],
      "source": [
        "class Shape:\n",
        "    def area(self):\n",
        "        pass"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ak3KXUt6RHWD"
      },
      "source": [
        "In this base class, the area method is defined, but does not have any implementation. If you want to create a derived class that represents a circle, you can override the area method and provide an implementation that calculates the area of a circle:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gR8Y8BUFRIF3"
      },
      "outputs": [],
      "source": [
        "class Circle(Shape):\n",
        "    def __init__(self, radius):\n",
        "        self.radius = radius\n",
        "\n",
        "    def area(self):\n",
        "        return 3.14 * self.radius * self.radius"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rPZRNcgcRMyc"
      },
      "source": [
        "In this example, the Circle class inherits from the Shape class, and overrides the area method. The new implementation of the area method calculates the area of a circle, based on its radius.\n",
        "\n",
        "It's important to note that when you override a method, the new implementation must have the same method signature as the original method. This means that the number and type of arguments, as well as the return type, must be the same.\n",
        "\n",
        "Another way to customize the behavior of a class is to call the base class method from the derived class method. To do this, you can use the super function. The super function allows you to call the base class method from the derived class method, and can be useful when you want to extend the behavior of the base class method, rather than replace it.\n",
        "\n",
        "For example, consider the following base class:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "FHILp8wPRPQ_"
      },
      "outputs": [],
      "source": [
        "class Shape:\n",
        "    def area(self):\n",
        "        print(\"Calculating area...\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nXqA-bhnRSDv"
      },
      "source": [
        "In this base class, the area method prints a message indicating that the area is being calculated. If you want to create a derived class that represents a circle, and you also want to print a message indicating the type of shape, you can use the super function to call the base class method, and add your own message:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "icfgCsMJRU3v"
      },
      "outputs": [],
      "source": [
        "class Circle(Shape):\n",
        "    def __init__(self, radius):\n",
        "        self.radius = radius\n",
        "\n",
        "    def area(self):\n",
        "        print(\"Calculating area of a circle...\")\n",
        "        super().area()\n",
        "        return 3.14 * self.radius * self.radius"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qrsubAvuRYar"
      },
      "source": [
        "In this example, the Circle class overrides the area method, and calls the base class method using the super function. This allows you to extend the behavior of the base class method, while still maintaining its original behavior.\n",
        "\n",
        "In conclusion, method overriding is a powerful feature in Python that allows you to customize the behavior of a class based on its specific needs. By using method overriding, you can create more robust and reliable code, and ensure that your classes behave in the way that you need them to. Additionally, by using the super function, you can extend the behavior of a base class method, rather than replace it, giving you even greater flexibility and control over the behavior of your classes."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g2IQ3IZLhhBj"
      },
      "source": [
        "**Access Specifiers/Modifiers**\n",
        "Access specifiers or access modifiers in python programming are used to limit the access of class variables and class methods outside of class while implementing the concepts of inheritance.\n",
        "\n",
        "Let us see the each one of access specifiers in detail:\n",
        "\n",
        "Types of access specifiers\n",
        "Public access modifier\n",
        "Private access modifier\n",
        "Protected access modifier\n",
        "Public Access Specifier in Python\n",
        "All the variables and methods (member functions) in python are by default public. Any instance variable in a class followed by the ‘self’ keyword ie. self.var_name are public accessed.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HT6pOdxDhhBj"
      },
      "outputs": [],
      "source": [
        "class Student:\n",
        "    # constructor is defined\n",
        "    def __init__(self, age, name):\n",
        "        self.age = age               # public variable\n",
        "        self.name = name             # public variable\n",
        "\n",
        "obj = Student(21,\"Harry\")\n",
        "print(obj.age)\n",
        "print(obj.name)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2dl_UKA_hhBj"
      },
      "source": [
        "**Private Access Modifier**\n",
        "\n",
        "By definition, Private members of a class (variables or methods) are those members which are only accessible inside the class. We cannot use private members outside of class.\n",
        "\n",
        "In Python, there is no strict concept of \"private\" access modifiers like in some other programming languages. However, a convention has been established to indicate that a variable or method should be considered private by prefixing its name with a double underscore (__). This is known as a \"weak internal use indicator\" and it is a convention only, not a strict rule. Code outside the class can still access these \"private\" variables and methods, but it is generally understood that they should not be accessed or modified."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "V10-f2AthhBj"
      },
      "outputs": [],
      "source": [
        "class Student:\n",
        "    def __init__(self, age, name):\n",
        "        self.__age = age      # An indication of private variable\n",
        "\n",
        "        def __funName(self):  # An indication of private function\n",
        "            self.y = 34\n",
        "            print(self.y)\n",
        "\n",
        "class Subject(Student):\n",
        "    pass\n",
        "\n",
        "obj = Student(21,\"Harry\")\n",
        "obj1 = Subject\n",
        "\n",
        "# calling by object of class Student\n",
        "print(obj.__age)\n",
        "print(obj.__funName())\n",
        "\n",
        "# calling by object  of class Subject\n",
        "print(obj1.__age)\n",
        "print(obj1.__funName())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cjs6OMwehhBk"
      },
      "source": [
        "Private members of a class cannot be accessed or inherited outside of class. If we try to access or to inherit the properties of private members to child class (derived class). Then it will show the error.\n",
        "\n",
        "Name mangling\n",
        "Name mangling in Python is a technique used to protect class-private and superclass-private attributes from being accidentally overwritten by subclasses. Names of class-private and superclass-private attributes are transformed by the addition of a single leading underscore and a double leading underscore respectively."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7kGuusUjhhBk"
      },
      "outputs": [],
      "source": [
        "class MyClass:\n",
        "    def __init__(self):\n",
        "        self._nonmangled_attribute = \"I am a nonmangled attribute\"\n",
        "        self.__mangled_attribute = \"I am a mangled attribute\"\n",
        "\n",
        "my_object = MyClass()\n",
        "\n",
        "print(my_object._nonmangled_attribute) # Output: I am a nonmangled attribute\n",
        "print(my_object.__mangled_attribute) # Throws an AttributeError\n",
        "print(my_object._MyClass__mangled_attribute) # Output: I am a mangled attribute"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sBKgrJ7WhhBk"
      },
      "source": [
        "In the example above, the attribute _nonmangled_attribute is marked as nonmangled by convention, but can still be accessed from outside the class. The attribute __mangled_attribute is private and its name is \"mangled\" to _MyClass__mangled_attribute, so it can't be accessed directly from outside the class, but you can access it by calling _MyClass__mangled_attribute"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0twfwRlihhBt"
      },
      "source": [
        "Protected Access Modifier\n",
        "In object-oriented programming (OOP), the term \"protected\" is used to describe a member (i.e., a method or attribute) of a class that is intended to be accessed only by the class itself and its subclasses. In Python, the convention for indicating that a member is protected is to prefix its name with a single underscore (_). For example, if a class has a method called _my_method, it is indicating that the method should only be accessed by the class itself and its subclasses.\n",
        "\n",
        "It's important to note that the single underscore is just a naming convention, and does not actually provide any protection or restrict access to the member. The syntax we follow to make any variable protected is to write variable name followed by a single underscore (_) ie. _varName.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "Pg_Ibx7PhhBt"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Harry\n",
            "CodeWithHarry\n",
            "Harry\n",
            "CodeWithHarry\n"
          ]
        }
      ],
      "source": [
        "class Student:\n",
        "    def __init__(self):\n",
        "        self._name = \"Harry\"\n",
        "\n",
        "    def _funName(self):      # protected method\n",
        "        return \"CodeWithHarry\"\n",
        "\n",
        "class Subject(Student):       #inherited class\n",
        "    pass\n",
        "\n",
        "obj = Student()\n",
        "obj1 = Subject()\n",
        "\n",
        "# calling by object of Student class\n",
        "print(obj._name)\n",
        "print(obj._funName())\n",
        "# calling by object of Subject class\n",
        "print(obj1._name)\n",
        "print(obj1._funName())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vxo9aTyMSKNE"
      },
      "source": [
        "**Excercise:**\n",
        "\n",
        "*   Define a method in the inner class and access the same by code outside the outer class\n",
        "*   Create a class Rectangle. The class has 2 attributes, length and width, each of which defaults to 0. It has methods to calculate the perimeter and area of the rectangle. It has set and get methods for both length and width. The set method should verify that length and width are floating point numbers larger than 0.0 and less than 20.0\n",
        "*   WAP to arrange the names of students in descending order of their totalmarks, input data consists of student’s details such as names, ID. no, marks of math, physics, and chemistry.\n",
        "*   WAP to display area of square and rectangle using constructor."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iQCBV3xgR3jn"
      },
      "source": [
        "Questions for write-up:\n",
        "*   What does Python's init function do?\n",
        "*   What is the purpose of the super() function in Python?\n",
        "*   How do you implement multiple inheritance in Python?\n",
        "*   What is the constructor in a Python class\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.12.1"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}