Markus Meskanen Markus Meskanen - 9 days ago 5
Python Question

How does __call__ actually work?

Python's magic method

__call__
is called whenever you attempt to call an object.
Cls()()
is thus equal to
Cls.__call__(Cls())
.

Functions are first class objects in Python, meaning they're just callable objects (using
__call__
). However,
__call__
itself is a function, thus it too has
__call__
, which again has its own
__call__
, which again has its own
__call__
.

So
Cls.__call__(Cls())
is thus equal to
Cls.__call__.__call__(Cls())
and again equilevant to
Cls.__call__.__call__.__call__(Cls())
and so on and so forth.

How does this infinite loop end? How does
__call__
actually execute the code?

Answer

Under the hood, all calls in Python use the same mechanism, and almost all arrive at the same C function in the CPython implementation. Whether an object is an instance of a class with a __call__ method, a function (itself an object), or a builtin object, all calls (except for optimized special cases) arrive at the function PyObject_Call. That C function gets the object's type from the ob_type field of the object's PyObject struct, and then from the type (another PyObject struct) gets the tp_call field, which is a function pointer. If tp_call is not NULL, it calls through that, with the args and kwargs structures that were also passed to PyObject_Call.

When a class defines a __call__ method, that sets up the tp_call field appropriately.

Here's an article explaining all of this in detail: Python internals: How callables work. It even lists and explains the entire PyObject_Call function, which isn't very big. If you want to see that function in its native habitat, it's in Objects/abstract.c in the CPython repo.

Also relevant is this stackoverflow Q&A: What is a "callable" in Python?.