oop_with_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# **Implementation of Classes and Objects**\n",
        "**Definition:**\n",
        "Classes and objects are the fundamental building blocks of object-oriented programming (OOP) in Python. A class defines a blueprint for objects, and objects are instances of classes.\n",
        "\n",
        "**Importance:**\n",
        "Promotes code reusability.\n",
        "Encapsulates data and functions together.\n",
        "\n",
        "Examples:\n",
        "\n",
        "**Defining a Class and Creating an Object:**"
      ],
      "metadata": {
        "id": "uDQHdH_7CqF7"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BaUoTK-SCbS2",
        "outputId": "e9378067-2f2f-4631-b0e9-f9b02be6958a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Buddy is barking.\n"
          ]
        }
      ],
      "source": [
        "# Defining a class and creating an object\n",
        "class Dog:\n",
        "    def __init__(self, name, age):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "\n",
        "    def bark(self):\n",
        "        return f'{self.name} is barking.'\n",
        "\n",
        "dog1 = Dog('Buddy', 3)\n",
        "print(dog1.bark())  # Output: Buddy is barking."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Explanation:**\n",
        "\n",
        "\n",
        "\n",
        "*   class Dog:: Defines a class named Dog.\n",
        "*  def init(self, name, age):: Defines the constructor method for the class, which initializes the object's attributes.\n",
        "*  def bark(self):: Defines a method named bark that returns a string.\n",
        "*   dog1 = Dog('Buddy', 3):: Creates an instance of the Dog class named dog1 with attributes name='Buddy' and age=3.\n",
        "* print(dog1.bark()): Calls the bark method on the dog1 object and prints the result."
      ],
      "metadata": {
        "id": "TD166O-HDBgb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **OOP Principles in Python**\n",
        "**Definition:**\n",
        "Object-oriented programming (OOP) in Python is based on four main principles: *Encapsulation, Inheritance, Polymorphism, and Abstraction.*\n",
        "\n",
        "**Importance:**\n",
        "* Encapsulation: Bundles data with methods that operate on the data.\n",
        "*Inheritance: Enables new classes to inherit attributes and methods from existing classes.\n",
        "* Polymorphism: Allows methods to be used interchangeably between different classes.\n",
        "* Abstraction: Hides complex implementation details and shows only the necessary features.\n",
        "\n",
        "**Examples:**\n",
        "\n",
        "**Encapsulation:**"
      ],
      "metadata": {
        "id": "A0HHX0owECSn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example of encapsulation\n",
        "class Car:\n",
        "    def __init__(self, make, model):\n",
        "        self.__make = make\n",
        "        self.__model = model\n",
        "\n",
        "    def get_car_info(self):\n",
        "        return f'Car: {self.__make} {self.__model}'\n",
        "\n",
        "car = Car('Toyota', 'Corolla')\n",
        "print(car.get_car_info())  # Output: Car: Toyota Corolla"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TEiRfnUTEwiI",
        "outputId": "ae5df26e-e2e9-4bf2-d568-3a49ac243b0b"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Car: Toyota Corolla\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "**Explanation:**\n",
        "\n",
        "* class Car:: Defines a class named Car.\n",
        "* def **init**(self, make, model):: Defines the constructor method for the class, which initializes the object's attributes.\n",
        "* self.**make and self**.model: Private attributes.\n",
        "* def get_car_info(self):: Defines a method named get_car_info that returns the car's information.\n",
        "* car = Car('Toyota', 'Corolla'):: Creates an instance of the Car class named car with attributes make='Toyota' and model='Corolla'.\n",
        "* print(car.get_car_info()): Calls the get_car_info method on the car object and prints the result.\n",
        "\n",
        "**Inheritance:**"
      ],
      "metadata": {
        "id": "_F6zU52IE3ua"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example of inheritance\n",
        "class Animal:\n",
        "    def __init__(self, name):\n",
        "        self.name = name\n",
        "\n",
        "    def speak(self):\n",
        "        pass\n",
        "\n",
        "class Dog(Animal):\n",
        "    def speak(self):\n",
        "        return f'{self.name} says Woof!'\n",
        "\n",
        "dog = Dog('Buddy')\n",
        "print(dog.speak())  # Output: Buddy says Woof!"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gO4bcEGgFaIJ",
        "outputId": "8445394c-0370-433a-a4ea-a4496663a70f"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Buddy says Woof!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Explanation:**\n",
        "- class Animal:: Defines a base class named Animal.\n",
        "- class Dog(Animal):: Defines a derived class named Dog that inherits from the Animal class.\n",
        "- def speak(self):: Overrides the speak method from the base class.\n",
        "- dog = Dog('Buddy'):: Creates an instance of the Dog class named dog with the attribute name='Buddy'.\n",
        "- print(dog.speak()): Calls the speak method on the dog object and prints the result.\n",
        "\n",
        "**Polymorphism:**"
      ],
      "metadata": {
        "id": "lg5ig9zAFc4Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example of polymorphism\n",
        "class Cat(Animal):\n",
        "    def speak(self):\n",
        "        return f'{self.name} says Meow!'\n",
        "\n",
        "animals = [Dog('Buddy'), Cat('Whiskers')]\n",
        "for animal in animals:\n",
        "    print(animal.speak())\n",
        "# Output:\n",
        "# Buddy says Woof!\n",
        "# Whiskers says Meow!"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zEb4etkRFjDE",
        "outputId": "1a4949d7-249f-44a7-f77d-82a29170d027"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Buddy says Woof!\n",
            "Whiskers says Meow!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Explanation:**\n",
        "- class Cat(Animal):: Defines a derived class named Cat that inherits from the Animal class.\n",
        "- def speak(self):: Overrides the speak method from the base class.\n",
        "- animals = [Dog('Buddy'), Cat('Whiskers')]: Creates a list of Animal objects.\n",
        "- for animal in animals:: Iterates over the list of animals and calls the speak method on each object, demonstrating polymorphism.\n",
        "\n",
        "**Abstraction:**"
      ],
      "metadata": {
        "id": "oeO1sp56Fn2N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example of abstraction\n",
        "from abc import ABC, abstractmethod\n",
        "\n",
        "class Shape(ABC):\n",
        "    @abstractmethod\n",
        "    def area(self):\n",
        "        pass\n",
        "\n",
        "class Rectangle(Shape):\n",
        "    def __init__(self, width, height):\n",
        "        self.width = width\n",
        "        self.height = height\n",
        "\n",
        "    def area(self):\n",
        "        return self.width * self.height\n",
        "\n",
        "rect = Rectangle(3, 4)\n",
        "print(rect.area())  # Output: 12"
      ],
      "metadata": {
        "id": "-3uMQEAXFpQ6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Explanation:**\n",
        "- from abc import ABC, abstractmethod:: Imports the ABC (Abstract Base Class) and abstractmethod from the abc module.\n",
        "- class Shape(ABC):: Defines an abstract base class named Shape.\n",
        "- @abstractmethod def area(self):: Declares an abstract method named area that must be implemented by derived classes.\n",
        "- class Rectangle(Shape):: Defines a derived class named Rectangle that inherits from the Shape class.\n",
        "- def __init__(self, width, height):: Defines the constructor method for the Rectangle class.\n",
        "- def area(self):: Implements the area method for the Rectangle class.\n",
        "- rect = Rectangle(3, 4):: Creates an instance of the Rectangle class named rect with attributes width=3 and height=4.\n",
        "- print(rect.area()): Calls the area method on the rect object and prints the result."
      ],
      "metadata": {
        "id": "AyUImXnWFsni"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#  Class Variables and Functions\n",
        "### Definition:\n",
        "Class variables are variables that are shared among all instances of a class. Class functions (or methods) are functions defined within a class and operate on instances of that class.\n",
        "\n",
        "### Importance:\n",
        "- Class variables provide a way to store data that is shared across all instances of a class.\n",
        "- Class methods enable the encapsulation of behavior related to class instances.\n",
        "\n",
        "### Examples:\n",
        "**Class Variables:**"
      ],
      "metadata": {
        "id": "mW9MA4pgF15p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example of class variables\n",
        "class Employee:\n",
        "    raise_amount = 1.05  # Class variable\n",
        "\n",
        "    def __init__(self, name, salary):\n",
        "        self.name = name\n",
        "        self.salary = salary\n",
        "\n",
        "    def apply_raise(self):\n",
        "        self.salary = int(self.salary * Employee.raise_amount)\n",
        "\n",
        "emp1 = Employee('Alice', 50000)\n",
        "emp1.apply_raise()\n",
        "print(emp1.salary)  # Output: 52500"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XwfXDWoSGMOO",
        "outputId": "d30cb4cd-c178-4572-e6ac-3c10c79f5d84"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "52500\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Explanation:**\n",
        "- class Employee:: Defines a class named Employee.\n",
        "- raise_amount = 1.05: Class variable that is shared among all instances of the class.\n",
        "- def __init__(self, name, salary):: Defines the constructor method for the class.\n",
        "- def apply_raise(self):: Defines a method that applies a raise to the employee's salary using the class variable.\n",
        "- emp1 = Employee('Alice', 50000):: Creates an instance of the Employee class named emp1 with attributes name='Alice' and salary=50000.\n",
        "- emp1.apply_raise(): Calls the apply_raise method on the emp1 object.\n",
        "- print(emp1.salary): Prints the salary of the emp1 object after applying the raise.\n",
        "\n",
        "**Class Methods:**"
      ],
      "metadata": {
        "id": "R1DiooKSGPlg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example of class methods\n",
        "class Circle:\n",
        "    pi = 3.14159  # Class variable\n",
        "\n",
        "    def __init__(self, radius):\n",
        "        self.radius = radius\n",
        "\n",
        "    def area(self):\n",
        "        return Circle.pi * self.radius ** 2\n",
        "\n",
        "circle1 = Circle(5)\n",
        "print(circle1.area())  # Output: 78.53975"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rmj-hgmdGToo",
        "outputId": "f014f9f9-affb-4ce4-badf-e79483045aea"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "78.53975\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Explanation:**\n",
        "- class Circle:: Defines a class named Circle.\n",
        "- pi = 3.14159: Class variable that is shared among all instances of the class.\n",
        "- def __init__(self, radius):: Defines the constructor method for the class.\n",
        "- def area(self):: Defines a method that calculates the area of the circle using the class variable pi.\n",
        "- circle1 = Circle(5):: Creates an instance of the Circle class named circle1 with attribute radius=5.\n",
        "- print(circle1.area()): Calls the area method on the circle1 object and prints the result."
      ],
      "metadata": {
        "id": "AdTAtU7uGbJY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Constructors and Destructors\n",
        "### Definition:\n",
        "Constructors are special methods that are automatically called when an object is created. Destructors are special methods that are automatically called when an object is deleted.\n",
        "\n",
        "### Importance:\n",
        "- Constructors initialize the object's attributes.\n",
        "- Destructors perform cleanup operations before an object is destroyed.\n",
        "\n",
        "### Examples:\n",
        "**Constructors:**"
      ],
      "metadata": {
        "id": "mBd7X9gtGgO8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example of constructor\n",
        "class Person:\n",
        "    def __init__(self, name, age):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "\n",
        "    def display(self):\n",
        "        print(f'Name: {self.name}, Age: {self.age}')\n",
        "\n",
        "person1 = Person('John', 30)\n",
        "person1.display()  # Output: Name: John, Age: 30"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f6h88iygGmbq",
        "outputId": "4c43b264-187b-4cfd-fc43-b83e530e94c1"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Name: John, Age: 30\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Explanation:**\n",
        "- class Person:: Defines a class named Person.\n",
        "- def __init__(self, name, age):: Defines the constructor method for the class, which initializes the object's attributes.\n",
        "- def display(self):: Defines a method that displays the person's information.\n",
        "- person1 = Person('John', 30):: Creates an instance of the Person class named person1 with attributes name='John' and age=30.\n",
        "- person1.display(): Calls the display method on the person1 object and prints the result.\n",
        "\n",
        "**Destructors:**"
      ],
      "metadata": {
        "id": "Xa-gRroyGrSU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example of destructor\n",
        "class Person:\n",
        "    def __init__(self, name, age):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "\n",
        "    def __del__(self):\n",
        "        print(f'{self.name} has been deleted.')\n",
        "\n",
        "person1 = Person('John', 30)\n",
        "del person1  # Output: John has been deleted."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Nh5z6r_QGu4f",
        "outputId": "2da795c5-873f-41c2-b416-06f80ee9d878"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "John has been deleted.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Explanation:**\n",
        "- class Person:: Defines a class named Person.\n",
        "- def __init__(self, name, age):: Defines the constructor method for the class, which initializes the object's attributes.\n",
        "- def __del__(self):: Defines the destructor method for the class, which performs cleanup operations before the object is destroyed.\n",
        "- person1 = Person('John', 30):: Creates an instance of the Person class named person1 with attributes name='John' and age=30.\n",
        "- del person1: Deletes the person1 object, which calls the destructor method and prints the result."
      ],
      "metadata": {
        "id": "zPFIRyNFGzM2"
      }
    }
  ]
}