3.4.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...])。构造器的一个特殊限制是不可以返回任何值；这样做将导致运行时抛出一个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_traceback 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). 第一种情形只有显式地破坏这个换才能修复；后两种情形可以通过保存None到sys.exc_traceback或sys.last_traceback中解决。已经成为垃圾的循环引用在循环检测选项启用时检测（默认是打开的），但是只有当没有Python级别的__del__()方法时才会被清除。参见gc模块的文档以获得关于循环检测器如何处理__del__()方法的更多信息，特别是garbage值的描述。

警告

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

另请参阅-R命令行选项。

object.__repr__(self)¶

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

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

object.__str__(self)¶

由str()内建函数和print语句调用以计算一个对象的“非正式的”字符串表示。与__repr__()不同的是它不需要是一个合法的Python表达式：可以使用更合适或者简明的表示。返回值必须是一个字符串对象。

object.__lt__(self, other)¶

object.__le__(self, other)¶

object.__eq__(self, other)¶

object.__ne__(self, other)¶

object.__gt__(self, other)¶

object.__ge__(self, other)¶

2.1版中新增。

这些就是所谓的“多元比较”方法，且优先于下文的__cmp__()调用。操作符和方法名之间的对应关系如下：x<y调用x.__lt__(y)，x<=y调用x.__le__(y)，x==y 调用x.__eq__(y)，x!=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.__cmp__(self, other)¶

如果没有定义多元比较（见上文），则调用比较操作。如果self < other，应该返回一个负整数；如果self == other，应该返回零；如果self > other，应该返回一个正整数。如果__cmp__()、__eq__()和__ne__()操作都没有定义，那么类的实例通过对象的ID（“地址”）比较。See also the description of __hash__() for some important notes on creating hashable objects which support custom comparison operations and are usable as dictionary keys. （注：__cmp__()不会传播异常的限制已经自Python 1.5移除。）

object.__rcmp__(self, other)¶

版本2.1中的变化：不再支持。

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.

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

用户自定义的类默认具有__cmp__()和__hash__()方法；有了它们，所有的对象比较起来都不相等（除非和它们自己比较）且x.__hash__()返回一个从id(x)得到的结果。

Classes which inherit a __hash__() method from a parent class but change the meaning of __cmp__() or __eq__() such that the hash value returned is no longer appropriate (e.g. by switching to a value-based concept of equality instead of the default identity based equality) can explicitly flag themselves as being unhashable by setting __hash__ = None in the class definition. Doing so means that not only will instances of the class raise an appropriate TypeError when a program attempts to retrieve their hash value, but they will also be correctly identified as unhashable when checking isinstance(obj, collections.Hashable) (unlike classes which define their own __hash__() to explicitly raise TypeError).

2.5版中的变化： __hash__() 现在也可以返回一个长整数对象；该32位整数从该对象的哈希值获得。

2.6版中的变化：__hash__现在可以设置为None以显示地标志一个类的实例是可哈希的。

object.__nonzero__(self)¶

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

object.__unicode__(self)¶

用于实现内建的unicode()调用；应该返回一个Unicode对象。当该方法没有定义时，则尝试字符串转换，并且将字符串转换的结果使用系统默认的编码转换为Unicode。

3.4.2. 自定义属性访问¶

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

object.__getattr__(self, name)¶

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

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

object.__setattr__(self, name, value)¶

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

如果__setattr__()想赋值给一个实例属性，它不应该简单地执行self.name = value — 这将导致递归调用它自己。相反，它应该将该值插入到实例属性的字典中，例如，self.__dict__[name] = value。对于新式类，它应该调用基类相同名称的方法，而不是访问实例的字典，例如，object.__setattr__(self, name, value)。

object.__delattr__(self, name)¶

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

3.4.3. 自定义类的创建¶

默认情况下，新式类使用type()构建。类定义被读取到一个单独的命名空间，然后类名称的值被绑定到type(name, bases, dict)的结果。

当读取类定义时，如果定义了__metaclass__，那么赋给它的可调用对象将被调用而不再调用type()。这允许类或者函数可以被覆盖，这样可以监控或者改变类创建的过程：

• Modifying the class dictionary prior to the class being created.
• Returning an instance of another class – essentially performing the role of a
  factory function.

这些步骤必须在元类的__new__()方法中去做 – 然后可以在这个方法中调用type.__new__()来创建一个具有不同属性的类。下面的例子在创建类之前添加一个新的元素到类的字典中：

class metacls(type):
    def __new__(mcs, name, bases, dict):
        dict['foo'] = 'metacls was here'
        return type.__new__(mcs, name, bases, dict)

当然你也可以覆盖其它的类方法（或者添加新方法）；例如在元类中定义一个定制的__call__()方法允许调用该类时的自定义行为，例如不用始终创建一个新的实例。

