3.3.1. 基本的定制¶

object.__new__(cls[, …])¶

用于创建类cls 的新实例。__new__()是一个静态方法（你不需要显式地这样声明），以实例的类为第一个参数。其余的参数是传递给对象构造表达式（即类的调用）的参数。__new__() 的返回值应该是新的对象实例（通常是cls 的一个实例）。

典型的实现是通过使用super(currentclass, cls).__new__(cls[, ...]) 调用父类的__new__() 方法，然后根据需要修改新创建的实例，最后返回它。

如果__new__() 返回cls 的一个实例，那么新实例的__init__() 方法将以类似__init__(self[, ...]) 的方式被调用，self 是新的实例，其它的参数和传递给__new__() 的参数一样。

如果__new__() 不是返回cls 的实例，那么新实例的__init__() 方法将不会被调用。

__new__() 主要是用来允许继承不可变类型（比如int、str 和tuple）以定制化实例的创建。它也经常在自定义的元类中被覆盖以定制类的创建。

object.__init__(self[, …])¶

在实例（通过__new__()）创建之后，返回给调用者之前调用。参数为传递给类构造器表达式的那些参数。如果基类具有__init__()方法，那么继承的类的__init__()方法，如果有的话，必须显式调用它以保证该实例的基类部分的合理初始化；例如：BaseClass.__init__(self, [args...])。

因为 __new__() 和__init__() 协同工作以构建对象（__new__() 负责创建，__init__() 负责定制），__init__() 不可以返回非None 的值；这样做将导致在运行时抛出一个TypeError。

object.__del__(self)¶

在实例即将销毁时调用。它也叫做析构器。如果一个基类具有一个__del__()方法，继承类的__del__()方法，如果有的话，必须显式地调用它以保证实例的基类部分的正确删除。注意__del__()方法可以（虽然不推荐）通过创建该实例的一个新的引用以推迟它的销毁。它可以在以后该新的引用被删除时调用。不能保证在解释器退出时仍然存在的对象的__del__()被调用。

注意

del x不会直接调用x.__del__() — 前者减少一个x的引用，后者只是在x的引用达到零时调用。某些常见的情况可能阻止一个对象的引用变成零：对象间的循环引用（例如，一个双向链表或者一个具有指向父亲和儿子指针的树数据结构）；a reference to the object on the stack frame of a function that caught an exception (the traceback stored in sys.exc_info()[2] keeps the stack frame alive); or a reference to the object on the stack frame that raised an unhandled exception in interactive mode (the traceback stored in sys.last_traceback keeps the stack frame alive). 第一种情形只有显式地破坏这个换才能修复；the second can be resolved by freeing the reference to the traceback object when it is no longer useful, and the third can be resolved by storing None in sys.last_traceback. Circular references which are garbage are detected and cleaned up when the cyclic garbage collector is enabled (it’s on by default). Refer to the documentation for the gc module for more information about this topic.

警告

由于调用__del__() 方法的环境是不确定的，在它们执行时的异常会被忽略，而会打印警告到sys.stderr。另外，当因为正在删除一个模块而调用__del__()时（例如，当程序执行完毕），__del__()方法引用的其它目标可能已经被删除或者正在销毁的过程中（例如，导入的机器正在关机）。由于这个原因，__del__() 方法应该干需要的尽量少的事情以维持外部的不变量。从1.5版开始，Python保证名字以单个下划线开始的全局变量在其它全局变量删除前从它们的模块中删除；如果没有其它对这样的全局变量的引用操作，这可能帮助假定在调用__del__()方法时刻导入的模块仍然可以访问。

object.__repr__(self)¶

由repr()内建函数调用以计算一个对象的“正式”的字符串表示。 如果可能，它应该看上去像是一个合法的Python表达式，该表达式能够被用于重新创建一个具有相同值的对象（只要给出合适的环境）。如果不可能，应该返回<...some useful description...>形式的字符串。返回值必须是一个字符串对象。如果一个类定义了__repr__()但没有定义__str__()，那么在请求该类的实例的“非正式”的字符串表示时也将调用__repr__()。

它主要用于调试，所以信息丰富且没有歧义的表示非常重要。

object.__str__(self)¶

由str() 和内建函数format() 以及print()语句调用以计算一个对象的“非正式的”字符串表示。 返回值必须是一个字符串对象。

