Exemple pratique de méthode spéciale Python __call__

Je sais que cette __call__méthode dans une classe est déclenchée lorsque l'instance d'une classe est appelée. Cependant, je ne sais pas quand je peux utiliser cette méthode spéciale, car on peut simplement créer une nouvelle méthode et effectuer la même opération effectuée dans __call__method et au lieu d'appeler l'instance, vous pouvez appeler la méthode.

J'apprécierais vraiment que quelqu'un me donne une utilisation pratique de cette méthode spéciale.

Le module Django Forms utilise __call__bien la méthode pour implémenter une API cohérente pour la validation de formulaire. Vous pouvez écrire votre propre validateur pour un formulaire dans Django en tant que fonction.

def custom_validator(value):
    #your validation logic

Django a des validateurs intégrés par défaut tels que des validateurs d'e-mails, des validateurs d'url, etc., qui relèvent généralement des validateurs RegEx. Pour les implémenter proprement, Django a recours à des classes appelables (au lieu de fonctions). Il implémente la logique de validation Regex par défaut dans un RegexValidator, puis étend ces classes pour d'autres validations.

class RegexValidator(object):
    def __call__(self, value):
        # validation logic

class URLValidator(RegexValidator):
    def __call__(self, value):
        super(URLValidator, self).__call__(value)
        #additional logic

class EmailValidator(RegexValidator):
    # some logic

Maintenant, votre fonction personnalisée et EmailValidator intégré peuvent être appelés avec la même syntaxe.

for v in [custom_validator, EmailValidator()]:
    v(value) # <-----

Comme vous pouvez le voir, cette implémentation dans Django est similaire à ce que d'autres ont expliqué dans leurs réponses ci-dessous. Cela peut-il être mis en œuvre d'une autre manière? Vous pourriez, mais à mon humble avis, ce ne sera pas aussi lisible ou aussi facilement extensible pour un gros framework comme Django.

Cet exemple utilise la mémorisation , le stockage essentiellement des valeurs dans un tableau (dictionnaire dans ce cas) afin que vous puissiez les consulter plus tard au lieu de les recalcul.

Ici, nous utilisons une classe simple avec une __call__méthode pour calculer les factorielles (via un objet appelable ) au lieu d'une fonction factorielle qui contient une variable statique (ce qui n'est pas possible en Python).

class Factorial:
    def __init__(self):
        self.cache = {}
    def __call__(self, n):
        if n not in self.cache:
            if n == 0:
                self.cache[n] = 1
            else:
                self.cache[n] = n * self.__call__(n-1)
        return self.cache[n]

fact = Factorial()

Vous avez maintenant un factobjet qui peut être appelé, comme toute autre fonction. Par exemple

for i in xrange(10):                                                             
    print("{}! = {}".format(i, fact(i)))

# output
0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
9! = 362880

Et il est également avec état.

Je trouve cela utile car cela me permet de créer des API faciles à utiliser (vous avez un objet appelable qui nécessite des arguments spécifiques), et faciles à implémenter car vous pouvez utiliser des pratiques orientées objet.

Ce qui suit est le code que j'ai écrit hier qui crée une version des hashlib.foométhodes qui hachent des fichiers entiers plutôt que des chaînes:

# filehash.py
import hashlib


class Hasher(object):
    """
    A wrapper around the hashlib hash algorithms that allows an entire file to
    be hashed in a chunked manner.
    """
    def __init__(self, algorithm):
        self.algorithm = algorithm

    def __call__(self, file):
        hash = self.algorithm()
        with open(file, 'rb') as f:
            for chunk in iter(lambda: f.read(4096), ''):
                hash.update(chunk)
        return hash.hexdigest()


md5    = Hasher(hashlib.md5)
sha1   = Hasher(hashlib.sha1)
sha224 = Hasher(hashlib.sha224)
sha256 = Hasher(hashlib.sha256)
sha384 = Hasher(hashlib.sha384)
sha512 = Hasher(hashlib.sha512)

Cette implémentation me permet d'utiliser les fonctions de la même manière que les hashlib.foofonctions:

from filehash import sha1
print sha1('somefile.txt')