__metaclass__¶

该变量可以是任何可调用形式，它接受name、bases和dict参数。在类创建时，该可调用对象将代替内建的type()使用。

2.2版中新增。

恰当的元类由下面的过程规则决定：

• 如果存在dict['__metaclass__']，则使用它。
• 否则，如果至少有一个基类，则使用它的元类（首先寻找__class__属性，如果不存在则使用它的类型）。
• 否则，如果存在一个名为__metaclass__的全局变量，则使用它。
• 否则，按照旧的方式，使用经典的metaclass(type.ClassType)。

元类的潜在使用方式没有限制。使用场景包括日志打印、接口检查、自动托管、自动的属性创建、代理、框架和自动的资源加锁/同步。

3.4.4. 自定义实例和子类的检查¶

2.6版中新增。

下面的方法用于覆盖内建函数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.4.5. 模拟可调用对象¶

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

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

3.4.6. 模拟容器类型¶

可以定义下面的方法来实现容器对象。容器类型通常是序列（例如列表或元组）或映射（比如字典），但是也可以表示其它容器。第一组方法用于模拟一个序列或者一个映射；不同的是，对于序列，允许的键应该是整数k，其中0 <= k < N，N是序列或者切片对象的长度，它们定义一个范围的元素。（为了向后兼容，也可以定义__getslice__()方法（见下文）来处理简单的切片，扩展的切片不可以。）同时建议映射类型提供keys(), values(), items(), has_key(), get(), clear(), setdefault(), iterkeys(), itervalues(), iteritems(), pop(), popitem(), copy()和 update() 方法，且行为与Python标准字典对象相似。The UserDict 模块提供一个DictMixin类来帮助从一个基础的__getitem__(), __setitem__(), __delitem__()和keys()集合中创建这些方法。不可变序列应该提供append(), count(), index(), extend(), insert(), pop(), remove(), reverse()和sort()，就像Python标准的列表对象。最后，序列类型应该通过定义下文描述的__add__(), __radd__(), __iadd__(), __mul__(), __rmul__()和__imul__()实现加法（表示连接）和乘法（表示重复）；它们不应该定义__coerce__()或其它数值操作符。建议映射和序列都实现__contains__()方法以允许使用高效的in操作符；对于映射，in应该等同于has_key()；对于序列，它应该搜遍全部的值。还要进一步建议映射和序列都实现__iter__()方法以允许遍历容器的高效迭代；对于映射，__iter__()应该与iterkeys()相同；对于序列，它应该迭代全部的值。

object.__len__(self)¶

调用它以实现内建的函数len()。应该返回对象的长度，一个>=0的整数。另外，一个没有定义__nonzero__()方法且__len__()方法回执零的对象在布尔上下文中被认为是假。

object.__getitem__(self, key)¶

调用它以实现self[key]这样的计算。对于序列类型，接受的键应该是整数和切片对象。注意负的索引的特殊解释（如果该类期望模拟一个序列类型）取决于__getitem__()方法。如果key是一个不合适的类型，可能引发 TypeError；如果是一个位于序列的索引集之外的值（在负值有特殊解释之后），应该引发 IndexError。对于映射类型，如果key不存在（不在容器中），应该引发KeyError。

注

for循环期望非法的索引将引发一个IndexError以允许正确地检测到序列的结束。

object.__setitem__(self, key, value)¶

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

object.__delitem__(self, key)¶

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

object.__iter__(self)¶

该方法在为一个容器请求一个迭代器时调用。该方法应该返回一个新的迭代器对象，它可以迭代容器中的所有对象。对于映射，它应该在容器的键上迭代，且应该也可以像iterkeys()一样可以访问。

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

object.__reversed__(self)¶

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

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

2.6版中新增。

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

object.__contains__(self, item)¶

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

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

3.4.7. 模拟序列类型的额外方法¶

可以定义下面可选的方法以进一步模拟序列对象。不可变序列的方法应该至多值定义__getslice__()；可变对象可以定义所有的三种方法。

object.__getslice__(self, i, j)¶

从2.0版后废弃： 支持类似__getitem__()方法的切片对象。（然后，CPython中的内建类型仍然实现了__getslice__()。因此，当实现切片时你必须在子类中覆盖它。）

调用它以实现计算self[i:j]。返回的对象应该与self的类型相同。注意在切片表达式中省略的i或j将分别被零或sys.maxint替换。如果在切片中使用了负索引，将在该索引加上序列的长度。如果该实例没有实现__len__()方法，将引发一个AttributeError。无法保证这种方法调整过的索引仍然不是负数。大于序列长度的索引不会给修改。如果找不到__getslice__()，则创建一个切片对象并传递给__getitem__()。

