Object-Oriented Programming (OOP) in Python

Object-Oriented Programming (OOP) is a programming paradigm that uses objects to represent data and methods to manipulate that data. Python is an object-oriented language, meaning it supports OOP principles like encapsulation, inheritance, and polymorphism. Below are the key concepts of OOP in Python.

Key Concepts of OOP

1. Classes and Objects

   • Class: A blueprint for creating objects. It defines attributes (data) and methods (functions) that the created objects will have.
   • Object: An instance of a class. It contains data and can perform actions defined by its class.

2. Attributes and Methods

   • Attributes: Variables that belong to a class or object. They store data about the object.
   • Methods: Functions defined inside a class that operate on the attributes of the object.

3. Encapsulation

   • Encapsulation is the bundling of data (attributes) and methods that operate on the data into a single unit (class). It restricts direct access to some of an object's components, which can prevent unintended interference and misuse.

4. Inheritance

   • Inheritance allows a class (child class) to inherit attributes and methods from another class (parent class). This promotes code reuse and establishes a hierarchical relationship between classes.

5. Polymorphism

   • Polymorphism allows methods to do different things based on the object that it is acting upon. It enables the same method to behave differently for different classes.

Basic OOP Concepts in Python

1. Defining a Class

You can define a class in Python using the class keyword.

class Dog:
    def __init__(self, name, age):  # Constructor method
        self.name = name  # Instance variable
        self.age = age    # Instance variable

    def bark(self):  # Instance method
        return f"{self.name} says Woof!"

2. Creating an Object

You create an object (an instance of the class) by calling the class name with arguments that match the constructor.

my_dog = Dog("Buddy", 3)  # Creating an object of the Dog class
print(my_dog.bark())  # Output: Buddy says Woof!

3. Encapsulation

Encapsulation is implemented through access modifiers. In Python, attributes and methods can be made private (not accessible from outside the class) by prefixing their names with an underscore _.

class Cat:
    def __init__(self, name):
        self._name = name  # Protected attribute

    def _meow(self):  # Protected method
        return f"{self._name} says Meow!"

cat = Cat("Whiskers")
print(cat._meow())  # Output: Whiskers says Meow!

4. Inheritance

You can create a child class that inherits from a parent class using parentheses.

class Puppy(Dog):  # Puppy class inherits from Dog
    def wag_tail(self):
        return f"{self.name} is wagging its tail."

my_puppy = Puppy("Rex", 1)
print(my_puppy.bark())  # Output: Rex says Woof!
print(my_puppy.wag_tail())  # Output: Rex is wagging its tail.

5. Polymorphism

Polymorphism allows you to define methods in a child class with the same name as methods in the parent class but with different implementations.

class Bird:
    def sound(self):
        return "Chirp!"

class Parrot(Bird):
    def sound(self):  # Overriding the parent class method
        return "Squawk!"

def make_sound(animal):
    print(animal.sound())  # Calls the sound method

my_bird = Bird()
my_parrot = Parrot()

make_sound(my_bird)  # Output: Chirp!
make_sound(my_parrot)  # Output: Squawk!

Summary

• Classes and Objects: Classes are blueprints for creating objects, which are instances of classes.
• Attributes and Methods: Attributes store data, while methods define behavior.
• Encapsulation: Bundles data and methods, restricting access with access modifiers.
• Inheritance: Allows classes to inherit attributes and methods from other classes, promoting code reuse.
• Polymorphism: Enables the same method to behave differently based on the object it is acting upon.

OOP in Python promotes a structured and modular approach to programming, making it easier to build and maintain complex applications!