Skip to main content
Special methods, commonly referred to as “dunder” (double underscore) or magic methods, are predefined methods in Python’s data model that dictate how custom objects interact with built-in language syntax. Characterized by a naming convention of leading and trailing double underscores, these methods are not typically invoked directly by the programmer. Instead, they are implicitly called by the Python interpreter to execute fundamental operations such as object instantiation, operator evaluation, attribute access, and type conversion. 
class CustomType:
    # Syntax visualization of a special method definition
    def __special_method__(self, *args, **kwargs):
        # Internal implementation details
        return NotImplemented

​
The Python Data Model and Protocols

Python’s object model is heavily reliant on protocols—informal interfaces defined by the presence of specific special methods. When a built-in function or operator is applied to an object, the interpreter translates that syntactic sugar into a corresponding special method call on the object’s class. For example, the evaluation of the + operator triggers the __add__ method, while the len() built-in function triggers the __len__ method. 

# Syntactic operation
result = obj_a + obj_b
length = len(obj_a)


# Interpreter translation (conceptual)
result = obj_a.__add__(obj_b)
length = obj_a.__len__()

​
Categorization of Special Methods

Special methods map to distinct structural and behavioral categories within the Python runtime:
  • Lifecycle and Instantiation: Manage the creation, initialization, and destruction of objects (__new__, __init__, __del__).
  • String Representation: Define how objects are serialized to strings for debugging or display (__repr__, __str__, __format__).
  • Attribute Management: Intercept and customize attribute lookup, assignment, and deletion (__getattribute__, __getattr__, __setattr__, __delattr__).
  • Operator Overloading: Define behavior for mathematical and bitwise operators (__add__, __sub__, __mul__, __lshift__, __iadd__).
  • Rich Comparison: Handle relational operators (__eq__, __ne__, __lt__, __le__, __gt__, __ge__).
  • Container Emulation: Allow objects to behave like sequences or mappings (__getitem__, __setitem__, __delitem__, __len__, __contains__).
  • Iteration: Implement the iterator protocol (__iter__, __next__).
  • Context Management: Define setup and teardown logic for the with statement (__enter__, __exit__).
  • Callable Emulation: Allow instances to be executed like functions (__call__).

​
Invocation Rules and Mechanics

Class-Level Binding: For built-in operations to invoke a special method, the method must be defined on the object’s class, not attached dynamically to the instance. The Python interpreter bypasses standard instance attribute lookup (obj.__dict__) for special methods. 
class MetaNode:
    pass

node = MetaNode()

# Dynamically attaching a special method to an instance
node.__len__ = lambda: 5


# This will raise a TypeError because the interpreter looks at type(node).__len__

# len(node)
CPython Implementation Details: In the CPython reference implementation, special methods correspond directly to C-level function pointers (slots) within the object’s type structure (e.g., tp_as_number, tp_as_sequence). When a built-in operation occurs, CPython accesses these slots directly, bypassing the standard __getattribute__ mechanism. This architectural decision ensures that fundamental language operations remain highly performant. Fallback and Reflection: Many special methods support a fallback mechanism via reflected (swapped) operands. If the left operand in a binary operation does not support the operation (returning the NotImplemented singleton), the interpreter will attempt to call the reflected special method on the right operand (e.g., falling back from __add__ to __radd__).
Tired of Poor Python Skills? Fix That With Deep Grasping!Learn More