object.__setslice__(self, i, j, sequence)¶

调用它以实现对self[i:j]的赋值。i和j的注意事项与__getslice__()相同。

该方法被废弃了。如果找不到__setslice__()，或者对于扩展的切片形式self[i:j:k]，则创建一个切片对象并传递给__setitem__()，而不是调用__setslice__()。

object.__delslice__(self, i, j)¶

调用它以实现对self[i:j]的删除。i和j的注意事项与__getslice__()相同。该方法已经被废弃了。如果找不到__delslice__()，或者对于扩展的切片形式self[i:j:k]，则创建一个切片对象并传递给__delitem__()，而不是调用__delslice__()。

注意这些方法只有在使用具有单个冒号的单个切片且切片方法可用时才调用。对于调用扩展切片符号的切片操作，或者切片方法不存在时，则以一个切片对象作为参数调用__getitem__(), __setitem__()或__delitem__()。

下面的实例演示如何使得你的程序或模块与早期版本的Python兼容（假设__getitem__(), __setitem__()和__delitem__()方法支持切片对象为参数）：

class MyClass:
    ...
    def __getitem__(self, index):
        ...
    def __setitem__(self, index, value):
        ...
    def __delitem__(self, index):
        ...

    if sys.version_info < (2, 0):
        # They won't be defined if version is at least 2.0 final

        def __getslice__(self, i, j):
            return self[max(0, i):max(0, j):]
        def __setslice__(self, i, j, seq):
            self[max(0, i):max(0, j):] = seq
        def __delslice__(self, i, j):
            del self[max(0, i):max(0, j):]
    ...

注意对max()的调用；它们是必要的因为在调用__*slice__()方法前对负索引的处理。当使用负索引时，__*item__()方法收到的参数与提供的参数相同，但是__*slice__()方法得到的是索引值经过“转换后”的形式。对于每一个负索引值，在调用该方法前会加上序列的长度（结果可能仍然是负索引）；这是内建序列类型对负索引通常的处理方式，期望__*item__()方法也这么做。然而，因为它们已经这么做了，负索引不可能传进去；它们必须被限制在序列的边界在传递给__*item__()方法之前。顺便调用max(0, i)可以返回合适的值。

3.4.8. 模拟数值类型¶

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

object.__add__(self, other)¶

object.__sub__(self, other)¶

object.__mul__(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)¶

调用这些方法以实现二元算术操作（+, -, *, //, %, divmod(), pow(), **, <<, >>, &, ^, |）。例如，若要计算表达式x + y，其中x是一个具有__add__()方法的类的实例，那么会调用x.__add__(y)。__divmod__()方法应该等同于使用__floordiv__()和__mod__()；不应该与__truediv__()（下文有讲述）相关。注意__pow__()应该定义成接受一个可选的第三个参数，如果想要支持内建pow()函数的三个参数版本。

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

object.__div__(self, other)¶

object.__truediv__(self, other)¶

除法操作（/）通过这些方法实现。__truediv__()方法在__future__.division生效时使用，否则使用__div__()。只有这两个方法只定义了一个时，对象才不会支持可选上下文中的除法；取而代之的是引发TypeError。

object.__radd__(self, other)¶

object.__rsub__(self, other)¶

object.__rmul__(self, other)¶

object.__rdiv__(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)¶

调用这些方法以实现具有映射（交换）操作数的二元算术操作（+, -, *, /, %, divmod(), pow(), **, <<, >>, &, ^, |）。这些函数只有当左操作数不支持对应的操作且该操作数是不同的类型。[2]例如，要计算表达式x - y，其中y是一个具有__rsub__()方法的类的实例，如果x.__sub__(y)返回NotImplemented则调用y.__rsub__(x)。

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

Note

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

object.__iadd__(self, other)¶

object.__isub__(self, other)¶

object.__imul__(self, other)¶

