Python __call__ Method
Last modified March 25, 2025
This comprehensive guide explores Python's __call__ method, which
enables instances to be invoked like functions. We’ll examine its purpose, use
cases, and advanced patterns through detailed, practical examples.
Understanding __call__ Basics
The __call__ method allows class instances to be called as if
they were functions. By defining __call__ in a class, its
instances become callable objects.
class Adder:
"""A class that adds a fixed value to an input."""
def __init__(self, n):
self.n = n
def __call__(self, x):
return self.n + x
add5 = Adder(5)
print(add5(10)) # Output: 15
In this basic example, we create an Adder class that stores a
number n during initialization. The __call__ method
takes an argument x and returns the sum of n and
x. We then instantiate add5 with 5 and call it with
10, invoking __call__ to yield 15.
The __call__ method makes instances behave like functions. It can
accept any number of arguments, similar to regular functions, and maintains
state via instance attributes. It is triggered whenever the instance is
invoked with parentheses.
Stateful Function Objects
The __call__ method enables the creation of function-like objects
that retain state between calls. This example demonstrates a counter that
tracks how many times it has been invoked.
class CallCounter:
"""Tracks the number of times it’s called."""
def __init__(self):
self.count = 0
def __call__(self, *args, **kwargs):
self.count += 1
print(f"Call {self.count}")
return f"Result from call {self.count}"
counter = CallCounter()
print(counter()) # Call 1
print(counter()) # Call 2
print(counter()) # Call 3
This example showcases several key concepts. The CallCounter
maintains state through its count attribute, incrementing it with
each call. The __call__ method accepts variable arguments using
*args and **kwargs, mimicking regular function
behavior, and the instance preserves its state across invocations.
This approach has practical applications. It can be used for tracking and logging function calls, implementing memoization or caching decorators, creating stateful function wrappers, and designing callbacks that retain memory of previous calls.
Creating Decorators with __call__
The __call__ method is essential for building class-based
decorators. This example implements a timer decorator that measures and logs a
function’s execution time.
import time
class Timer:
"""Measures execution time of a decorated function."""
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
start = time.time()
result = self.func(*args, **kwargs)
end = time.time()
print(f"{self.func.__name__} took {end - start:.4f}s")
return result
@Timer
def calculate(n):
return sum(i * i for i in range(n))
print(calculate(1000000))
This decorator implementation captures a function func during
initialization. The __call__ method wraps the function, measuring
the time before and after execution, then prints the duration and returns the
result. Here, calculate computes a sum of squares efficiently.
Class-based decorators offer several advantages. They can maintain state
between calls, unlike function decorators, and provide an easier way to
implement complex decoration logic. Configuration is possible through
__init__, and the decoration logic remains cleanly separated from
the wrapped function.
Implementing Function Memoization
By combining __call__ with state, we can implement memoization to
cache function results. This example optimizes a recursive Fibonacci function.
class Memoize:
"""Caches function results for faster execution."""
def __init__(self, func):
self.func = func
self.cache = {}
def __call__(self, *args):
if args not in self.cache:
self.cache[args] = self.func(*args)
return self.cache[args]
@Memoize
def fibonacci(n):
if n < 2:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
print(fibonacci(50)) # Much faster with memoization
This memoization implementation stores the original function and a cache
dictionary in the instance. The __call__ method checks the cache
for existing results using the arguments as keys, computing and storing new
results only when necessary, then returns the cached value.
This approach works effectively because each recursive call benefits from the memoized results. The cache persists across calls to the same instance, using tuple arguments as hashable keys. This dramatically boosts performance for recursive functions like Fibonacci by avoiding redundant computations.
Creating Functors (Function Objects)
The __call__ method facilitates the creation of functors—objects
that act like functions while retaining state. This example models a
polynomial evaluator.
class Polynomial:
"""Evaluates a polynomial for a given x."""
def __init__(self, *coefficients):
self.coeffs = coefficients
def __call__(self, x):
return sum(coeff * (x ** i)
for i, coeff in enumerate(self.coeffs))
quadratic = Polynomial(1, 2, 1) # 1x² + 2x + 1
print(quadratic(2)) # 1*(2²) + 2*2 + 1 = 9
This polynomial functor initializes with a variable number of coefficients
representing the polynomial terms. When called with an x value,
__call__ computes the polynomial’s result, maintaining the
coefficients between calls and behaving like a mathematical function.
Functors offer several benefits. They combine data and behavior in a single object, providing more flexibility than plain functions. They can be passed as callbacks and are capable of implementing complex function-like behavior, making them versatile tools in Python programming.
Implementing Command Pattern
Using __call__, we can implement the Command design pattern to
create executable command objects. This example controls a light’s state.
class Command:
"""Wraps a receiver method as a callable command."""
def __init__(self, receiver):
self.receiver = receiver
def __call__(self, *args):
return self.receiver(*args)
class Light:
"""Simulates a light with on/off states."""
def on(self):
print("Light is ON")
def off(self):
print("Light is OFF")
light = Light()
turn_on = Command(light.on)
turn_off = Command(light.off)
turn_on() # Light is ON
turn_off() # Light is OFF
This Command pattern implementation creates a generic Command
class that takes a receiver method during initialization. The
__call__ method executes the receiver when invoked, enabling the
creation of concrete commands like turning a light on or off, which are then
called like functions.
This approach has notable advantages. It decouples the invoker from the receiver, allowing commands to be queued or logged. It simplifies implementing undo/redo functionality, and it treats commands as first-class objects, enhancing flexibility in design.
Dynamic API Endpoints
The __call__ method can create dynamic API endpoints that handle
various requests. This example simulates a simple user API with method
handlers.
class APIEndpoint:
"""Manages dynamic API endpoints with handlers."""
def __init__(self, name):
self.name = name
self.handlers = {}
def add_handler(self, method, handler):
self.handlers[method] = handler
def __call__(self, method, *args):
if method not in self.handlers:
raise ValueError(f"Unsupported method: {method}")
return self.handlers[method](*args)
user_endpoint = APIEndpoint("users")
user_endpoint.add_handler("GET", lambda: "User list retrieved")
user_endpoint.add_handler("POST", lambda name: f"User {name} created")
print(user_endpoint("GET")) # User list retrieved
print(user_endpoint("POST", "John")) # User John created
This API endpoint implementation creates named endpoints that support
multiple HTTP methods. It uses __call__ to process requests by
selecting and executing the appropriate handler from a dictionary, offering a
clean interface for dynamic responses.
This technique has practical applications. It’s useful for web framework route handling, creating dynamic RPC interfaces, implementing plugin systems, and building protocol adapters, providing a flexible way to manage request processing.
Best Practices and Pitfalls
When working with __call__, consider these guidelines:
- Keep callable objects focused - Each should have a single, clear purpose
- Document call signatures - Make it clear how to call your object
- Consider implementing
__repr__- Helps with debugging callable objects - Don't abuse
__call__- If an object isn't conceptually callable, use regular methods - Watch for mutable state - Shared state in callable objects can lead to bugs
Conclusion
The __call__ method is a powerful Python feature that enables
instances to behave like functions. It allows objects to be invoked with the
obj() syntax, supports the creation of stateful function objects,
and is essential for class-based decorators. Additionally, it facilitates the
implementation of various design patterns and is useful for crafting
flexible, dynamic interfaces.
Use __call__ when you need objects that maintain state across
invocations or when a function-like syntax enhances your API’s intuitiveness.
Source
Author
List all Python tutorials.