Introduction to Object-Oriented Programming (OOP) in Python

Object-Oriented Programming (OOP) is a powerful paradigm that allows us to model real-world entities as objects. These objects encapsulate both data (properties) and behavior (methods). Let’s break down the key concepts:

• Class: A class serves as a blueprint for creating objects. It defines the common properties and methods shared by all instances of that class. Think of it as a template.
• Object: An object is an instance of a class. It represents a specific entity with its own state (data) and behavior (methods). For example, a “Car” class could have objects representing different car models.
• Data Abstraction: Abstraction hides the implementation details and exposes only essential information. Imagine driving a car—you know how to accelerate and brake without understanding the internal mechanics. That’s abstraction!
• Encapsulation: Encapsulation bundles data and methods together within a class. It ensures that data remains private and can only be accessed through well-defined methods.
• Inheritance: Inheritance allows one class (the child class) to inherit properties and methods from another class (the parent class). It promotes code reuse and hierarchy.

Class Declaration

### 1.1. Class Definition
class Animal:
    """
    This class represents an animal.
    """
    
    ### 1.2. Constructor Method
    def __init__(self, name, species):
        """
        Constructor method to initialize an Animal object.

        Parameters:
        - name (str): The name of the animal.
        - species (str): The species of the animal.
        """
        self.name = name
        self.species = species

    ### 1.3. Instance Method
    def make_sound(self):
        """
        Instance method to make the animal sound.
        """
        pass # Actual implementation will be in subclasses

Inheritance

### 2.1. Subclass Declaration
class Dog(Animal):
    """
    This class represents a dog, inheriting from the Animal class.
    """
    
    ### 2.2. Constructor Method Override
    def __init__(self, name, breed):
        """
        Constructor method to initialize a Dog object.

        Parameters:
        - name (str): The name of the dog.
        - breed (str): The breed of the dog.
        """
        super().__init__(name, species="Dog")
        self.breed = breed

    ### 2.3. Instance Method Override
    def make_sound(self):
        """
        Instance method to make the dog bark.
        """
        return "Woof!"

### 2.4. Another Subclass Declaration
class Cat(Animal):
    """
    This class represents a cat, inheriting from the Animal class.
    """
    
    ### 2.5. Constructor Method Override
    def __init__(self, name, color):
        """
        Constructor method to initialize a Cat object.

        Parameters:
        - name (str): The name of the cat.
        - color (str): The color of the cat.
        """
        super().__init__(name, species="Cat")
        self.color = color

    ### 2.6. Instance Method Override
    def make_sound(self):
        """
        Instance method to make the cat meow.
        """
        return "Meow!"

Creating instances of Dog and Cat

# Creating instances of Dog and Cat
dog = Dog("Buddy", "Golden Retriever")
cat = Cat("Whiskers", "Gray")

# Accessing attributes and methods
print(f"{dog.name} is a {dog.species} of breed {dog.breed}.")
print(f"{cat.name} is a {cat.species} with {cat.color} fur.")
print(f"{dog.name} says: {dog.make_sound()}")
print(f"{cat.name} says: {cat.make_sound()}")