This posts is a complete guide to Python OOP (Object-Oriented Programming) — both basic and advanced topics, interview-relevant insights, code examples, and a data engineering mini-project using Python OOP + PySpark.

🐍 Python OOP: Classes and Objects (Complete Guide)

✅ What is OOP?

Object-Oriented Programming is a paradigm that organizes code into objects, which are instances of classes.
It helps in creating modular, reusable, and structured code.

✅ 1. Class and Object

🔹 Class: A blueprint for creating objects.

🔹 Object: An instance of a class with actual data.

class Car:
    def __init__(self, brand, year):
        self.brand = brand
        self.year = year

car1 = Car("Toyota", 2020)  # Object created
print(car1.brand)  # Output: Toyota

✅ 2. __init__() Constructor

• Special method that initializes an object
• Called automatically when the object is created

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

✅ 3. Instance Variables and Methods

• Belong to the object (not the class)
• Accessed via self

class Person:
    def __init__(self, name):
        self.name = name  # instance variable

    def greet(self):  # instance method
        print(f"Hello, {self.name}")

✅ 4. Class Variables and Methods

• Shared across all instances
• Use @classmethod

class Employee:
    count = 0  # class variable

    def __init__(self):
        Employee.count += 1

    @classmethod
    def total_employees(cls):
        return cls.count

✅ 5. Static Methods

• No access to self or cls
• Utility function tied to class

class Math:
    @staticmethod
    def square(x):
        return x * x

✅ 6. Encapsulation

• Hide internal state using private/protected variables

class BankAccount:
    def __init__(self):
        self.__balance = 0  # private

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

    def get_balance(self):
        return self.__balance

✅ 7. Inheritance

• One class (child) can inherit properties and methods from another (parent). Encourages code reuse.

class Animal:
    def speak(self):
        print("Animal sound")

class Dog(Animal):
    def speak(self):
        print("Bark")

d = Dog()
d.speak()  # Output: Bark

class DataSource:
    def __init__(self, path):
        self.path = path

    def read(self):
        raise NotImplementedError

class CSVSource(DataSource):
    def read(self):
        print(f"Reading CSV from {self.path}")

class JSONSource(DataSource):
    def read(self):
        print(f"Reading JSON from {self.path}")

💼 Use Case:

Define a DataSource base class for all sources (CSV, JSON, SQL, API) → extend it in specific classes → plug into ETL pipelines uniformly.

✅ 8. Polymorphism

✅ Concept:

Different classes implement the same method in different ways, and can be used interchangeably.

for animal in [Dog(), Animal()]:
    animal.speak()

sources = [CSVSource("data.csv"), JSONSource("data.json")]

for src in sources:
    src.read()  # Calls appropriate method based on object type

💼 Use Case:

Let your pipeline loop over any data source without knowing whether it’s CSV, JSON, DB, or API — only requiring it to implement a .read() method.

✅ 9. Abstraction (via abc module)

• Hide implementation; expose only interface

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Circle(Shape):
    def area(self):
        return 3.14 * 5 * 5

✅ 10. Special Methods / Dunder Methods

class Book:
    def __init__(self, title): self.title = title
    def __str__(self): return f"Book: {self.title}"

print(Book("Python"))  # Book: Python

✅ 11. Composition vs Inheritance

• Inheritance: IS-A relationship
• Composition: HAS-A relationship

class Engine:
    def start(self):
        print("Engine starts")

class Car:
    def __init__(self):
        self.engine = Engine()  # composition

    def drive(self):
        self.engine.start()

✅ Concept:

A class uses other classes inside it to build complex systems (not inheritance, but has-a).

class DataCleaner:
    def clean(self, df):
        return df.dropna()

class ETLJob:
    def __init__(self, reader, cleaner):
        self.reader = reader
        self.cleaner = cleaner

    def run(self):
        df = self.reader.read()
        return self.cleaner.clean(df)

💼 Use Case:

An ETLJob uses a Reader and Cleaner — each component can be swapped (plug-and-play). Useful in modular data pipelines.

✅ 12. Private (__var) vs Protected (_var)

✅ 13. Property Decorator

Used to define getter/setter logic without changing attribute access.

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius

    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32

    @fahrenheit.setter
    def fahrenheit(self, value):
        self._celsius = (value - 32) * 5/9

✅ 14. Dataclasses (Python 3.7+)

Auto-generates __init__, __repr__, __eq__

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

✅ 15. Custom Exceptions

class MyError(Exception):
    pass

raise MyError("Something went wrong")

🧠 CHEAT SHEET (INLINE)

Class                → Blueprint for object
Object               → Instance of class
__init__()           → Constructor method
self                 → Refers to the current object
Instance Variable    → Variable unique to object
Class Variable       → Shared among all instances
@classmethod         → Takes cls, not self
@staticmethod        → No self or cls, utility function
Encapsulation        → Hide data using __var or _var
Inheritance          → Reuse parent class features
Polymorphism         → Same interface, different behavior
Abstraction          → Interface hiding via abc module
__str__, __repr__    → Human/dev readable display
__call__             → Make an object callable
@property               → Turn method into attribute
@dataclass           → Auto boilerplate class
Composition          → Use other classes inside a class
Exception class      → Custom error with `raise`