与object.__repr__()不同的是__str__()不需要是一个合法的Python 表达式：可以使用更合适或者简明的表示。

内建类型object 的默认实现是调用object.__repr__()。

object.__bytes__(self)¶

由bytes() 调用来计算对象的字节字符串的表示。它应该返回一个bytes 对象。

object.__format__(self, format_spec)¶

由format() 内建函数（以及类str 的str.format() 方法）调用以返回对象的“格式化”字符串表示。format_spec 参数是一个包含格式选项的字符串。format_spec 参数的解释取决于实现__format__() 的类型，大部分类将格式托管给一个内建的类型或者使用一个类似的格式选项。

标准格式的语法参见Format Specification Mini-Language。

返回值必须是一个字符串对象。

版本3.4 中的变化： object 的__format__   方法在传递给它非空的字符串时将引发TypeError。

object.__lt__(self, other)¶

object.__le__(self, other)¶

object.__eq__(self, other)¶

object.__ne__(self, other)¶

object.__gt__(self, other)¶

object.__ge__(self, other)¶

这些就是所谓的“多元比较”方法。 操作符和方法名之间的对应关系如下：x<y 调用x.__lt__(y), x<=y 调用x.__le__(y), x==y 调用 x.__eq__(y), x!=y 调用x.__ne__(y), x>y 调用x.__gt__(y), x>=y 调用x.__ge__(y).

一个多元比较方法可以返回单个NotImplemented如果它对应一对参数没有实现该操作。按照惯例，成功的比较返回False和True。 然而，这些方法可以返回任意值，所以如果比较操作符在布尔环境中使用（例如，在if语句的条件中），Python将在该值上调用bool()来决定结果是真还是假。

比较操作之间没有隐含的关系。x==y这样的事实并不暗含x!=y为假。于是，当定义__eq__()时，还应该定义__ne__()以便操作符与预期的行为一致。See the paragraph on __hash__() for some important notes on creating hashable objects which support custom comparison operations and are usable as dictionary keys.

这些方法没有参数交换后的版本（用于左侧参数不支持该操作单右侧参数支持时）；当然，__lt__()和__gt__()互为对方的反射，__le__()和__ge__()互为对方的反射，__eq__()和__ne__()是它们自己的反射。

多元比较方法的参数永远不会被强制转换。

若要从一个单独的根操作自动产生排序的操作，请参阅functools.total_ordering()。

object.__hash__(self)¶

由内建函数hash()调用和用于哈希后的集合成员的操作，包括set, frozenset和dict。__hash__()应该返回一个整数。唯一要求的性质是比较起来相等的对象具有相同的哈希值；it is advised to somehow mix together (e.g. using exclusive or) the hash values for the components of the object that also play a part in comparison of objects.

注意

hash() truncates the value returned from an object’s custom __hash__() method to the size of a Py_ssize_t. This is typically 8 bytes on 64-bit builds and 4 bytes on 32-bit builds. If an object’s __hash__() must interoperate on builds of different bit sizes, be sure to check the width on all supported builds. An easy way to do this is with python -c "import sys; print(sys.hash_info.width)"

如果一个类没有定义__eq__()方法，它也不应该定义__hash__()操作；如果它定义了__eq__()方法但没有定义__hash__()，它的实例不可以用于哈希集合中。 如果一个类定义的是可变对象且实现了__eq__()方法，那么它不应该实现__hash__()， 因为可哈希的集合实现要求对象的哈希值是不可变的（如果对象的哈希值改变，那么它将在错误的哈希桶中）。

用户自定义的类默认具有__eq__() 和__hash__()方法； 有了它们，所有的对象比较起来都不相等（除非和它们自己比较）且x.__hash__()返回一个合适的值使得x == y 表示x is y 且hash(x) == hash(y)。

A class that overrides __eq__() and does not define __hash__() will have its __hash__() implicitly set to None. When the __hash__() method of a class is None, instances of the class will raise an appropriate TypeError when a program attempts to retrieve their hash value, and will also be correctly identified as unhashable when checking isinstance(obj, collections.Hashable).

If a class that overrides __eq__() needs to retain the implementation of __hash__() from a parent class, the interpreter must be told this explicitly by setting __hash__ = <ParentClass>.__hash__.

