CLASSES

https://www.youtube.com/watch?v=Mf2RdpEiXjU&t=7819s
https://www.youtube.com/playlist?list=PLKnIA16_RmvbAlyx4_rdtR66B7EHX5k3z

https://www.youtube.com/watch?v=Ej_02ICOIgs

NOTES
https://www.geeksforgeeks.org/python-oops-concepts/
https://www.geeksforgeeks.org/introduction-of-object-oriented-programming/

OOPs Syllabus

Core OOP Concepts

1. Introduction to OOP
a. What is OOP and why is it important?
b. Difference between procedural and object-oriented programming
2. Classes and Objects
a. Defining classes and creating objects
b. Instance attributes vs. class attributes
c. __init__ constructor method
d. self keyword
3. Encapsulation
a. Public, protected, and private attributes (_var, __var)
b. Getter and setter methods
c. @property decorator
4. Abstraction
a. Hiding implementation details
b. Abstract classes and methods (ABC module in Python)
5. Inheritance
a. Single vs. multiple inheritance
b. Method Overriding (super() function)
c. isinstance() and issubclass()
6. Polymorphism
a. Method overloading (not natively supported in Python)
b. Method overriding
c. Duck typing and dynamic typing in Python

2. Advanced OOP Concepts

6. Magic (Dunder) Methods
o __str__, __repr__
o __eq__, __lt__, __gt__ (operator overloading)
o __call__ (making objects callable)
o __getitem__, __setitem__ (indexing behavior)
7. Class Methods and Static Methods
o @classmethod vs @staticmethod
o Use cases and differences
8. Composition vs. Inheritance
o When to use composition over inheritance
o Example: Creating modular ML pipeline components
9. Metaclasses and type()
o Class Methods and Static Methods
 o @classmethod vs @staticmethod
o Use cases and differences
o Custom metaclasses
o __new__() vs. __init__()
10. Property and Descriptors
o @property decorator
o Custom descriptors using __get__, __set__, __delete__
11. Slots
o Memory optimization using __slots__

3. OOP in Python for Data Science

9. Designing OOP-based ML Pipelines
o Creating reusable data transformation classes
o Inheriting from sklearn.base.BaseEstimator for custom models
10. OOP for Data Processing
o Wrapping Pandas operations inside a class
o Encapsulating feature engineering steps
11. OOP for Model Deployment
o Flask/FastAPI-based OOP design
o predict() methods inside model classes
o Handling stateful vs. stateless behavior in API services

4. Best Practices and Design Patterns

12. SOLID Principles
o Single Responsibility Principle
o Open-Closed Principle
o Liskov Substitution Principle
o Interface Segregation Principle
o Dependency Inversion Principle
13. Common Design Patterns in Data Science
o Factory pattern (for model selection)
o Singleton pattern (for managing database connections)
o Strategy pattern (for choosing different ML algorithms at runtime)
o Observer pattern (event-driven logging)
14. Error Handling in OOP
o try-except-finally for class methods
o Raising custom exceptions (__str__ in exception classes)

5. Practical Coding Problems for OOP Interviews

15. Implement a simple ML pipeline using OOP
o Define DataLoader, Preprocessor, ModelTrainer classes
o Use method overriding for different preprocessing techniques
16. Create a class-based API wrapper
o Implement a Python wrapper around an ML model using OOP
o Handle requests with requests library
17. Implement an OOP-based caching system
o Use the Singleton pattern to store processed data
o Implement LRU caching using functools.lru_cache

6. OOP vs. Functional Programming in Data Science

18. When to use OOP vs. Functional Programming
o Trade-offs between the two paradigms
o Examples of both approaches in ML pipeline development
Phase 2: Advanced OOP Concepts
Week 3: Inheritance and Composition
1. Deep Dive into Inheritance
o Method Resolution Order (MRO)
o super() and __mro__
o Diamond problem and C3 linearization
2. Composition vs Inheritance
o When to use composition over inheritance
o Pros and cons

Week 4: Design Principles

1. SOLID Principles
o Single Responsibility Principle
o Open/Closed Principle
o Liskov Substitution Principle
o Interface Segregation Principle
o Dependency Inversion Principle
2. DRY, KISS, and YAGNI Principles
o Code readability and maintainability

Phase 3: Design Patterns

Week 5: Creational Design Patterns
1. Singleton Pattern
2. Factory Method Pattern
3. Abstract Factory Pattern
4. Builder Pattern
5. Prototype Pattern

Week 6: Structural Design Patterns

1. Adapter Pattern
2. Decorator Pattern
3. Facade Pattern
4. Proxy Pattern
5. Bridge Pattern

Week 7: Behavioral Design Patterns

1. Observer Pattern
2. Strategy Pattern
3. Command Pattern
4. State Pattern
5. Template Method Pattern

Phase 4: OOP in Real-World Projects

Week 8: Project 1 – Object-Oriented Design
 Design a Library Management System
 Implement class hierarchy, polymorphism, and composition

Week 9: Project 2 – Design Patterns

 Implement a Booking System using Factory, Singleton, and Observer patterns

Week 10: Project 3 – Scalable OOP

 Design a Social Media Feed
  Handle relationships using composition and inheritance
 Optimize with metaclasses and __slots__

Phase 5: Interview Preparation

Week 11: System Design and Code Review
1. Object-Oriented Design in System Design Interviews
o How to approach design problems using OOP
o Trade-offs between inheritance and composition
o UML Diagrams – Class, Sequence, and Object diagrams
2. Scalability and Performance Considerations
o Lazy loading
o Efficient memory management using __slots__

Week 12: Coding Problems (MAANG-Level)

1. Easy
o Implement a Stack using OOP principles
o Create a Bank Account class with deposit/withdraw functionality
o Design a Shape hierarchy with Circle and Square classes
2. Medium
o Design a Parking Lot system
o Design an Online Shopping Cart
o Create an Event Notification system using Observer Pattern
3. Hard
o Design a Hotel Reservation system using Factory and Singleton Patterns
o Design a Multiplayer Chess Game using State and Command Patterns
o Implement a Cache system with eviction policy using Decorator Pattern