Introduction

Object-Oriented Programming (OOP) is a programming paradigm that focuses on using objects to represent real-world concepts and entities. OOP is supported in Python by many concepts such as classes, objects, inheritance, encapsulation, and polymorphism. In this blog, you will learn the fundamentals of OOP in python

Classes and Objects

A class is a blueprint for constructing objects, which are instances of the class. Classes define the properties (data) and methods (functions) that class objects will have. Here's an example of a basic Python class definition:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print(f"Hello, my name is {self.name} and I'm {self.age} years old.")

In this example, the Person class with two attributes (name and age) and one method (say_hello). The init method is a special method called when an object is created from the class. It initializes the attributes of the object with the values passed as arguments.

To create an object of the Person class, you can use the following syntax:

person1 = Person("John", 25)

This creates a new object of the Person class with the name attribute set to "John" and the age attribute set to 25. You can then call the say_hello method on the object:

person1.say_hello() # Output: "Hello, my name is John and I'm 25 years old."

Inheritance

Inheritance is a technique for creating a new class by deriving from an existing one. The new class (subclass) inherits the current class (superclass) attributes and methods, and it can also add new attributes and methods or override existing ones. Here's an example of a subclass of the Person class:

class Student(Person):
    def __init__(self, name, age, student_id):
        super().__init__(name, age)
        self.student_id = student_id

    def say_hello(self):
        print(f"Hello, my name is {self.name}, I'm {self.age} years old, and my student ID is {self.student_id}.")

In this example, the Student class is derived from the Person class, so it inherits the name and age attributes and the say_hello method. It also adds a new attribute (student_id) and overrides the say_hello method to include the student ID.

To create an object of the Student class, you can use the following syntax:

student1 = Student("Jenny", 20, 12345)

This creates a new object of the Student class with the name attribute set to "Jenny", the age attribute set to 20, and the student_id attribute set to 12345. You can then call the say_hello method on the object:

student1.say_hello() # Output: "Hello, my name is Jenny, I'm 20 years old, and my student ID is 12345."

Encapsulation

Encapsulation is a technique for hiding a class's implementation details from the outside world and exposing only the interface (public methods) to the class's users. This helps to maintain the data's and methods' integrity and consistency, and it prevents unintentional alteration or misuse of the class.

Encapsulation is performed by adopting naming conventions for private or protected characteristics and methods. Private attributes and methods have a double underscore (__), while protected attributes and methods have a single underscore ( ).

Here's an example of a class that uses encapsulation to protect its attributes:

class BankAccount:
    def __init__(self, account_number, balance):
        self.__account_number = account_number
        self.__balance = balance

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if amount > self.__balance:
            print("Insufficient balance.")
        else:
            self.__balance -= amount

    def get_balance(self):
        return self.__balance

In this example, the BankAccount class has two private attributes (__account_number and __balance) and three public methods (deposit, withdraw, and get_balance). The private attributes can only be accessed or modified from within the class methods, and not from outside the class.

To create an object of the BankAccount class, you can use the following syntax:

account1 = BankAccount("1234567890", 1000)

This creates a new object of the BankAccount class with the account_number attribute set to "1234567890" and the balance attribute set to 1000. You can then call the public methods on the object:

account1.deposit(500)
account1.withdraw(200)
print(account1.get_balance()) # Output: 1300

Polymorphism

Polymorphism is a way to use the same interface (method) to represent different implementations (behaviors) of a class or object. Polymorphism can be achieved in Python using function overloading, operator overloading, and method overriding.

Here's an example of method overriding to achieve polymorphism:

class Animal:
    def __init__(self, name):
        self.name = name

    def make_sound(self):
        pass
class Dog(Animal):
    def make_sound(self):
        print(f"{self.name} barks.")
class Cat(Animal):
    def make_sound(self):
        print(f"{self.name} meows.")

In this example, the Animal class has one method (make_sound) that doesn't do anything. The Dog and Cat classes are derived from the Animal class, and they override the make_sound method with their implementations.

To create objects of the Dog and Cat classes, you can use the following syntax:

dog1 = Dog("Buddy")
cat1 = Cat("Whiskers")

These create new objects of the Dog and Cat classes with the name attributes set to "Buddy" and "Whiskers", respectively. You can then call the make_sound method on the objects:

dog1.make_sound() # Output: "Buddy barks."
cat1.make_sound() # Output: "Whiskers meows."

Conclusion

Object-Oriented Programming (OOP) is a powerful programming paradigm that enables you to model real-world concepts and entities as objects. Python supports a wide range of OOP concepts, including classes, objects, inheritance, encapsulation, and polymorphism. You can build more efficient, reusable, and maintainable code if you grasp these aspects.