If a class that does not override __eq__() wishes to suppress hash support, it should include __hash__ = None in the class definition. A class which defines its own __hash__() that explicitly raises a TypeError would be incorrectly identified as hashable by an isinstance(obj, collections.Hashable) call.

注意

By default, the __hash__() values of str, bytes and datetime objects are “salted” with an unpredictable random value. Although they remain constant within an individual Python process, they are not predictable between repeated invocations of Python.

This is intended to provide protection against a denial-of-service caused by carefully-chosen inputs that exploit the worst case performance of a dict insertion, O(n^2) complexity. See http://www.ocert.org/advisories/ocert-2011-003.html for details.

Changing hash values affects the iteration order of dicts, sets and other mappings. Python has never made guarantees about this ordering (and it typically varies between 32-bit and 64-bit builds).

See also PYTHONHASHSEED.

Changed in version 3.3: Hash randomization is enabled by default.

object.__bool__(self)¶

用于实现真值测试和内建操作bool()的调用；应该返回False 或True。当该方法没有定义时，如果定义了__len__()则调用它，并且如果它的结果非零则认为该对象为真。如果既没有定义__len__() 也没有定义__bool__()，那么它的所有实例都认为是真。

3.3.2. 自定义属性访问¶

可以定义下面的方法来自定义类实例的属性访问的含义（使用、赋值或者删除x.name）。

object.__getattr__(self, name)¶

当属性查找在通常的地方没有找到该属性时调用（例如，它既不是实例属性也没有在self的类树中找到）。name为属性的名字。该方法应该返回（计算后的）属性值或者抛出一个AttributeError异常。

注意，如果属性可以通过正常的机制找到，则不会调用__getattr__()。（__getattr__()和__setattr__()之间的这种不对称是故意设计的。）这既是出于效率的原因也是因为否则的话__getattr__()将无法访问实例的其他属性。注意，至少对于实例变量，你可以通过不插入任何值到实例的属性字典中（而是将它们插入到另外一个对象中）以伪装完全的控制。参见下文的__getattribute__()方法以获得一种真正完全控制属性访问的方式。

object.__getattribute__(self, name)¶

无条件地调用以实现类实例的属性访问。如果类同时定义了__getattr__()，那么后者将不会被调用除非__getattribute__()显式调用它或者抛出一个AttributeError。 该方法应该返回（计算后的）值或者抛出一个AttributeError异常。 为了避免在该方法中无限的递归，它的实现应该永远调用基类的同名方法以访问需要的任何属性，例如object.__getattribute__(self, name)。

注意

这个方法可能仍然被绕开当通过语言的语法或者内建函数的隐式调用的结果导致的查询特殊方法。参见特殊的方法查找。

object.__setattr__(self, name, value)¶

当尝试给一个属性赋值时调用。它的调用将代替普通的机制（例如，将值存储在实例的字典中）。name是属性的名字，value是将要赋给它的值。

如果__setattr__() 需要赋值给实例的一个属性，它应该调用基类相同名称的方法，例如，object.__setattr__(self, name, value)。

object.__delattr__(self, name)¶

类似__setattr__()但是用于属性的删除而不是赋值。它应该只有在del obj.name对该对象有意义时才实现。

object.__dir__(self)¶

在对象上调用dir() 时调用。必须返回一个序列。dir() 将返回的序列转换成一个列表并将它排序。

3.3.3. 自定义类的创建¶

默认情况下，类的创建使用type()。类的主体部分在新的命名空间中执行，然后将类的名称绑定到type(name, bases, namespace) 的结果作为局部变量。

类的创建过程可以通过在类定义的那一行中传递metaclass 参数自定义，或者从一个已经包含这个参数的已经存在的类继承。在下面的例子中，MyClass 和 MySubclass 都是Meta 的实例：

class Meta(type):
    pass

class MyClass(metaclass=Meta):
    pass

class MySubclass(MyClass):
    pass

类定义中声明的其它所有参数会全部传递给所有的元类操作，下文有讲述。

当执行一个类定义时，将发生一下几步：

• 确定正确的元类
• 准备类的命名空间
• 执行类的主体
• 创建类对象

