Object Oriented Python – Advanced Features
Once you understand the basics of Object-Oriented Programming in Python, the next step is learning advanced features. These concepts help you write more powerful, flexible, and professional-level Python applications.
In this tutorial, we will explore advanced OOP features such as magic methods, decorators, class methods, static methods, property, and metaclasses.
1. Magic Methods (Dunder Methods)
Magic methods are special methods surrounded by double underscores (__).
They allow you to define how objects behave with built-in operations.
Example: init and str
class Student:
def __init__(self, name):
self.name = name
def __str__(self):
return f"Student: {self.name}"
s = Student("John")
print(s)
Common Magic Methods
| Method | Purpose |
|---|---|
__init__ | Constructor |
__str__ | String representation |
__len__ | Length of object |
__add__ | Addition operator |
__eq__ | Equality check |
2. Operator Overloading
You can define how operators work with objects.
Example: Adding Objects
class Number:
def __init__(self, value):
self.value = value
def __add__(self, other):
return self.value + other.value
n1 = Number(10)
n2 = Number(20)
print(n1 + n2)
3. Class Methods
Class methods work with the class itself, not objects.
They use @classmethod decorator.
Example:
class Student:
school = "ABC School"
@classmethod
def change_school(cls, name):
cls.school = name
Student.change_school("XYZ School")
print(Student.school)
4. Static Methods
Static methods do not depend on class or object.
They behave like normal functions inside a class.
Example:
class Math:
@staticmethod
def add(a, b):
return a + b
print(Math.add(5, 3))
5. Property Decorator
The @property decorator allows controlled access to attributes.
Example:
class Person:
def __init__(self, age):
self._age = age
@property
def age(self):
return self._age
@age.setter
def age(self, value):
if value > 0:
self._age = value
6. Abstract Classes
Abstract classes define structure but not implementation.
They use abc module.
Example:
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
class Circle(Shape):
def area(self):
return 3.14 * 5 * 5
7. Multiple Inheritance (Advanced Use)
Python supports multiple inheritance.
class A:
def show_a(self):
print("A")
class B:
def show_b(self):
print("B")
class C(A, B):
pass
obj = C()
obj.show_a()
obj.show_b()
8. Metaclasses (Advanced Concept)
Metaclasses control class creation.
Example:
class Meta(type):
def __new__(cls, name, bases, dct):
print(f"Creating class: {name}")
return super().__new__(cls, name, bases, dct)
class MyClass(metaclass=Meta):
pass
9. call Method
Makes objects callable like functions.
class Multiply:
def __call__(self, a, b):
return a * b
m = Multiply()
print(m(5, 3))
10. Why Advanced OOP Features Matter
Advanced OOP features help you:
- Write cleaner and powerful code
- Build frameworks and libraries
- Improve code flexibility
- Customize object behavior
- Develop scalable applications
11. Real-World Usage
These features are used in:
- Django & Flask frameworks
- Machine learning libraries (TensorFlow, PyTorch)
- API development
- Game engines
- Enterprise systems
12. Common Mistakes
❌ Overusing magic methods
✔ Use only when needed
❌ Misusing metaclasses
✔ Avoid unless necessary
❌ Ignoring readability
✔ Keep code simple and understandable
13. Best Practices
✔ Use decorators for clean design
✔ Prefer composition over complex inheritance
✔ Use static methods for utility functions
✔ Use property for controlled access
✔ Keep advanced features minimal and meaningful
Conclusion
Object-Oriented Python advanced features give you full control over how classes and objects behave. Concepts like magic methods, decorators, properties, and metaclasses allow you to build powerful and flexible applications.
Mastering these features will elevate your Python skills to a professional level and prepare you for framework development and large-scale software engineering.
0 Comments