Bien sûr, j'aurais pu l'implémenter d'une manière différente, mais dans ce cas, cela semblait être une approche simple.

__call__est également utilisé pour implémenter des classes de décorateur en python. Dans ce cas, l'instance de la classe est appelée lorsque la méthode avec le décorateur est appelée.

class EnterExitParam(object):

    def __init__(self, p1):
        self.p1 = p1

    def __call__(self, f):
        def new_f():
            print("Entering", f.__name__)
            print("p1=", self.p1)
            f()
            print("Leaving", f.__name__)
        return new_f


@EnterExitParam("foo bar")
def hello():
    print("Hello")


if __name__ == "__main__":
    hello()

Oui, lorsque vous savez que vous avez affaire à des objets, il est parfaitement possible (et dans de nombreux cas conseillé) d'utiliser un appel de méthode explicite. Cependant, vous avez parfois affaire à du code qui attend des objets appelables - généralement des fonctions, mais grâce à__call__ vous, vous pouvez créer des objets plus complexes, avec des données d'instance et plus de méthodes pour déléguer des tâches répétitives, etc. qui sont toujours appelables.

De plus, vous utilisez parfois à la fois des objets pour des tâches complexes (où il est logique d'écrire une classe dédiée) et des objets pour des tâches simples (qui existent déjà dans des fonctions ou sont plus facilement écrites sous forme de fonctions). Pour avoir une interface commune, vous devez soit écrire de petites classes encapsulant ces fonctions avec l'interface attendue, soit conserver les fonctions des fonctions et rendre les objets plus complexes appelables. Prenons les threads comme exemple. Les Threadobjets du module standard de la bibliothèquethreading veulent un appelable comme targetargument (c'est-à-dire comme action à faire dans le nouveau thread). Avec un objet appelable, vous n'êtes pas limité aux fonctions, vous pouvez également transmettre d'autres objets, comme un worker relativement complexe qui obtient des tâches à faire à partir d'autres threads et les exécute séquentiellement:

class Worker(object):
    def __init__(self, *args, **kwargs):
        self.queue = queue.Queue()
        self.args = args
        self.kwargs = kwargs

    def add_task(self, task):
        self.queue.put(task)

    def __call__(self):
        while True:
            next_action = self.queue.get()
            success = next_action(*self.args, **self.kwargs)
            if not success:
               self.add_task(next_action)

Ce n'est qu'un exemple qui me vient à l'esprit, mais je pense que c'est déjà assez complexe pour justifier le cours. Faire cela uniquement avec des fonctions est difficile, au moins cela nécessite le retour de deux fonctions et cela devient lentement complexe. On pourrait renommer __call__quelque chose d'autre et passer une méthode liée, mais cela rend le code créant le thread un peu moins évident et n'ajoute aucune valeur.

Les décorateurs basés sur les classes utilisent __call__pour référencer la fonction encapsulée. Par exemple:

class Deco(object):
    def __init__(self,f):
        self.f = f
    def __call__(self, *args, **kwargs):
        print args
        print kwargs
        self.f(*args, **kwargs)

Il y a une bonne description des différentes options ici sur Artima.com

La __call__méthode et les fermetures IMHO nous donnent un moyen naturel de créer un modèle de conception STRATÉGIE en Python. Nous définissons une famille d'algorithmes, encapsulons chacun d'eux, les rendons interchangeables et à la fin nous pouvons exécuter un ensemble d'étapes communes et, par exemple, calculer un hachage pour un fichier.

Je viens de tomber sur une utilisation de __call__()concert avec __getattr__()laquelle je trouve que c'est beau. Il vous permet de masquer plusieurs niveaux d'une API JSON / HTTP / (cependant_sérialisée) à l'intérieur d'un objet.

La __getattr__()partie prend en charge le retour itératif d'une instance modifiée de la même classe, en remplissant un attribut supplémentaire à la fois. Ensuite, après que toutes les informations ont été épuisées, __call__()prend le relais avec les arguments que vous avez transmis.

En utilisant ce modèle, vous pouvez par exemple passer un appel comme api.v2.volumes.ssd.update(size=20), qui se termine par une requête PUT à https://some.tld/api/v2/volumes/ssd/update.

Le code particulier est un pilote de stockage en bloc pour un certain backend de volume dans OpenStack, vous pouvez le vérifier ici: https://github.com/openstack/cinder/blob/master/cinder/volume/drivers/nexenta/jsonrpc.py

EDIT: mise à jour du lien pour pointer vers la révision principale.

Spécifiez a __metaclass__et remplacez la __call__méthode, et demandez à la méthode des méta-classes spécifiée de __new__renvoyer une instance de la classe, alto vous avez une "fonction" avec des méthodes.

Nous pouvons utiliser __call__method pour utiliser d'autres méthodes de classe comme méthodes statiques.

    class _Callable:
        def __init__(self, anycallable):
            self.__call__ = anycallable

    class Model:

        def get_instance(conn, table_name):

            """ do something"""

        get_instance = _Callable(get_instance)

    provs_fac = Model.get_instance(connection, "users")             

Un exemple courant est le __call__in functools.partial, voici une version simplifiée (avec Python> = 3.5):

class partial:
    """New function with partial application of the given arguments and keywords."""

    def __new__(cls, func, *args, **kwargs):
        if not callable(func):
            raise TypeError("the first argument must be callable")
        self = super().__new__(cls)

        self.func = func
        self.args = args
        self.kwargs = kwargs
        return self

    def __call__(self, *args, **kwargs):
        return self.func(*self.args, *args, **self.kwargs, **kwargs)

Usage:

def add(x, y):
    return x + y

inc = partial(add, y=1)
print(inc(41))  # 42

L'opérateur d'appel de fonction.

class Foo:
    def __call__(self, a, b, c):
        # do something

x = Foo()
x(1, 2, 3)

La méthode __call__ peut être utilisée pour redéfinir / réinitialiser le même objet. Il facilite également l'utilisation des instances / objets d'une classe en tant que fonctions en passant des arguments aux objets.

Je trouve un bon endroit pour utiliser des objets appelables, ceux qui définissent __call__(), est lors de l' utilisation des capacités de programmation fonctionnelle en Python, tels que map(), filter(), reduce().

Le meilleur moment pour utiliser un objet appelable sur une fonction simple ou une fonction lambda est lorsque la logique est complexe et doit conserver un état ou utilise d'autres informations qui ne sont pas transmises à la __call__()fonction.

Voici un code qui filtre les noms de fichiers en fonction de leur extension de nom de fichier à l'aide d'un objet appelable et filter().

Appelable:

import os

class FileAcceptor(object):
    def __init__(self, accepted_extensions):
        self.accepted_extensions = accepted_extensions

    def __call__(self, filename):
        base, ext = os.path.splitext(filename)
        return ext in self.accepted_extensions

class ImageFileAcceptor(FileAcceptor):
    def __init__(self):
        image_extensions = ('.jpg', '.jpeg', '.gif', '.bmp')
        super(ImageFileAcceptor, self).__init__(image_extensions)

Usage:

filenames = [
    'me.jpg',
    'me.txt',
    'friend1.jpg',
    'friend2.bmp',
    'you.jpeg',
    'you.xml']

acceptor = ImageFileAcceptor()
image_filenames = filter(acceptor, filenames)
print image_filenames

Production:

['me.jpg', 'friend1.jpg', 'friend2.bmp', 'you.jpeg']

C'est trop tard mais je donne un exemple. Imaginez que vous ayez une Vectorclasse et une Pointclasse. Les deux prennent x, ycomme arguments positionnels. Imaginons que vous souhaitiez créer une fonction qui déplace le point à placer sur le vecteur.

4 solutions

• put_point_on_vec(point, vec)

• Faites-en une méthode sur la classe vectorielle. par exemple my_vec.put_point(point)

• Faites-en une méthode sur la Pointclasse.my_point.put_on_vec(vec)
• Vectorimplémente __call__, vous pouvez donc l'utiliser commemy_vec_instance(point)

Cela fait en fait partie de quelques exemples sur lesquels je travaille pour un guide des méthodes dunder expliquées avec Maths que je vais publier tôt ou tard.

J'ai quitté la logique du déplacement du point lui-même car ce n'est pas le sujet de cette question