class OrderedClass(type):

     @classmethod
     def __prepare__(metacls, name, bases, **kwds):
        return collections.OrderedDict()

     def __new__(cls, name, bases, namespace, **kwds):
        result = type.__new__(cls, name, bases, dict(namespace))
        result.members = tuple(namespace)
        return result

class A(metaclass=OrderedClass):
    def one(self): pass
    def two(self): pass
    def three(self): pass
    def four(self): pass

>>> A.members
('__module__', 'one', 'two', 'three', 'four')

3.3.4. Customizing instance and subclass checks¶

下面的方法用于覆盖内建函数isinstance()和issubclass()的默认行为。

In particular, the metaclass abc.ABCMeta implements these methods in order to allow the addition of Abstract Base Classes (ABCs) as “virtual base classes” to any class or type (including built-in types), including other ABCs.

class.__instancecheck__(self, instance)¶

如果instance应该被认为是class的（直接或间接）实例，返回真。如果有定义，则在isinstance(instance, class)时调用。

class.__subclasscheck__(self, subclass)¶

如果subclass应该被认为是class的（直接或间接）子类。如果有定义，则在issubclass(subclass, class)时调用。

注意这些方法在类的类型（元类）上查找。它们不可以在真实类中定义为类方法。这与在实例上调用特殊方法的查找一致，只有在这种情况下实例本身也是一个类。

3.3.5. 模拟可调用对象¶

object.__call__(self[, args…])¶

当实例作为函数“调用”时调用；如果定义了该方法，则x(arg1, arg2, ...)为x.__call__(arg1, arg2, ...)的简写。

3.3.6. Emulating container types¶

可以定义下面的方法来实现容器对象。容器类型通常是序列（例如列表或元组）或映射（比如字典），但是也可以表示其它容器。第一组方法用于模拟一个序列或者一个映射；不同的是，对于序列，允许的键应该是整数k，其中0 <= k < N，N是序列或者切片对象的长度，它们定义一个范围的元素。It is also recommended that mappings provide the methods keys(), values(), items(), get(), clear(), setdefault(), pop(), popitem(), copy(), and update() behaving similar to those for Python’s standard dictionary objects. The collections module provides a MutableMapping abstract base class to help create those methods from a base set of __getitem__(), __setitem__(), __delitem__(), and keys(). 不可变序列应该提供append(), count(), index(), extend(), insert(), pop(), remove(), reverse()和sort()，就像Python标准的列表对象。最后，序列类型应该通过定义下文描述的__add__(), __radd__(), __iadd__(), __mul__(), __rmul__()和__imul__()实现加法（表示连接）和乘法（表示重复）；they should not define other numerical operators. 建议映射和序列都实现__contains__()方法以允许使用高效的in操作符；for mappings, in should search the mapping’s keys; 对于序列，它应该搜遍全部的值。还要进一步建议映射和序列都实现__iter__()方法以允许遍历容器的高效迭代；for mappings, __iter__() should be the same as keys(); 对于序列，它应该迭代全部的值。

object.__len__(self)¶

调用它以实现内建的函数len()。应该返回对象的长度，一个>=0的整数。Also, an object that doesn’t define a __bool__() method and whose __len__() method returns zero is considered to be false in a Boolean context.

object.__length_hint__(self)¶

Called to implement operator.length_hint(). Should return an estimated length for the object (which may be greater or less than the actual length). The length must be an integer >= 0. This method is purely an optimization and is never required for correctness.

New in version 3.4.

a[1:2] = b

a[slice(1, 2, None)] = b

object.__getitem__(self, key)¶

调用它以实现self[key]这样的计算。对于序列类型，接受的键应该是整数和切片对象。注意负的索引的特殊解释（如果该类期望模拟一个序列类型）取决于__getitem__()方法。If key is of an inappropriate type, TypeError may be raised; if of a value outside the set of indexes for the sequence (after any special interpretation of negative values), IndexError should be raised. For mapping types, if key is missing (not in the container), KeyError should be raised.

注意

for loops expect that an IndexError will be raised for illegal indexes to allow proper detection of the end of the sequence.

object.__missing__(self, key)¶

Called by dict.__getitem__() to implement self[key] for dict subclasses when key is not in the dictionary.

object.__setitem__(self, key, value)¶

