0

以下示例

import types
import pprint
class A:
    def __call__(self, *args):
        pprint.pprint('[A.__call__] self=%r, args=%r'
                      % (self, list(args)))
class B:
    pass
if __name__ == '__main__':
    a = A()
    print(callable(a))
    a(1, 2)
    b = B()
    b.meth = types.MethodType(a, b)
    b.meth(3, 4)

印刷

True
'[A.__call__] self=<__main__.A object at 0xb7233c2c>, args=[1, 2]'
('[A.__call__] self=<__main__.A object at 0xb7233c2c>, args=[<__main__.B '
 'object at 0xb71687cc>, 3, 4]')

__call__ 方法参数的数量在 b.meth(3, 4) 示例中发生了更改。请解释第一个（__main__.B 对象...）以及 Python 何时提供它？

在 Debian 9.9 Stretch 上使用 Python 3.5.3

4

1 回答 1

2

这里的重要概念是类函数是一个将“self”绑定到它作为其第一个参数的函数。

我将通过几个示例进行演示。以下代码对于所有示例都是相同的：

import types

# Class with function
class A:
    def func(*args):
        print('A.func(%s)'%(', '.join([str(arg) for arg in args])))

# Callable function-style class
class A_callable:
    def __call__(*args):
        print('A_callable.__call__(%s)'%(', '.join([str(arg) for arg in args])))

# Empty class
class B():
    pass

# Function without class
def func(*args):
    print('func(%s)'%(', '.join([str(arg) for arg in args])))

现在让我们考虑几个例子：

>>> func(42)
func(42)

这个很明显。它只是func用参数调用函数42。

接下来的更有趣：

>>> A().func(42)
A.func(<__main__.A object at 0x7f1ed9ed2908>, 42)
>>> A_callable()(42)
A_callable.__call__(<__main__.A_callable object at 0x7f1ed9ed28d0>, 42)

您可以看到类对象self作为第一个参数自动提供给函数。重要的是要注意，添加self参数不是因为函数存储在对象中，而是因为函数是作为对象的一部分构造的，因此对象绑定到它。

展示：

>>> tmp = A().func
>>> tmp
<bound method A.func of <__main__.A object at 0x7f1ed9ed2978>>
>>> tmp(42)
A.func(<__main__.A object at 0x7f1ed9ed2978>, 42)

>>> tmp = A_callable().__call__
>>> tmp
<bound method A_callable.__call__ of <__main__.A_callable object at 0x7f1ed9ed2908>>
>>> tmp(42)
A_callable.__call__(<__main__.A_callable object at 0x7f1ed9ed2908>, 42)

self参数没有被添加，因为你a.在它之前写了。它是函数对象本身的一部分，将其存储在变量中仍然保持该绑定。

您还可以手动将类对象绑定到函数，如下所示：

>>> tmp = types.MethodType(func, B)
>>> tmp
<bound method func of <class '__main__.B'>>
>>> tmp(42)
func(<class '__main__.B'>, 42)

另一方面，仅将函数分配给类不会绑定到self该函数。如前所述，参数在调用时不会动态添加，而是在构造时静态添加：

>>> b = B()
>>> b.func = func
>>> b.func
<function func at 0x7f1edb58fe18>
>>> b.func(42)
func(42) # does NOT contain the `self` argument

self这就是为什么如果我们想将它添加到一个对象，我们需要显式地绑定到函数：

>>> b = B()
>>> b.func = types.MethodType(func, b)
>>> b.func
<bound method func of <__main__.B object at 0x7f1ed9ed2908>>
>>> b.func(42)
func(<__main__.B object at 0x7f1ed9ed2908>, 42)

唯一剩下的就是了解绑定是如何工作的。如果一个方法绑定func了一个参数a，并被调用*args，它将添加a到开头，*args然后将其传递给函数。开始在这里很重要。

现在我们知道了理解您的代码所需的一切：

>>> a = A_callable()
>>> b = B()
>>> b.func = types.MethodType(a, b)
>>> b.func
<bound method ? of <__main__.B object at 0x7f1ed97e9fd0>>
>>> b.func(42)
A_callable.__call__(<__main__.A_callable object at 0x7f1ed97fb2b0>, <__main__.B object at 0x7f1ed97e9fd0>, 42)

首先，我们可以将其更改b.func为plain tmp，因为如前所述，向对象添加函数不会更改其类型或功能。只有绑定self可以。

然后，让我们逐段执行代码：

>>> a = A_callable()
>>> b = B()

到现在为止还挺好。我们有一个空对象b和一个可调用对象a。

>>> tmp = types.MethodType(a,b)

这条线是症结所在。如果你明白这一点，你就会明白一切。

tmp现在是绑定到它的a函数b。这意味着，如果我们调用tmp(42)，它会添加b到其参数的开头。a因此会收到b, 42。然后，因为a是可调用的，它会将其参数转发给a.__call__.

这意味着，我们处于tmp(42)等于的点a.__call__(b, 42)。

因为__call__是 的类函数A_callable，在构造的过程中a会自动绑定到函数。因此，在参数到达 之前，被添加到参数列表的开头，这意味着参数现在是。__call__aA_callable.__call__aa, b, 42

现在我们处于tmp(42)equals的位置A_callable.__call__(a, b, 42)。这正是您所看到的：

>>> tmp = types.MethodType(a, b)
>>> tmp(42)
A_callable.__call__(<__main__.A_callable object at 0x7f1ed97fb2b0>, <__main__.B object at 0x7f1ed97e9fd0>, 42)
>>> A_callable.__call__(a, b, 42)
A_callable.__call__(<__main__.A_callable object at 0x7f1ed97fb2b0>, <__main__.B object at 0x7f1ed97e9fd0>, 42)

现在，如果您将参数拆分为self, *args，您基本上只需将第一个参数取出并将其存储在self. 你的第一个论点是a，所以self将是a，你的另一个*args将是b, 42。同样，这正是您所看到的。

于 2019-07-20T16:15:44.570 回答