🧪 Real Use Cases in Data Engineering

Let’s break down class methods, static methods, and dunder (magic) methods in Python — with clear 🔎 concepts, ✅ use cases, and 🧪 examples.

✅ 1. @classmethod

🔎 What:

• Bound to the class, not instance
• Takes cls as the first argument
• Can access or modify class-level variables

✅ Use Cases:

• Alternate constructors
• Tracking instances or metadata
• Factory patterns

🧪 Example:

class Book:
    count = 0  # class variable

    def __init__(self, title):
        self.title = title
        Book.count += 1

    @classmethod
    def get_count(cls):
        return cls.count

    @classmethod
    def from_string(cls, data):
        return cls(data.strip())

b1 = Book("Python")
b2 = Book.from_string("Data Science")
print(Book.get_count())  # Output: 2

✅ 2. @staticmethod

🔎 What:

• No access to self or cls
• Pure utility function inside a class
• Logical grouping of functionality

✅ Use Cases:

• Helper methods
• Validators
• Business logic without depending on state

🧪 Example:

class MathTools:
    @staticmethod
    def square(n):
        return n * n

    @staticmethod
    def is_even(n):
        return n % 2 == 0

print(MathTools.square(4))  # 16
print(MathTools.is_even(5))  # False

✅ 3. Dunder (Magic) Methods

🔎 What:

• “Double underscore” methods: __init__, __str__, __len__, etc.
• Python calls them automatically
• Used to customize how your objects behave

✅ Most Common Dunder Methods (with use cases):

🧪 Dunder Method Examples:

class Book:
    def __init__(self, title, pages):
        self.title = title
        self.pages = pages

    def __str__(self):
        return f"Book: {self.title}"

    def __len__(self):
        return self.pages

b = Book("Python Basics", 300)
print(b)          # Book: Python Basics
print(len(b))     # 300

class Counter:
    def __init__(self):
        self.count = 0

    def __call__(self):
        self.count += 1
        return self.count

c = Counter()
print(c())  # 1
print(c())  # 2

🧠 Summary: When to Use What?

class Reader:
    def read(self):
        raise NotImplementedError

class CSVReader(Reader):
    def __init__(self, path):
        self.path = path

    def read(self):
        import pandas as pd
        print(f"Reading from {self.path}")
        return pd.read_csv(self.path)

class Transformer:
    def transform(self, df):
        raise NotImplementedError

class RemoveNulls(Transformer):
    def transform(self, df):
        return df.dropna()

class Writer:
    def write(self, df):
        print("Writing DataFrame")
        # In real scenario, df.to_csv(), to_sql(), etc.

class ETLJob:
    def __init__(self, reader, transformer, writer):
        self.reader = reader
        self.transformer = transformer
        self.writer = writer

    def run(self):
        df = self.reader.read()
        df = self.transformer.transform(df)
        self.writer.write(df)

# Instantiate and run
reader = CSVReader("sample.csv")
transformer = RemoveNulls()
writer = Writer()
job = ETLJob(reader, transformer, writer)
job.run()

Great question! These are core pillars of Object-Oriented Programming (OOP), and they each serve different purposes in code reuse, design flexibility, and extensibility.

Let’s break it down with simple definitions, examples, and comparisons. ✅

🔀 Polymorphism vs Inheritance vs Composition

🧬 1. Inheritance

“Is-A” relationship — A subclass is a specialized version of a parent class.

✅ Purpose:

• Reuse and extend functionality
• Share a common interface

🧪 Example:

class Animal:
    def speak(self):
        print("Some sound")

class Dog(Animal):
    def speak(self):
        print("Bark")

d = Dog()
d.speak()  # Bark

🔀 2. Polymorphism

“Many forms” — Different classes implement the same method name, allowing flexible interface usage.

✅ Purpose:

• Swap objects without changing code
• Method overriding or duck typing

🧪 Example:

class Cat:
    def speak(self):
        print("Meow")

class Dog:
    def speak(self):
        print("Bark")

def animal_sound(animal):
    animal.speak()

animal_sound(Cat())  # Meow
animal_sound(Dog())  # Bark

✅ This works due to polymorphism — same method name (speak) used differently across classes.

🧩 3. Composition

“Has-A” relationship — A class contains one or more objects of other classes.

✅ Purpose:

• Build complex behavior by combining simple objects
• More flexible than inheritance
• Avoid tight coupling

🧪 Example:

class Engine:
    def start(self):
        print("Engine starts")

class Car:
    def __init__(self):
        self.engine = Engine()  # HAS-A engine

    def drive(self):
        self.engine.start()

c = Car()
c.drive()  # Engine starts

🧠 Visual Comparison

Inheritance     → Car IS-A Vehicle
Polymorphism    → Car.drive(), Bike.drive() — same interface, different behavior
Composition     → Car HAS-A Engine

🏁 Summary Table

✅ When to Use What?

Pages: 1 2 3 4 5