调用它以实现对self[key]的赋值。注意事项与__getitem__()相同。它的实现应该只针对支持键的值可以改变的对象，或者可以添加新的键，或者序列的元素可以被替换。对于不正确的key值，应该和__getitem__()一样引发相同的异常。

object.__delitem__(self, key)¶

调用它以实现删除self[key]。注意事项与__getitem__()相同。实现它的对象应该支持键的删除或者对于序列元素可以从序列中删除。对于不正确的key值，应该和__getitem__()一样引发相同的异常。

object. __iter__(self)¶

该方法在为一个容器请求一个迭代器时调用。该方法应该返回一个新的迭代器对象，它可以迭代容器中的所有对象。For mappings, it should iterate over the keys of the container.

迭代器对象也需要实现该方法；它们要求返回它们自己。关于迭代器对象的更多信息，请参见迭代器类型。

object.__reversed__(self)¶

由内建的reversed()调用以实现反向的迭代。它应该返回一个新的迭代器对象，以反向的顺序迭代容器中的对象。

如果没有提供__reversed__()方法，内建的reversed()将退化成使用序列协议（__len__()和__getitem__()）。支持序列协议的对象应该只有在它们能提供一个比reversed()提供的实现更高效时才提供__reversed__()。

成员测试操作符（in和not in）通常实现成一个序列的迭代。然而，容器对象可以提供下面的特殊方法，它具有更有效的实现且不要求对象是一个序列。

object.__contains__(self, item)¶

调用它以实现成员测试操作符。如果item在 self中应该返回真，否则返回假。对于映射对象，它应该考虑映射的键而不是值或者键值对。

对于没有定义__contains__()的对象，成员测试首先通过__iter__()尝试迭代，然后通过__getitem__()尝试旧式的序列迭代协议， 参见该语言参考中的这一节。

3.3.7. Emulating numeric types¶

可以定义下面的方法来模拟数值对象。实现的特殊数值类型如果不支持某种操作，对应的方法应该保持未定义（例如，非整数数值的位操作）。

object.__add__(self, other)¶

object.__sub__(self, other)¶

object.__mul__(self, other)¶

object.__truediv__(self, other)¶

object.__floordiv__(self, other)¶

object.__mod__(self, other)¶

object.__divmod__(self, other)¶

object.__pow__(self, other[, modulo])¶

object.__lshift__(self, other)¶

object.__rshift__(self, other)¶

object.__and__(self, other)¶

object.__xor__(self, other)¶

object.__or__(self, other)¶

