对特殊方法的访问

对特殊方法的访问 - Special method lookup

    对于用户自定义的 class 来说, 特殊方法只有通过定义对象的类型object’s type (而非通过 instance
    的 __dict__属性)被定义, 才能保证特殊方法的隐式调用.
    也就是说给自定义的 class 打 特殊方法的 monkey patching 后,再通过 conventional'传统方式' 调用是行不通的.
        注, conventional'传统方式' 调用 指的是如下面例子中 len() 跟 __len__() 的对应关系.
    见下例的 exception,
        例,
            >>> class C:
            ...     pass
            ...
            >>> c = C()
            >>> c.__len__ = lambda: 5
            >>> c.__len__()
            5
            >>> len(c)
            Traceback (most recent call last):
              File "<stdin>", line 1, in <module>
            TypeError: object of type 'C' has no len()

        报错的原因在于, 所有对象(包括类型对象) 都有实现特殊方法, 如果通过'传统方式'隐式调用
        这些特殊方法(len(c)), 当在类型对象本身上调用对应的特殊方法的时候便会失败.
        详见 python doc 中的描述,
            The rationale behind this behaviour lies with a number of special methods such as __hash__() and __repr__()
            that are implemented by all objects, including type objects.
            If the implicit lookup of these methods used the conventional lookup process,
            they would fail when invoked on the type object itself:

        例如,
            >>> 1 .__hash__() == hash(1)
            True
            >>> int.__hash__() == hash(int)
            Traceback (most recent call last):
              File "<stdin>", line 1, in <module>
            TypeError: descriptor '__hash__' of 'int' object needs an argument

            错误在于, 试图去调用一个类(int) 的 unbound method(__hash__), 有时这样的错误调用行为
            被称作‘metaclass confusion’. 可以采取通过 instance 访问 special methods
            的方式绕过 ‘metaclass confusion’.
            >>> type(1).__hash__(1) == hash(1)
            True
            >>> type(int).__hash__(int) == hash(int)
            True

            这样做的另外的一个好处是, 对特殊方法的隐式调用同时也绕过 __getattribute__ 方法,
            对该对象的的 metaclass 来说也是这样.
            >>> class Meta(type):
            ...     def __getattribute__(*args):
            ...         print("Metaclass getattribute invoked")
            ...         return type.__getattribute__(*args)
            ...
            >>> class C(object, metaclass=Meta):
            ...     def __len__(self):
            ...         return 10
            ...     def __getattribute__(*args):
            ...         print("Class getattribute invoked")
            ...         return object.__getattribute__(*args)
            ...
            >>> c = C()
            >>> c.__len__()                 # Explicit lookup via instance
            Class getattribute invoked
            10
            >>> type(c).__len__(c)          # Explicit lookup via type
            Metaclass getattribute invoked
            10
            >>> len(c)                      # Implicit lookup
            10

    summarize,
        '绕过' __getattribute__ 的机制最佳化了解释器的解释速度, 而这种机制是通过对特殊方法的灵活处理
        实现的,即特殊方法必须在类对象本身上 set, 而不能通过 monkey patching,再通过 conventional'传统方式' 调用.

        注,
            conventional'传统方式' 调用 指的是诸如例子中 len() 跟 __len__() 的对应关系.

    reference,
        python doc,
            https://docs.python.org/3/reference/datamodel.html#special-lookup