显式调用 __call__ 有效并使用 __init__

Question

我正在学习 Python 3.X 中的重载，为了更好地理解该主题，我编写了以下在 3.X 中有效但在 2.X 中无效的代码。 我预计下面的代码会失败，因为我没有为 class Test定义__call__ 。 但令我惊讶的是，它有效并打印出"constructor called" 。 演示。

class Test: 
    def __init__(self):
        print("constructor called")
#Test.__getitem__()  #error as expected

Test.__call__() #this works in 3.X(but not in 2.X) and prints "constructor called"! WHY THIS DOESN'T GIVE ERROR in 3.x?

所以我的问题是这段代码如何/为什么在 3.x 中有效，但在 2.x 中无效。 我的意思是我想知道正在发生的事情背后的机制。

更重要的是，为什么在我使用__call__时使用__init__ ？

Answer 1

在 3.x 中：

关于属性查找， type和object

每次在 object 上查找属性时，Python 都会遵循如下过程：

1. 是object中实际数据的直接一部分吗？ 如果是这样，请使用它并停止。

2. 它直接是对象的class的一部分吗？ 如果是这样，请坚持执行第 4 步。

3. 否则，检查对象的 class 是否有__getattr__和__getattribute__覆盖，查看 MRO 中的基类等。（当然，这是一个巨大的简化。）

4. 如果在第 2 步或第 3 步中发现了某些内容，请检查它是否具有__get__ 。 如果是，请查找（是的，这意味着从步骤 1 开始为该对象上名为__get__的属性），调用它，并使用它的返回值。 否则，使用直接返回的内容。

函数自动有一个__get__ ； 它用于实现方法绑定。 类是对象； 这就是为什么可以在其中查找属性的原因。 即： class Test: block 的目的是定义一个数据类型； 该代码创建一个名为 object 的Test ，它表示已定义的数据类型。

但由于Test class 是一个 object，它必须是某个 class 的实例。class 称为type ，并具有内置实现。

>>> type(Test)
<class 'type'>

请注意， type(Test)不是 function 调用。 相反，名称type被预定义为引用 class，在用户代码中创建的每个其他 class 都是（默认情况下）的一个实例。

换句话说， type是默认的元类：类的 class。

>>> type
<class 'type'>

有人会问，class这个type属于什么？ 答案出奇地简单 -本身：

>>> type(type) is type
True

由于上面的例子调用了type ，我们得出结论type是可调用的。 要可调用，它必须具有__call__属性，并且它可以：

>>> type.__call__
<slot wrapper '__call__' of 'type' objects>

当使用单个参数调用type时，它会查找参数的 class（大致相当于访问参数的__class__属性）。 当用三个 arguments 调用时，它会创建一个新的type实例，即一个新的 class。

字体是如何工作type ？

因为这是在语言的核心挖掘（为对象分配 memory），所以不太可能在纯 Python 中实现它，至少对于参考 C 实现（我不知道发生了什么魔法在此处的 PyPy 中）。 但是我们可以像这样大约model type class：

def _validate_type(obj, required_type, context):
    if not isinstance(obj, required_type):
        good_name = required_type.__name__
        bad_name = type(obj).__name__
        raise TypeError(f'{context} must be {good_name}, not {bad_name}')

class type:
    def __new__(cls, name_or_obj, *args):
        # __new__ implicitly gets passed an instance of the class, but
        # `type` is its own class, so it will be `type` itself.
        if len(args) == 0: # 1-argument form: check the type of an existing class.
            return obj.__class__
        # otherwise, 3-argument form: create a new class.
        try:
            bases, attrs = args
        except ValueError:
            raise TypeError('type() takes 1 or 3 arguments')
        _validate_type(name, str, 'type.__new__() argument 1')
        _validate_type(bases, tuple, 'type.__new__() argument 2')
        _validate_type(attrs, dict, 'type.__new__() argument 3')

        # This line would not work if we were actually implementing
        # a replacement for `type`, as it would route to `object.__new__(type)`,
        # which is explicitly disallowed. But let's pretend it does...
        result = super().__new__()
        # Now, fill in attributes from the parameters.
        result.__name__ = name_or_obj
        # Assigning to `__bases__` triggers a lot of other internal checks!
        result.__bases__ = bases
        for name, value in attrs.items():
            setattr(result, name, value)
        return result
    del __new__.__get__ # `__new__`s of builtins don't implement this.

    def __call__(self, *args):
        return self.__new__(self, *args)
    # this, however, does have a `__get__`.

当我们调用 class ( Test() ) 时（概念上）会发生什么？

1. Test()使用函数调用语法，但它不是 function。为了弄清楚应该发生什么，我们将调用转换为Test.__class__.__call__(Test) 。 （我们在这里直接使用__class__ ，因为使用type翻译 function 调用 - 要求type对自身进行分类 - 最终会陷入无休止的递归。）

2. Test.__class__是type ，所以这变成了type.__call__(Test) 。

3. type直接包含一个__call__ （ type是它自己的 class，还记得吗？），所以它是直接使用的——我们不通过__get__描述符调用 go。 我们调用 function， Test为self ，没有其他的 arguments。（我们现在有一个 function，所以我们不需要再次翻译 function 调用语法。我们可以- 给定一个 function func ， func.__class__.__call__.__get__(func)给我们一个未命名的内置“方法包装器”类型的实例，它在调用时做与func相同的事情。在方法包装器上重复循环创建一个单独的方法包装器，它仍然做同样的事情。）

4. 这将尝试调用Test.__new__(Test) （因为self已绑定到Test ）。 Test.__new__未在Test中明确定义，但由于Test是 class，因此我们不查看Test的 class（ type ），而是查看Test的基数（ object ）。

5. object.__new__(Test)存在，并且做了神奇的内置东西来为 class 的新实例分配 memory，使得可以为该实例分配属性（即使Test是Test的子object ，这是不允许的） ，并将其__class__设置为Test 。

类似地，当我们调用type时，相同的逻辑链将type(Test)变成type.__class__.__call__(type, Test)变成type.__call__(type, Test) ，然后转发到type.__new__(type, Test) 。 这一次， type中直接有一个__new__属性，所以这不会回退到查找object 。 相反，将name_or_obj设置为Test ，我们只需返回Test.__class__ ，即type 。 并使用单独的name, bases, attrs属性 arguments， type.__new__而不是创建type的实例。

最后：当我们显式调用Test.__call__()时会发生什么？

如果在 class 中定义了一个__call__ ，它就会被使用，因为它是直接找到的。 但是，这将失败，因为没有足够的 arguments：描述符协议未被使用，因为属性是直接找到的，因此self未绑定，因此缺少该参数。

如果没有定义__call__方法，那么我们查看Test的 class，即type 。 那里有一个__call__ ，所以 rest 像上一节中的步骤 3-5 一样继续。

Answer 2

在 Python 3.x 中，每个 class 隐含地是内置 class object的孩子。 至少在 CPython 实现中， object class 有一个在其元类type中定义的__call__方法。

这意味着Test.__call__()与Test()完全相同，并将返回一个新的Test object，调用您的自定义__init__方法。

在 Python 中，2.x 类默认是旧式类，不是object的子类。 因为__call__没有定义。 您可以通过使用新样式类在 Python 2.x 中获得相同的行为，这意味着通过在 object 上显式显示 inheritance：

# Python 2 new style class
class Test(object):
    ...