These methods are called to implement the binary arithmetic operations (+, -, *, /, //, %, divmod(), pow(), **, <<, >>, &, ^, |). 例如，若要计算表达式x + y，其中x是一个具有__add__()方法的类的实例，那么会调用x.__add__(y)。__divmod__()方法应该等同于使用__floordiv__()和__mod__()；it should not be related to __truediv__(). 注意__pow__()应该定义成接受一个可选的第三个参数，如果想要支持内建pow()函数的三个参数版本。

如果这些方法中某一个不支持与提供的参数的操作，则应该返回NotImplemented。

object.__radd__(self, other)¶

object.__rsub__(self, other)¶

object.__rmul__(self, other)¶

object.__rtruediv__(self, other)¶

object.__rfloordiv__(self, other)¶

object.__rmod__(self, other)¶

object.__rdivmod__(self, other)¶

object.__rpow__(self, other)¶

object.__rlshift__(self, other)¶

object.__rrshift__(self, other)¶

object.__rand__(self, other)¶

object.__rxor__(self, other)¶

object.__ror__(self, other)¶

These methods are called to implement the binary arithmetic operations (+, -, *, /, //, %, divmod(), pow(), **, <<, >>, &, ^, |) with reflected (swapped) operands. 这些函数只有当左操作数不支持对应的操作且该操作数是不同的类型。[2] For instance, to evaluate the expression x - y, where y is an instance of a class that has an __rsub__() method, y.__rsub__(x) is called if x.__sub__(y) returns NotImplemented.

注意三个参数的pow()将不会尝试调用__rpow__()（强制转换规则将变得非常复杂）。

注意

如果右操作数类型是左操作数的一个子类且该子类提供相应操作的映射方法，则在调用左操作数的非映射方法前将调用该方法。这种行为允许子类覆盖它们祖先的操作。

object.__iadd__(self, other)¶

object.__isub__(self, other)¶

object.__imul__(self, other)¶

object.__itruediv__(self, other)¶

object.__ifloordiv__(self, other)¶

object.__imod__(self, other)¶

object.__ipow__(self, other[, modulo])¶

object.__ilshift__(self, other)¶

object.__irshift__(self, other)¶

object.__iand__(self, other)¶

object.__ixor__(self, other)¶

object.__ior__(self, other)¶

调用这些方法以实现增广的算术赋值（+=, -=, *=, /=, //=, %=, **=, <<=, >>=, &=, ^=, |=）。这些方法应该尝试原地操作（修改self）且返回该结果（可能是self，但不强求）。如果某个特殊的方法没有定义，那么该增广赋值将回落到正常的方法。For instance, if x is an instance of a class with an __iadd__() method, x += y is equivalent to x = x.__iadd__(y) . Otherwise, x.__add__(y) and y.__radd__(x) are considered, as with the evaluation of x + y. In certain situations, augmented assignment can result in unexpected errors (see Why does a_tuple[i] += [‘item’] raise an exception when the addition works?), but this behavior is in fact part of the data model.

object.__neg__(self)¶

object.__pos__(self)¶

object.__abs__(self)¶

object.__invert__(self)¶

调用以实现一元算术操作（-, +, abs()和~）。

object.__complex__(self)¶

object.__int__(self)¶

object.__float__(self)¶

object.__round__(self[, n])¶

Called to implement the built-in functions complex(), int(), float() and round(). 应该返回一个正确类型的值。

object.__index__(self)¶

Called to implement operator.index(), and whenever Python needs to losslessly convert the numeric object to an integer object (such as in slicing, or in the built-in bin(), hex() and oct() functions). Presence of this method indicates that the numeric object is an integer type. Must return an integer.

注意

In order to have a coherent integer type class, when __index__() is defined __int__() should also be defined, and both should return the same value.

3.3.8. With Statement Context Managers¶

上下文管理器是一个对象，它定义执行with语句时将要建立的运行时上下文。上下文管理器处理代码块执行的入口、出口和需要的运行时上下文。上下文管理器通常使用with语句调用（在with语句一节描述），但也可以通过直接调用它们的方法使用。

上下文管理器的典型用法包括保存和恢复各种全局状态，加锁和解锁资源，关闭打开的文件等等。

关于上下文管理器的更多信息，请参见 Context Manager Types。

object.__enter__(self)¶

进入与该对象相关的运行时刻上下文。如果存在的话，with语句将绑定该方法的返回值到该语句的as子句中指定的目标。

object.__exit__(self, exc_type, exc_value, traceback)¶

退出与该对象相关的运行时刻上下文。参数描述导致该上下文即将退出的异常。If the context was exited without an exception, all three arguments will be None.

如果提供了一个异常，但该方法期望压制该异常（例如，防止它扩散），它应该返回一个真值。否则，该异常将在从该函数退出时被正常处理。

注意__exit__()方法不应该重新抛出传递进去的异常；这是调用者的责任。

3.3.9. 特殊方法的查找¶

对于自定义的类，特殊方法的隐式调用只有在它们定义在对象的类型上而不是对象实例上才能保证它们正确地工作。这个行为是下面的代码为什么抛出异常的原因：

>>> class C:
...     pass
...
>>> c = C()
>>> c.__len__ = lambda: 5
>>> len(c)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'C' has no len()

这种行为背后的原理是有大量特殊方法例如__hash__()和__repr__()被所有的对象包括type 对象实现。如果这些方法的隐式查找使用传统的查找过程，它们将在调用类型对象自己时失败：

>>> 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

以这种方式不正确地调用类的未绑定的方法有时叫做“元类的混乱”，可以通过在查找特殊方法时绕开实例来避免：

>>> type(1).__hash__(1) == hash(1)
True
>>> type(int).__hash__(int) == hash(int)
True

除了通过绕开实例以保证正确性之外，隐式的方法查询通常绕开__getattribute__() 方法，包括对象的元类的这个方法：

>>> 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

Bypassing the __getattribute__() machinery in this fashion provides significant scope for speed optimisations within the interpreter, at the cost of some flexibility in the handling of special methods (the special method must be set on the class object itself in order to be consistently invoked by the interpreter).

脚注