Python’s Dunder (Magic) Methods with Examples

Python provides a set of special methods, also known as dunder (double underscore) methods or magic methods, that allow developers to define how objects of a class interact with built-in functions and operators. These methods begin and end with double underscores (method) and enable customization of object behavior.

Object Creation & Initialization

These methods control object instantiation and destruction.

• new(cls, …) → Controls object creation (before init).
• init(self, …) → Initializes the object after creation.
• del(self) → Called when an object is about to be destroyed.

class Example:
    def __new__(cls, *args, **kwargs):
        print("Creating instance")
        return super().__new__(cls)

    def __init__(self, value):
        print("Initializing instance")
        self.value = value

    def __del__(self):
        print("Instance deleted")


obj = Example(42)
del obj

Output

Creating instance
Initializing instance
Instance deleted

Read more about class method

String Representation

• str(self) → Defines str(obj), should return a user-friendly string.
• repr(self) → Defines repr(obj), should return a string for debugging.
• format(self, format_spec) → Defines behavior for format(obj).
• bytes(self) → Defines bytes(obj) for conversion to bytes.

In Python, str and repr are special methods used for string representations of objects. While they seem similar, they serve different purposes.

• The goal of repr is to provide an unambiguous and developer-friendly representation of the object.
• The goal of str is to provide a human-readable and informative representation.

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

    def __str__(self):
        return f"{self.name} is {self.age} years old."

    def __repr__(self):
        return f"Person(name={self.name}, age={self.age})"

p = Person("Alice", 30)
print(str(p))   # Calls __str__
print(repr(p))  # Calls __repr__

print(p)

Output

Alice is 30 years old.  
Person(name=Alice, age=30)  
Alice is 30 years old.

Case 1: If both __str__ and __repr__ are not defined

print(p) #<__main__.Person object at 0x106316f10>
print(str(p))   # <__main__.Person object at 0x106316f10>
print(repr(p))  # <__main__.Person object at 0x106316f10>

Case 2 : If str is not defined but repr is defined

print(p) #Person(name=Alice, age=30)
print(str(p))   # Person(name=Alice, age=30)
print(repr(p))  # Person(name=Alice, age=30)

Case 3: if repr is not defined but str is defined

print(p) #Alice is 30 years old.
print(str(p))   # Alice is 30 years old.
print(repr(p))  # <__main__.Person object at 0x106316f10>

Python’s fallback behavior:

• If both are missing, Python uses <ClassName object at MemoryAddress>
• If str is missing, Python falls back to repr.

str --> rep --> default 

Attribute Handling

• dict → Stores an object’s instance attributes as a dictionary.
• getattr(self, name) → Defines behaviour when an attribute is accessed but not found.
• setattr(self, name, value) → Defines behavior when an attribute is set.
• delattr(self, name) → Defines behavior when an attribute is deleted.
• dir(self) → Customizes dir(obj).

__dict__

In Python, dict is a special attribute of objects that stores an object’s attributes (instance variables) in a dictionary format. It is commonly used to inspect an object’s properties dynamically.

For an Instance of a Class

class Movie:
    def __init__(self, title, year):
        self.title = title
        self.year = year

movie = Movie("Inception", 2010)
print(movie.__dict__) # {'title': 'Inception', 'year': 2010}

For a Class

class Movie:
    genre = "Sci-Fi"

    def get_title(self):
        print("title")

print(Movie.__dict__)

Output

{'__module__': '__main__', 'genre': 'Sci-Fi', 'get_title': <function Movie.get_title at 0x1063477e0>, '__dict__': <attribute '__dict__' of 'Movie' objects>, '__weakref__': <attribute '__weakref__' of 'Movie' objects>, '__doc__': None}

Modifying Attributes Dynamically

You can also modify an object’s attributes dynamically using dict:

movie.__dict__["director"] = "Christopher Nolan"
print(movie.director)  # Output: Christopher Nolan

Arithmetic Operations :Operator Overloading

• These methods allow objects to work with mathematical operators.
• Operators Overloading

Used to override operators like +, -, *, /, etc.

• add(self, other) → Defines self + other
• sub(self, other) → Defines self – other
• mul(self, other) → Defines self * other
• truediv(self, other) → Defines self / other
• floordiv(self, other) → Defines self // other
• mod(self, other) → Defines self % other
• pow(self, other) → Defines self ** other
• radd(self, other) → Defines other + self (for right operand)
• iadd(self, other) → Defines self += other (in-place addition)

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)

    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(2, 3)
v2 = Vector(1, 1)

print(v1 + v2)   # Vector(3, 4)
print(v1 - v2)   # Vector(1, 2)
print(v1 * 2)    # Vector(4, 6)

Comparison Operators

Used for defining behavior of comparison operators.

• eq(self, other) → self == other
• ne(self, other) → self != other
• lt(self, other) → self < other
• le(self, other) → self <= other
• gt(self, other) → self > other
• ge(self, other) → self >= other

class Box:
    def __init__(self, volume):
        self.volume = volume

    def __eq__(self, other):
        return self.volume == other.volume

    def __lt__(self, other):
        return self.volume < other.volume

    def __gt__(self, other):
        return self.volume > other.volume

b1 = Box(10)
b2 = Box(20)

print(b1 == b2)  # False
print(b1 < b2)   # True
print(b1 > b2)   # False

Type Conversion

• int(self) → Defines int(obj)
• float(self) → Defines float(obj)
• complex(self) → Defines complex(obj)
• bool(self) → Defines bool(obj)
• hash(self) → Defines hash(obj)

Container & Sequence Protocols

For making objects behave like lists, dicts, or sets.

• len(self) → Defines len(obj)
• getitem(self, key) → Allows obj[key]
• setitem(self, key, value) → Allows obj[key] = value
• delitem(self, key) → Allows del obj[key]
• contains(self, item) → Defines item in obj
• iter(self) → Defines iteration over an object (for x in obj).
• next(self) → Defines behavior of next(obj).

Callable Objects

• call(self, …) → Makes an instance callable like a function.

Context Manager (With Statement)

• enter(self) → Defines what happens at the start of with obj:
• exit(self, exc_type, exc_value, traceback) → Handles cleanup at the end.

Descriptors (Advanced)

• get(self, instance, owner) → Defines behavior when accessed.
• set(self, instance, value) → Defines behavior when modified.
• delete(self, instance) → Defines behavior when deleted.

Metaclass Methods

• prepare(cls, name, bases, **kwargs) → Used in metaclasses to prepare a class namespace.
• instancecheck(self, instance) → Defines isinstance(instance, cls).
• subclasscheck(self, subclass) → Defines issubclass(subclass, cls).

How Are Dunder Methods Called?

• Dunder (double underscore) methods in Python, also known as magic methods, are automatically invoked by Python when certain operations are performed on an object. These methods don’t need to be explicitly called with self or cls because they are hooked into the Python language itself.
• This is part of Python’s object-oriented design, allowing objects to behave like built-in types.

Conclusion

Python’s dunder methods provide powerful ways to customize class behavior. By overriding these methods, you can integrate custom objects seamlessly with Python’s built-in features. Whether you need arithmetic operations, comparisons, sequence behavior, or even context management, dunder methods make it all possible.

Resource

• Python Interview question
• RealPython