Data Science heavily depends on Python. But do you know what are those 4 things that Python has to depend on ?

We used the most apparent one, OOP, which is sort of the tool for organizing your code around objects. So, Object Oriented features of python, allows us to write reusable and well-defined programs. Let us go through the core concepts: Class, Object, Constructor, Methods, Static Methods and Four Pillars of OOP.

1. Class

A class is like a blueprint for the object. It allows the creation of objects that can have attributes(data) and methods(functions)

Example:

class Car:

    def __init__(self, brand, model):

        self.brand = brand  # Attribute

        self.model = model  # Attribute

Here, Car is a class with attributes brand and model.

2. Object

An object is an instance of a class. It has real values assigned to the attributes defined in the class.

Example:

car1 = Car(“Toyota”, “Camry”)  # Creating an object of the Car class

print(car1.brand)  # Output: Toyota

print(car1.model)  # Output: Camry

car1 is an object of the Car class.

3. Constructor (__init__ Method)

A constructor is a special method that gets called automatically when an object is created. It initializes object attributes.

Example:

class Student:

    def __init__(self, name, age):

        self.name = name

        self.age = age

 

student1 = Student(“Ajay”, 21)

print(student1.name)  # Output: Ajay

The __init__ method initializes name and age when we create student1.

4. Methods

Methods are functions inside a class that perform actions using object data.

Example:

class Dog:

    def __init__(self, name):

        self.name = name

    

    def bark(self):

        return f”{self.name} is barking!”

 

dog1 = Dog(“Bruno”)

print(dog1.bark())  # Output: Bruno is barking!

The bark method prints a message using the object’s name.

5. Static Methods

Static methods don’t use instance attributes. They belong to the class and are defined using @staticmethod.

Example:

class MathOperations:

    @staticmethod

    def add(a, b):

        return a + b

 

print(MathOperations.add(5, 3))  # Output: 8

The add method doesn’t require an object to be called.

The Four Pillars of OOP

OOP is based on four main principles that make programming more structured and reusable:

1. Encapsulation

It is a mechanism of restricting access to internal object details by wrapping data, functions and access in a single unit (class).

Example:

class BankAccount:

    def __init__(self, balance):

        self.__balance = balance  # Private attribute

    

    def get_balance(self):

        return self.__balance

 

account = BankAccount(1000)

print(account.get_balance())  # Output: 1000

Here, __balance is private and can only be accessed via methods.

2. Abstraction

Abstraction simplifies implementation details and presents only the required parts.

Example:

from abc import ABC, abstractmethod

 

class Animal(ABC):

    @abstractmethod

    def sound(self):

        pass

 

class Dog(Animal):

    def sound(self):

        return “Bark”

 

dog = Dog()

print(dog.sound())  # Output: Bark

The Animal class provides a blueprint, while Dog implements the sound method.

3. Inheritance

Inheritance is when a class can use properties and methods of another class.

Example:

class Animal:

    def __init__(self, name):

        self.name = name

    

    def speak(self):

        return “Animal sound”

 

class Dog(Animal):

    def speak(self):

        return “Bark”

 

dog = Dog(“Bruno”)

print(dog.speak())  # Output: Bark

Here, Dog inherits from Animal and overrides the speak method.

4. Polymorphism

Methods having the same name but different implementations in different classes are referred to as polymorphism.

Example:

class Bird:

    def fly(self):

        return “Bird is flying”

 

class Airplane:

    def fly(self):

        return “Airplane is flying”

 

objects = [Bird(), Airplane()]

for obj in objects:

    print(obj.fly())

Here, both Bird and Airplane have a fly method, but they behave differently.

Conclusion

OOP in Python helps structure code by using classes and objects.

• Class: Blueprint for creating objects
• Object: An instance of a class
• Constructor: Initializes object attributes
• Methods: Functions inside a class
• Static Methods: Independent functions within a class
• Encapsulation: Restricting direct access to data
• Abstraction: Hiding implementation details
• Inheritance: Reusing properties and methods from another class
• Polymorphism: Methods with the same name behaving differently in different classes

If you want to get more understanding of these concepts, please learn Python programming presented by SkillzRevo!!!