Was ist der Unterschied zwischen __init__ und __call__?

Question

Ich möchte den Unterschied kennen zwischen __init__ et __call__ Methoden.

Zum Beispiel:

class test:

  def __init__(self):
    self.a = 10

  def __call__(self): 
    b = 20

Answer 1

Der erste wird verwendet, um ein neu erstelltes Objekt zu initialisieren, und empfängt die dafür verwendeten Argumente:

class Foo:
    def __init__(self, a, b, c):
        # ...

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

Die zweite implementiert den Funktionsaufruf-Operator.

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

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

Answer 2

Definieren eines benutzerdefinierten __call__() Methode erlaubt es, die Instanz der Klasse als Funktion aufzurufen, wobei die Instanz selbst nicht immer verändert wird.

In [1]: class A:
   ...:     def __init__(self):
   ...:         print "init"
   ...:         
   ...:     def __call__(self):
   ...:         print "call"
   ...:         
   ...:         

In [2]: a = A()
init

In [3]: a()
call

Answer 3

In Python sind Funktionen Objekte erster Klasse, d.h. Funktionsreferenzen können als Eingaben an andere Funktionen und/oder Methoden übergeben und von diesen ausgeführt werden.

Instanzen von Klassen (auch bekannt als Objekte), können wie Funktionen behandelt werden: Sie können an andere Methoden/Funktionen übergeben und diese aufrufen. Um dies zu erreichen, muss die __call__ Klassenfunktion muss spezialisiert werden.

def __call__(self, [args ...]) Es nimmt als Eingabe eine variable Anzahl von Argumenten. Angenommen, x die eine Instanz der Klasse X , x.__call__(1, 2) ist vergleichbar mit dem Aufruf von x(1,2) o die Instanz selbst als eine Funktion .

In Python, __init__() ist ordnungsgemäß als Klassenkonstruktor definiert (ebenso wie __del__() ist der Destruktor der Klasse). Daher gibt es eine Netto-Unterscheidung zwischen __init__() et __call__() : Die erste erstellt eine Instanz von Class up, die zweite macht diese Instanz aufrufbar als eine Funktion sein, ohne den Lebenszyklus des Objekts selbst zu beeinflussen (d.h. __call__ wirkt sich nicht auf den Lebenszyklus von Bau und Zerstörung aus), kann aber seinen internen Zustand ändern (wie unten gezeigt).

Beispiel.

class Stuff(object):

    def __init__(self, x, y, range):
        super(Stuff, self).__init__()
        self.x = x
        self.y = y
        self.range = range

    def __call__(self, x, y):
        self.x = x
        self.y = y
        print '__call__ with (%d,%d)' % (self.x, self.y)

    def __del__(self):
        del self.x
        del self.y
        del self.range

>>> s = Stuff(1, 2, 3)
>>> s.x
1
>>> s(7, 8)
__call__ with (7,8)
>>> s.x
7

Answer 4

__call__ macht die Instanz einer Klasse aufrufbar. Warum sollte dies erforderlich sein?

Technisch __init__ wird einmal aufgerufen von __new__ wenn das Objekt erstellt wird, so dass es initialisiert werden kann.

Es gibt jedoch viele Szenarien, in denen Sie Ihr Objekt umdefinieren möchten, z. B. wenn Sie mit Ihrem Objekt fertig sind und ein neues Objekt benötigen. Mit __call__ können Sie dasselbe Objekt neu definieren, als ob es neu wäre.

Dies ist nur ein Fall, es kann viele weitere geben.

Answer 5

>>> class A:
...     def __init__(self):
...         print "From init ... "
... 
>>> a = A()
From init ... 
>>> a()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: A instance has no __call__ method
>>> 
>>> class B:
...     def __init__(self):
...         print "From init ... "
...     def __call__(self):
...         print "From call ... "
... 
>>> b = B()
From init ... 
>>> b()
From call ... 
>>>