[Road to Intermediate Python] Appelez une instance de classe comme une fonction avec __call__

Lien vers le résumé

https://qiita.com/ganariya/items/fb3f38c2f4a35d1ee2e8

introduction

Afin d'étudier Python, j'ai copié une bibliothèque d'intelligence de groupe appelée acopy.

Dans acopy, de nombreuses grammaires et idiomes Python intéressants sont utilisés, et il est résumé que c'est utile parmi eux.

Cette fois, regardons l'attribut __call__ qui appelle une instance d'une classe comme une fonction.

Méthode d'attribut __call__

Si vous définissez l'attribut __call__ dans une classe, Vous pouvez appeler l'instance comme une fonction avec l'opérateur ().

class Person:

    def __init__(self, age, name):
        self.age = age
        self.name = name

    def __repr__(self):
        return f'age = {self.age}, name = {self.name}'

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


'''
age = 20, name = ron
ron
'''
p = Person(20, 'ron')
print(p)
print(p())

Dans l'exemple ci-dessus, l'attribut «call» est défini dans la classe Person. Cela renverra le nom de p lorsque l'instance sera appelée, comme un appel de fonction.

De cette façon, c'est «call» qui peut être appelé comme une fonction.

Exemple d'utilisation

Alors, à quel point est-il heureux avec ça ()?

Interface simple

Je ne pense pas que cela devrait être fait beaucoup, mais comme une simple interface Je me demande s'il peut être utilisé.

class Add:

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

    def __call__(self, y):
        return self.x + y


class Sub:

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

    def __call__(self, y):
        return self.x - y


'''
20
10
50
'''
arr = [Add(10), Sub(20), Add(40)]
for ice in arr:
    print(ice(10))

Je pense que c'est quelque chose de différent.

Donner un état à la fonction

Je pense que c'est principalement le sens de ceci. En C ++, il existe un objet fonction qui a () dans la structure. C'est mon article qui en a parlé. (Il n'y a aucune raison pour laquelle mon unordered_map ne peut pas utiliser le type de paire comme clé)

Il est difficile de donner un état à une fonction, mais une classe peut facilement avoir un état. Ensuite, il est possible d'obtenir le nombre de fois où l'opérateur () est utilisé et le résultat du calcul tel que DP pour un traitement lourd.

class Count:
    cls_count = 0

    def __init__(self):
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        Count.cls_count += 1
        return self.count, Count.cls_count


c1 = Count()
c2 = Count()

'''
(1, 1)
(1, 2)
(2, 3)
(3, 4)
(2, 5)
'''
print(c1())
print(c2())
print(c1())
print(c1())
print(c2())

Dans le code ci-dessus, nous créons une classe Count et l'appelons en tant que fonction. En interne, les variables et les états internes cls_count, count sont enregistrés.

Ce qui précède est un bon exemple, mais vous pouvez enregistrer l'état interne dans un appel de fonction appelé ().

En outre, ce qui suit est un appel de fonction au tamis Eratostenes. Après avoir calculé une fois, la valeur mise en cache en interne est renvoyée.

class Era:

    def __init__(self, N):
        self.N = N
        self.primes = []
        self.ready = False

    def __call__(self, x):
        if self.ready:
            return self.primes[x]
        else:
            self.primes = [True] * (self.N + 1)
            self.primes[0] = self.primes[1] = False

            i = 2
            while i * i <= self.N:
                if self.primes[i]:
                    for j in range(i * 2, N + 1, i):
                        self.primes[j] = False
                i += 1
            return self.primes[x]


N = 100
era = Era(N)

for i in range(0, N + 1):
    print(i, era(i))

De cette façon, je veux l'appeler comme une fonction avec () de l'extérieur, mais quand je veux avoir un état interne, il semble bon d'utiliser __call__.

Les références

• À propos de la méthode call
• Une histoire que je n'ai pas comprise call et appelable