在Python中，函数是一级对象，这意味着:函数引用可以在输入中传递给其他函数和/或方法，并在它们内部执行。

类的实例(又名对象)，可以像函数一样对待:将它们传递给其他方法/函数并调用它们。为了实现这一点，__call__类函数必须特殊化。

Def __call__(self， [args…]) 它接受可变数量的参数作为输入。假设x是类x的实例，x.__call__(1,2)类似于将x(1,2)或实例本身作为函数调用。

在Python中，__init__()被正确地定义为类构造函数(以及__del__()是类析构函数)。因此，在__init__()和__call__()之间有一个净区别:第一个创建Class的实例，第二个使该实例可以像函数一样被调用，而不会影响对象本身的生命周期(即__call__不影响构建/销毁生命周期)，但它可以修改其内部状态(如下所示)。

的例子。

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

在Python中，函数是一级对象，这意味着:函数引用可以在输入中传递给其他函数和/或方法，并在它们内部执行。

类的实例(又名对象)，可以像函数一样对待:将它们传递给其他方法/函数并调用它们。为了实现这一点，__call__类函数必须特殊化。

Def __call__(self， [args…]) 它接受可变数量的参数作为输入。假设x是类x的实例，x.__call__(1,2)类似于将x(1,2)或实例本身作为函数调用。

在Python中，__init__()被正确地定义为类构造函数(以及__del__()是类析构函数)。因此，在__init__()和__call__()之间有一个净区别:第一个创建Class的实例，第二个使该实例可以像函数一样被调用，而不会影响对象本身的生命周期(即__call__不影响构建/销毁生命周期)，但它可以修改其内部状态(如下所示)。

的例子。

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

案例1:

class Example:
    def __init__(self, a, b, c):
        self.a=a
        self.b=b
        self.c=c
        print("init", self.a, self.b, self.c)

Run:

Example(1,2,3)(7,8,9)

结果:

- init 1 2 3
- TypeError: 'Example' object is not callable

案例2:

class Example:
    def __init__(self, a, b, c):
        self.a=a
        self.b=b
        self.c=c
        print("init", self.a, self.b, self.c)
    def __call__(self, x, y, z):
        self.x=x
        self.y=y
        self.z=z
        print("call", self.x, self.y, self.z)

Run:

Example(1,2,3)(7,8,9)

结果:

- init 1 2 3
- call 7 8 9

__call__使类的实例可调用。 为什么需要它?

从技术上讲，__init__在对象创建时由__new__调用一次，以便可以初始化它。

但是在许多情况下，您可能想要重新定义对象，例如您已经完成了对象，并且可能发现需要一个新对象。使用__call__，你可以重新定义相同的对象，就像它是新的一样。

这只是一个案例，可能还有更多。

__init__()可以:

初始化类的实例。 被叫了很多次。 只返回None。

__call__()可以像实例方法一样自由使用。

例如，Person类有__init__()和__call__()，如下所示:

class Person:
    def __init__(self, f_name, l_name):
        self.f_name = f_name
        self.l_name = l_name
        print('"__init__()" is called.')
        
    def __call__(self, arg):
        return arg + self.f_name + " " + self.l_name

现在，我们创建并初始化Person类的实例，如下所示:

    # Here
obj = Person("John", "Smith")

然后调用__init__()，如下所示:

"__init__()" is called.

接下来，我们以如下所示的2种方式调用__call__():

obj = Person("John", "Smith")
print(obj("Hello, ")) # Here
print(obj.__call__("Hello, ")) # Here

然后调用__call__()，如下所示:

"__init__()" is called.
Hello, John Smith # Here
Hello, John Smith # Here

并且，__init__()可以多次调用，如下所示:

obj = Person("John", "Smith")
print(obj.__init__("Tom", "Brown")) # Here
print(obj("Hello, "))
print(obj.__call__("Hello, "))

然后，调用__init__()， Person类的实例被重新初始化，并从__init__()返回None，如下所示:

"__init__()" is called.
"__init__()" is called. # Here
None # Here
Hello, Tom Brown
Hello, Tom Brown

并且，如果__init__()不返回None，我们调用__init__()，如下所示:

class Person:
    def __init__(self, f_name, l_name):
        self.f_name = f_name
        self.l_name = l_name
        print('"__init__()" is called.')
        return "Hello" # Here
        
    # ...

obj = Person("John", "Smith") # Here

出现以下错误:

__init__()应该返回None，而不是'str'

并且，如果Person类中没有定义__call__:

class Person:
    def __init__(self, f_name, l_name):
        self.f_name = f_name
        self.l_name = l_name
        print('"__init__()" is called.')
        
    # def __call__(self, arg):
    #     return arg + self.f_name + " " + self.l_name

然后，我们调用obj("Hello， ")，如下所示:

obj = Person("John", "Smith")
obj("Hello, ") # Here

出现以下错误:

'Person'对象不可调用

同样，我们调用obj。__call__("Hello， ")如下所示:

obj = Person("John", "Smith")
obj.__call__("Hello, ") # Here

出现以下错误:

AttributeError: 'Person'对象没有属性'__call__'

__init__是Python类中的一个特殊方法，它是类的构造函数方法。每当构造类的对象时调用它，或者我们可以说它初始化了一个新对象。 例子:

    In [4]: class A:
   ...:     def __init__(self, a):
   ...:         print(a)
   ...:
   ...: a = A(10) # An argument is necessary
10

如果我们使用A()，它会给出一个错误 TypeError: __init__()缺少一个必需的位置参数:'a'，因为它需要一个参数a，因为__init__。

……

当在Class中实现__call__时，可以帮助我们将Class实例作为函数调用调用。

例子:

In [6]: class B:
   ...:     def __call__(self,b):
   ...:         print(b)
   ...:
   ...: b = B() # Note we didn't pass any arguments here
   ...: b(20)   # Argument passed when the object is called
   ...:
20

这里如果我们使用B()，它运行得很好，因为它在这里没有__init__函数。