object.__idiv__(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，但不强求）。如果某个特殊的方法没有定义，那么该增广赋值将回落到正常的方法。例如，若要执行语句x += y，其中x是一个具有__iadd__()方法的类的实例，将调用x.__iadd__(y)。如果x是一个不支持__iadd__()方法的类的实例，那么将考虑x.__add__(y)和y.__radd__(x)，类似计算x + y。

object.__neg__(self)¶

object.__pos__(self)¶

object.__abs__(self)¶

object.__invert__(self)¶

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

object.__complex__(self)¶

object.__int__(self)¶

object.__long__(self)¶

object.__float__(self)¶

调用以实现内建函数complex(), int(), long()和float()。应该返回一个正确类型的值。

object.__oct__(self)¶

object.__hex__(self)¶

调用以实现内建函数oct()和hex()。应该返回一个字符串值。

object.__index__(self)¶

调用以实现operator.index()。也会在Python需要一个整数对象（例如切片）时调用。必须返回一个整数（整数或长整数）。

2.5版中新增。

object.__coerce__(self, other)¶

调用时实现“混合模式“的数值算术。应该返回一个二元元组，包含self和另外一个转换成相同类型的other，如果转换不可能则应该返回None。如果共同的类型是other的类型，返回None就足够了，因为解释器还会请求另外一个对象尝试强制转换（但有时，如果另外一个类型不可以改变，在这里做转换还是有用的）。NotImplemented返回值等同于返回None。

3.4.9. 隐式转换规则¶

这一节用于记录隐式转换的规则。随着语言的逐步发展，隐式转换的规则已经变得很难精确地记录下来；记录某个特殊实现的一个版本所做的工作是不需要的。取而代之，这里是一些针对强制转换的非正式的指导。在Python 3中，隐式转换将不再支持。

• 如果%操作的左操作数是一个字符串或Unicode对象，则不会发生强制转换而是调用字符串格式化操作。

• 不再建议定义强制转换操作。在没有定义强制转换类型上的混合模式操作将传递原始的参数给该操作。

• New-style classes (those derived from object) never invoke the __coerce__() method in response to a binary operator; the only time __coerce__() is invoked is when the built-in function coerce() is called.

• 对于大多数意图和目的，返回NotImplemented的操作当作与完全没有实现该操作相同。

• Below, __op__() and __rop__() are used to signify the generic method names corresponding to an operator; __iop__() is used for the corresponding in-place operator. For example, for the operator ‘+‘, __add__() and __radd__() are used for the left and right variant of the binary operator, and __iadd__() for the in-place variant.

• For objects x and y, first x.__op__(y) is tried. If this is not implemented or returns NotImplemented, y.__rop__(x) is tried. If this is also not implemented or returns NotImplemented, a TypeError exception is raised. 但请参见下面的例外：

• Exception to the previous item: if the left operand is an instance of a built-in type or a new-style class, and the right operand is an instance of a proper subclass of that type or class and overrides the base’s __rop__() method, the right operand’s __rop__() method is tried before the left operand’s __op__() method.

  This is done so that a subclass can completely override binary operators. Otherwise, the left operand’s __op__() method would always accept the right operand: when an instance of a given class is expected, an instance of a subclass of that class is always acceptable.

• When either operand type defines a coercion, this coercion is called before that type’s __op__() or __rop__() method is called, but no sooner. If the coercion returns an object of a different type for the operand whose coercion is invoked, part of the process is redone using the new object.

• When an in-place operator (like ‘+=‘) is used, if the left operand implements __iop__(), it is invoked without any coercion. When the operation falls back to __op__() and/or __rop__(), the normal coercion rules apply.

• 在x + y中，如果x是一个实现了序列连接的序列，则调用序列连接。

• 在x * y中，如果一个操作数是一个实现了序列重复的序列，且另外一个是一个整数（int或long)，则调用序列重复。

• Rich comparisons (implemented by methods __eq__() and so on) never use coercion. Three-way comparison (implemented by __cmp__()) does use coercion under the same conditions as other binary operations use it.

• 在当前实现中，内建数值类型int, long, float和complex不使用强制转换。所有这些类型实现了一个__coerce__()方法，以用于内建的coerce()函数。

  2.7版中新的变化。

3.4.10. With语句的上下文管理器¶

2.5版中新引入。

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

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

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

object.__enter__(self)¶

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

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

退出与该对象相关的运行时刻上下文。参数描述导致该上下文即将退出的异常。如果该上下文退出时没有异常，三个参数都将为None。

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

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

3.4.11. 旧式类特殊方法的查找¶

对于旧式类，特殊方法的查找始终与其它方法和属性的查找方式完全相同。无论方法的查找是显式的x.__getitem__(i)还是隐式的x[i]。

该行为意味着特殊的方法对于同一个旧式类的不同实例展现不同的行为，如果特殊的属性设置不同：

>>> class C:
...     pass
...
>>> c1 = C()
>>> c2 = C()
>>> c1.__len__ = lambda: 5
>>> c2.__len__ = lambda: 9
>>> len(c1)
5
>>> len(c2)
9

3.4.12. 新式类特殊的方法查找¶

对于新式类，特殊方法的隐式调用只有它在对象的类型上定义而不是对象实例的字典中定义时才保证正确地工作。该行为是为什么下面的代码引起一个异常的原因（与旧式类的相同例子不同）：

>>> class C(object):
...     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__()被所有的对象包括类型对象实现。如果这些方法的隐式查找使用传统的查找过程，它们将在调用类型对象自己时失败：

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

脚注