Qu'est ce qu'un “callable”?

De Python sources objet.c:

/* Test whether an object can be called */

int
PyCallable_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;
    }
}

Il dit:

1. Si un objet est une instance d'une classe, alors il est appelable iff il a __call__ attribut.
2. Ailleurs l'objet x est appelable iff x->ob_type->tp_call != NULL

Desciption de tp_call champ:

ternaryfunc tp_call Facultatif
pointeur vers une fonction qui implémente
l'appel de l'objet. Cela devrait être
La valeur NULL si l'objet n'est pas appelable.
La signature est la même que pour
PyObject_Call(). Ce champ est
héritées par les sous-types.

Vous pouvez toujours utiliser les haut- callable fonction pour déterminer si l'objet donné est remboursable ou non; ou, mieux encore, il vous suffit d'appeler et d'attraper TypeError plus tard. callable est retiré en Python 3.0 et 3.1, l'utilisation callable = lambda o: hasattr(o, '__call__') ou isinstance(o, collections.Callable).

Exemple, simpliste cache de mise en œuvre:

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    

Utilisation:

@Cached
def ack(x, y):
    return ack(x-1, ack(x, y-1)) if x*y else (x + y + 1) 

Exemple de la bibliothèque standard, fichier site.py, la définition de l'intégré dans exit() et quit() fonctions:

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')

Laissez-moi vous expliquer en arrière:

Considérer cette...

foo()

... comme sucre syntaxique pour:

foo.__call__()

Où foo peut être n'importe quel objet qui répond à __call__. Quand je dis que n'importe quel objet, je veux dire: intégré-types, vos propres classes et de leurs instances.

Dans le cas de types intégrés, lorsque vous écrivez:

int('10')
unicode(10)

Vous êtes essentiellement faire:

int.__call__('10')
unicode.__call__(10)

C'est aussi pourquoi vous n'avez pas foo = new int en Python: vous venez de faire l'objet de classe retourner une instance de celui-ci sur __call__. La façon Python résout c'est très élégant à mon avis.

__call__ rend n'importe quel objet être appelée comme une fonction.

Cet exemple de sortie 8:

class Adder(object):
  def __init__(self, val):
    self.val = val

  def __call__(self, val):
    return self.val + val

func = Adder(5)
print func(3)

En Python un callable est un objet qui a une __call__ méthode:

>>> class Foo:
...  pass
... 
>>> class Bar(object):
...  pass
... 
>>> type(Foo).__call__(Foo)
<__main__.Foo instance at 0x711440>
>>> type(Bar).__call__(Bar)
<__main__.Bar object at 0x712110>
>>> def foo(bar):
...  return bar
... 
>>> type(foo).__call__(foo, 42)
42

Aussi simple que ça 🙂

Bien sûr, cela peut être surchargé:

>>> class Foo(object):
...  def __call__(self):
...   return 42
... 
>>> f = Foo()
>>> f()
42

callables mettre en œuvre les __call__ méthode spéciale de sorte que tout objet avec une telle méthode est appelable.

Appelable est un type ou une catégorie de "Construire-dans la fonction ou de la Méthode" avec une méthode
appel

>>> type(callable)
<class 'builtin_function_or_method'>
>>>

Exemple:
impression est un objet appelable. Avec construire-dans la fonction __appel__
Lorsque vous appelez le impression fonction, Python crée un objet de type d'impression et appelle sa méthode __appel__ en passant les paramètres le cas échéant.

>>> type(print)
<class 'builtin_function_or_method'>
>>> print.__call__(10)
10
>>> print(10)
10
>>>

Merci.
En ce qui concerne,
Maris