What is a "callable"?
A callable is anything that can be called.
The built-in callable (PyCallable_Check in objects.c) checks if the argument is either:
- an instance of a class with a
__call__
method or - is of a type that has a non null tp_call (c struct) member which indicates callability otherwise (such as in functions, methods etc.)
The method named __call__
is (according to the documentation)
Called when the instance is ''called'' as a function
Example
class Foo: def __call__(self): print 'called'foo_instance = Foo()foo_instance() #this is calling the __call__ method
From Python's sources object.c:
/* Test whether an object can be called */intPyCallable_Check(PyObject *x){ if (x == NULL) return 0; if (PyInstance_Check(x)) { PyObject *call = PyObject_GetAttrString(x, "__call__"); if (call == NULL) { PyErr_Clear(); return 0; } /* Could test recursively but don't, for fear of endless recursion if some joker sets self.__call__ = self */ Py_DECREF(call); return 1; } else { return x->ob_type->tp_call != NULL; }}
It says:
- If an object is an instance of some class then it is callable iff it has
__call__
attribute. - Else the object
x
is callable iffx->ob_type->tp_call != NULL
Desciption of tp_call
field:
ternaryfunc tp_call
An optional pointer to a function that implements calling the object. This should be NULL if the object is not callable. The signature is the same as for PyObject_Call(). This field is inherited by subtypes.
You can always use built-in callable
function to determine whether given object is callable or not; or better yet just call it and catch TypeError
later. callable
is removed in Python 3.0 and 3.1, use callable = lambda o: hasattr(o, '__call__')
or isinstance(o, collections.Callable)
.
Example, a simplistic cache implementation:
class Cached: def __init__(self, function): self.function = function self.cache = {} def __call__(self, *args): try: return self.cache[args] except KeyError: ret = self.cache[args] = self.function(*args) return ret
Usage:
@Cacheddef ack(x, y): return ack(x-1, ack(x, y-1)) if x*y else (x + y + 1)
Example from standard library, file site.py
, definition of built-in exit()
and quit()
functions:
class Quitter(object): def __init__(self, name): self.name = name def __repr__(self): return 'Use %s() or %s to exit' % (self.name, eof) def __call__(self, code=None): # Shells like IDLE catch the SystemExit, but listen when their # stdin wrapper is closed. try: sys.stdin.close() except: pass raise SystemExit(code)__builtin__.quit = Quitter('quit')__builtin__.exit = Quitter('exit')
A callable is an object allows you to use round parenthesis ( ) and eventually pass some parameters, just like functions.
Every time you define a function python creates a callable object. In example, you could define the function func in these ways (it's the same):
class a(object): def __call__(self, *args): print 'Hello'func = a()# or ... def func(*args): print 'Hello'
You could use this method instead of methods like doit or run, I think it's just more clear to see obj() than obj.doit()