Ce qui est un « être appelé » Python ?

Question

Maintenant qu'il est clair qu'une métaclasse est, il est associé à un concept que j'utilise tout le temps sans savoir ce que cela signifie vraiment.

Je suppose que tout le monde fait une fois une erreur avec la parenthèse, résultant en un "objet n'est pas appelable" l'exception". De plus, à l'aide de __init__ et __ _ _ new__ conduisent à se demander ce que cette sanglante __appel__ peut être utilisé pour.

Pourriez-vous me donner quelques explications, y compris des exemples avec la méthode magique ?

Answer 1

Un callable est quelque chose qui peut être appelé.

L' intégré dans callable (PyCallable_Check dans les objets.c) vérifie si l'argument est soit:

• une instance d'une classe avec un __appel__ méthode ou
• est d'un type qui a un non-nulle de tp_call (struct c) le membre qui indique callability autrement (comme dans les fonctions, méthodes, etc.)

La méthode __call__ est (selon la documentation)

Appelé lorsque l'instance est "appelé", comme une fonction

Exemple

class Foo:
  def __call__(self):
    print 'called'

foo_instance = Foo()
foo_instance() #this is calling the __call__ method

Answer 2

À partir de Python sources d'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__ d'attribut.
2. Le reste de l'objet x est rachetable iff x->ob_type->tp_call != NULL

Desciption de l' 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 supprimé en Python 3.0 et 3.1, utilisez 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, de la définition de haut- exit() et quit() fonctions de:

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

Answer 3

Un callable est qu'un objet vous permet d’utiliser des parenthèses rondes () et finalement passer certains paramètres, à l’instar de fonctions.

Chaque fois que vous définissez un python de fonction crée un objet appelable. Dans l’exemple, vous pourriez définir la fonction func dans ces voies (c’est la même chose) :

Vous pouvez utiliser cette méthode au lieu de méthodes telles que doit ou exécuter, je pense que c’est juste plus clair de voir obj() qu’obj.doit()

Answer 4

Un Callable est un objet qui a l' __call__ méthode. Cela signifie que vous pouvez faux appelable de fonctions ou de faire des choses intéressantes comme la Fonction Partielle de l'Application où vous devez prendre une fonction et ajouter quelque chose qui améliore ou se remplit de certains paramètres, de retour quelque chose qui peut être appelé à son tour (connu sous le nom Lancer dans la programmation fonctionnelle des cercles).

Certaines erreurs typographiques sera l'interprète de tenter d'appeler quelque chose que vous n'avez pas l'intention, comme (par exemple) une chaîne de caractères. Cela peut produire des erreurs où l'interprète tente d'exécuter un non-rachetable application. Vous pouvez voir ce qui se passe dans un interpréteur python en faisant quelque chose comme la transcription ci-dessous.

[nigel@k9 ~]$ python
Python 2.5 (r25:51908, Nov  6 2007, 15:55:44) 
[GCC 4.1.2 20070925 (Red Hat 4.1.2-27)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 'aaa'()    # <== Here we attempt to call a string.
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object is not callable
>>>

Answer 5

@Kevin Little: c’est faux. de l’objet type est appelé. Et parce que c’est un descripteur, il n’apparaît pas dans :