3.3.1。基本定制

object.__new__（cls [，… ] ）

被调用以创建类cls的新实例。 __new__()是一个静态方法（特殊的，因此您不需要声明它），它将请求实例的类作为其第一个参数。其余参数是传递给对象构造函数表达式的参数（对类的调用）。返回值__new__()应该是新的对象实例（通常是cls的实例）。

典型的实现通过__new__()使用 适当的参数调用超类的方法然后在返回之前根据需要修改新创建的实例来创建类的新实例。super().__new__(cls[, ...])

如果__new__()返回cls的实例，那么__init__()将调用新实例的 方法，其中 self是新实例，其余参数与传递给它的相同。__init__(self[, ...])__new__()

如果__new__()不返回cls的实例，则__init__()不会调用新实例的 方法。

__new__()主要用于允许不可变类型的子类（如int，str或tuple）自定义实例创建。它也通常在自定义元类中重写，以自定义类创建。

object.__init__（自[，… ] ）

在创建实例（by __new__()）之后调用，但在将其返回给调用者之前调用。参数是传递给类构造函数表达式的参数。如果基类有一个__init__() 方法，派生类的__init__()方法（如果有的话）必须显式调用它以确保实例的基类部分的正确初始化; 例如：super().__init__([args...])。

因为__new__()并且__init__()在构造对象（__new__()创建对象和__init__()自定义对象）时一起工作，所以不会None返回任何非值__init__(); 这样做会导致TypeError在运行时引发。

object.__del__（自我）

当实例即将被销毁时调用。这也称为终结器或（不正确地）析构函数。如果基类具有 __del__()方法，则派生类的__del__()方法（如果有）必须显式调用它以确保正确删除实例的基类部分。

有可能（尽管不推荐！）__del__()方法通过创建对它的新引用来推迟实例的销毁。这称为物体复活。它是依赖于实现的，无论__del__()是在复活的对象即将被摧毁时第二次被调用; 当前的CPython实现只调用一次。

无法保证__del__()在解释器退出时仍然存在的对象调用方法。

注意

del x不直接调用x.__del__()– 前者将引用计数减x1，后者仅在x引用计数达到零时调用 。

CPython实现细节：参考周期可以防止对象的引用计数变为零。在这种情况下，循环垃圾收集器稍后将检测并删除该循环。引用周期的常见原因是在局部变量中捕获到异常。然后框架的本地引用异常，该异常引用自己的回溯，该回溯引用回溯中捕获的所有帧的本地。

也可以看看

该gc模块的文档。

警告

由于__del__()调用方法的不稳定环境，将忽略执行期间发生的异常，并打印警告sys.stderr。特别是：

• __del__()可以在执行任意代码时调用，包括来自任意线程。如果__del__()需要锁定或调用任何其他阻塞资源，它可能会死锁，因为资源可能已被执行中断的代码占用__del__()。
• __del__()可以在解释器关闭期间执行。因此，它需要访问的全局变量（包括其他模块）可能已被删除或设置为None。Python保证在删除其他全局变量之前，从其模块中删除名称以单个下划线开头的全局变量; 如果不存在对此类全局变量的其他引用，这可能有助于确保在__del__()调用方法时导入的模块仍然可用 。

 

object.__repr__（自我）

由repr()内置函数调用以计算对象的“官方”字符串表示。如果可能的话，这应该看起来像一个有效的Python表达式，可用于重新创建具有相同值的对象（给定适当的环境）。如果无法做到这一点，则应返回表单的字符串。返回值必须是字符串对象。如果类定义 但未定义，则在需要该类的实例的“非正式”字符串表示时也使用。<...some useful description...>__repr__()__str__()__repr__()

这通常用于调试，因此表示信息丰富且明确是很重要的。

 

object.__str__（自我）

由str(object)内置函数调用 format()并print()计算对象的“非正式”或可打印的字符串表示形式。返回值必须是 字符串对象。

此方法的不同之处在于object.__repr__()不期望__str__()返回有效的Python表达式：可以使用更方便或简洁的表示。

内置类型object 调用定义的默认实现object.__repr__()。

object.__bytes__（自我）

由字节调用以计算对象的字节串表示。这应该返回一个bytes对象。

 

object.__format__（self，format_spec ）

由format()内置函数调用，并通过扩展，评估格式化的字符串文字和str.format()方法，以生成对象的“格式化”字符串表示。的format_spec参数是包含所期望的格式选项的描述的字符串。对format_spec参数的解释取决于实现的类型__format__()，但是大多数类将格式化为一种内置类型，或者使用类似的格式化选项语法。

有关标准格式语法的说明，请参阅格式规范迷你语言。

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

在版本3.4中更改： __format__方法object本身会引发一个TypeError if传递的任何非空字符串。

在版本3.7中更改：现在相当于而不是。object.__format__(x, '')str(x)format(str(self), '')

object.__lt__（自我，其他）

object.__le__（自我，其他）

object.__eq__（自我，其他）

object.__ne__（自我，其他）

object.__gt__（自我，其他）

object.__ge__（自我，其他）

这些是所谓的“丰富比较”方法。运算符符号和方法名称之间的对应关系如下：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()该值以确定结果是true还是false。

默认情况下，除非是结果，否则__ne__()委托__eq__()并反转结果NotImplemented。比较运算符之间没有其他隐含的关系，例如，事实并非暗示。要从单个根操作自动生成排序操作，请参阅。(x<y orx==y)x<=yfunctools.total_ordering()

有关__hash__()创建支持自定义比较操作的可哈希对象的一些重要说明，请参阅段落，并可用作字典键。

这些方法没有交换参数版本（当左参数不支持操作但右参数支持时使用）; 相反，__lt__()和__gt__()彼此的思考， __le__()并__ge__()在对方的反映， __eq__()并__ne__()有自己的思考。如果操作数的类型不同，并且右操作数的类型是左操作数类型的直接或间接子类，则右操作数的反射方法具有优先级，否则左操作数的方法具有优先级。不考虑虚拟子类化。

object.__hash__（自我）

通过内置的函数调用hash()和杂乱的集合的成员包括运营set，frozenset和 dict。 __hash__()应该返回一个整数。唯一需要的属性是比较相等的对象具有相同的哈希值; 建议将对象组件的哈希值混合在一起，这些哈希值也通过将对象打包成元组并对元组进行散列来对比对象。例：

def __hash__(self):
    return hash((self.name, self.nick, self.color))

注意

hash()将从对象的自定义__hash__()方法返回的值截断 为a的大小Py_ssize_t。这通常是64位版本上的8个字节和32位版本上的4个字节。如果对象 __hash__()必须在不同位大小的构建上进行互操作，请务必检查所有受支持构建的宽度。一个简单的方法就是这样做 。python -c "import sys;print(sys.hash_info.width)"

如果一个类没有定义一个__eq__()方法，它也不应该定义一个 __hash__()操作; 如果定义__eq__()但不 定义__hash__()，则其实例将不能用作可散列集合中的项目。如果一个类定义了可变对象并实现了一个 __eq__()方法，那么它就不应该实现__hash__()，因为hashable集合的实现要求一个键的哈希值是不可变的（如果对象的哈希值改变，它将在错误的哈希桶中）。

用户定义的类默认具有__eq__()和__hash__()方法; 与它们相比，所有对象都比较不相等（除了它们自己）并x.__hash__()返回一个适当的值，这 意味着它和。x == yx is yhash(x) == hash(y)

覆盖__eq__()和未定义的类__hash__() 将__hash__()隐式设置为None。当__hash__()类的 方法是None，类的实例将TypeError在程序尝试检索其哈希值时引发适当的，并且在检查时也将被正确地识别为不可用。isinstance(obj, collections.abc.Hashable)

如果覆盖的类__eq__()需要保留__hash__()父类的实现，则必须通过设置明确告知解释器。__hash__ =<ParentClass>.__hash__

如果一个不重写的类__eq__()希望禁止哈希支持，它应该包含在类定义中。定义自己明确引发a的类将被错误地识别为可通过调用进行清除。__hash__ = None__hash__()TypeErrorisinstance(obj,collections.abc.Hashable)

注意

默认情况下，__hash__()str，bytes和datetime对象的值使用不可预测的随机值“加盐”。虽然它们在单个Python进程中保持不变，但是在重复调用Python之间它们是不可预测的。

这旨在提供针对由精心选择的输入引起的拒绝服务的保护，该输入利用dict插入的最坏情况性能，O（n ^ 2）复杂度。有关详细信息，请参见 http://www.ocert.org/advisories/ocert-2011-003.html。

更改哈希值会影响集的迭代顺序。Python从未对此排序做出保证（通常在32位和64位版本之间有所不同）。

也可以看看 PYTHONHASHSEED。

在版本3.3中更改：默认情况下启用哈希随机化。

object.__bool__（自我）

被称为实施真值测试和内置操作 bool(); 应该返回False或True。如果未定义此方法，__len__()则调用此方法（如果已定义），如果其结果为非零，则将该对象视为true。如果一个类既未定义也 __len__()未定义__bool__()，则其所有实例都被视为真。

3.3.2。自定义属性访问

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

object.__getattr__（自我，名字）

当默认的属性访问失败，并调用AttributeError （或者__getattribute__()引发AttributeError，因为 名字是不是一个实例的属性或分类的属性self;或__get__()的名称属性提升 AttributeError）。此方法应返回（计算）属性值或引发AttributeError异常。

请注意，如果通过常规机制找到属性，__getattr__()则不会调用该属性 。（这是__getattr__()和之间的故意不对称 __setattr__()。）这是出于效率原因而做的，因为否则__getattr__()将无法访问实例的其他属性。请注意，至少对于实例变量，您可以通过不在实例属性字典中插入任何值来伪造总控制（而是将它们插入另一个对象中）。请参阅__getattribute__()下面的方法，了解实际获得对属性访问的完全控制的 方法。

object.__getattribute__（自我，名字）

无条件调用以实现类的实例的属性访问。如果类也定义__getattr__()，除非__getattribute__()明确调用它或引发一个，否则不会调用 后者AttributeError。此方法应返回（计算）属性值或引发AttributeError异常。为了避免此方法中的无限递归，其实现应始终调用具有相同名称的基类方法来访问其所需的任何属性，例如，。object.__getattribute__(self, name)

注意

当通过语言语法或内置函数进行隐式调用查找特殊方法时，仍然可以绕过此方法。请参阅特殊方法查找。

object.__setattr__（自我，名字，价值）

在尝试进行属性分配时调用。这被称为而不是正常机制（即将值存储在实例字典中）。 name是属性名称，value是要分配给它的值。

如果__setattr__()要分配给实例属性，则应调用具有相同名称的基类方法，例如 。object.__setattr__(self, name, value)

object.__delattr__（自我，名字）

喜欢__setattr__()但是对于属性删除而不是赋值。只有对对象有意义时才应该实现。del obj.name

object.__dir__（自我）

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

import sys from types 
import ModuleType 
class VerboseModule(ModuleType): 
   def __repr__(self): 
       return f'Verbose {self.__name__}' 
   def __setattr__(self, attr, value): 
       print(f'Setting {attr}...') 
       super().__setattr__(attr, value) 
sys.modules[__name__].__class__ = VerboseModule

3.3.3。自定义类创建

每当一个类继承自另一个类时，就会在该类上调用__init_subclass__。这样，就可以编写改变子类行为的类。这与类装饰器密切相关，但类装饰器仅影响它们应用的特定类，__init_subclass__仅适用于定义方法的类的未来子类。

classmethod object.__init_subclass__（cls ）

只要包含类是子类，就会调用此方法。 然后cls是新的子类。如果定义为普通实例方法，则此方法将隐式转换为类方法。

给新类的关键字参数传递给父类__init_subclass__。为了与使用的其他类兼容__init_subclass__，应该取出所需的关键字参数并将其他参数传递给基类，如下所示：

class Philosopher: 
    def __init_subclass__(cls, default_name, **kwargs): 
        super().__init_subclass__(**kwargs) 
        cls.default_name = default_name 

class AustralianPhilosopher(Philosopher, default_name="Bruce"): 
    pass

 

默认实现object.__init_subclass__不执行任何操作，但如果使用任何参数调用它，则会引发错误。

注意

元类提示metaclass由类型机器的其余部分使用，并且永远不会传递给__init_subclass__实现。可以访问实际的元类（而不是显式提示） type(cls)。

版本3.6中的新功能。

class Meta(type): 
    pass 
class MyClass(metaclass=Meta): 
    pass 
class MySubclass(MyClass): 
    pass

3.3.4。自定义实例和子类检查

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

特别是，元类abc.ABCMeta实现了这些方法，以允许将抽象基类（ABC）作为“虚基类”添加到任何类或类型（包括内置类型），包括其他ABC。

class.__instancecheck__（自我，实例）

返回true如果实例应该考虑的（直接或间接）的实例类。如果定义，则调用实现。isinstance(instance,class)

class.__subclasscheck__（自我，子类）

返回true，如果子类应考虑的（直接或间接）子类。如果定义，则调用实现。issubclass(subclass, class)

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

3.3.5。模拟泛型类型

可以实现由…指定的泛型类语法 PEP 484 （例如List[int]）通过定义一种特殊方法

classmethod object.__class_getitem__（cls，key ）

通过key中的类型参数返回表示泛型类特化的对象。

这个方法是在类对象本身上查找的，当在类体中定义时，该方法隐式地是一个类方法。注意，此机制主要用于静态类型提示，不鼓励使用其他用法。

3.3.6。模拟可调用对象

object.__call__（self [，args … ] ）

当实例被“调用”为函数时调用; 如果定义了这个方法， 则是一个简写。x(arg1, arg2, ...)x.__call__(arg1,arg2, ...)

3.3.7。模拟容器类型

可以定义以下方法来实现容器对象。容器通常是序列（例如列表或元组）或映射（如字典），但也可以表示其他容器。第一组方法用于模拟序列或模拟映射; 不同之处在于，对于序列，允许键应该是整数k，其中N是序列的长度，或切片对象，它们定义了一系列项。它也建议映射提供方法 ，，，，， ，，，，和 行为类似于对Python的标准字典对象。该0 <= k <Nkeys()values()items()get()clear()setdefault()pop()popitem()copy()update()collections.abc模块提供了一个 MutableMapping 抽象基类，以帮助从一组基本的创建的那些方法 __getitem__()，__setitem__()，__delitem__()，和keys()。可变类型应该提供方法append()，count()， index()，extend()，insert()，pop()，remove()， reverse()和sort()，像Python标准列表对象。最后，序列类型应该实现加成（意味着串联）和乘法（意味着重复）通过定义的方法__add__()， __radd__()，__iadd__()，__mul__()，__rmul__()和__imul__()下面描述的; 他们不应该定义其他数字运算符。建议映射和序列都实现该 __contains__()方法以允许有效使用in运算符; 对于映射，in应该搜索映射的键; 对于序列，它应该搜索值。进一步建议映射和序列实现该__iter__()方法以允许通过容器的有效迭代; 对于映射，__iter__()应该是一样的 keys(); 对于序列，它应该迭代值。

object.__len__（自我）

被称为实现内置功能len()。应该返回对象的长度，整数>=0.此外，在布尔上下文中，未定义 __bool__()方法且其__len__()方法返回零的对象被视为false。

CPython实现细节：在CPython中，长度最多需要sys.maxsize。如果长度大于sys.maxsize某些特征（例如len()）可能会提高OverflowError。为了防止OverflowError通过真值测试提高 ，对象必须定义一个__bool__()方法。

object.__length_hint__（自我）

被叫实施operator.length_hint()。应返回对象的估计长度（可能大于或小于实际长度）。长度必须是整数>=0.此方法纯粹是一种优化，并且永远不需要正确性。

版本3.4中的新功能。

a[1:2] = b

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

object.__getitem__（自我，钥匙）

被要求实施评估self[key]。对于序列类型，接受的键应该是整数和切片对象。请注意，负索引的特殊解释（如果类希望模拟序列类型）取决于__getitem__()方法。如果密钥类型不合适，TypeError可能会引发; 如果某个值超出了序列的索引集（在负值的任何特殊解释之后），则 IndexError应该引发。对于映射类型，如果缺少密钥（不在容器中），则KeyError应该引发。

注意

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

object.__setitem__（自我，钥匙，价值）

被要求实施任务self[key]。同样的注意事项 __getitem__()。如果对象支持对键值的更改，或者是否可以添加新键，或者对于可以替换元素的序列，则只应对映射实现此操作。同样的例外情况应提高不当键作为值__getitem__()的方法。

object.__delitem__（自我，钥匙）

被称为实施删除self[key]。同样的注意事项 __getitem__()。如果对象支持删除键，则应仅对映射实现此操作，或者如果可以从序列中删除元素，则仅对序列实现此操作。同样的例外情况应提高不当键 作为值__getitem__()的方法。

object.__missing__（自我，钥匙）

叫做dict。当key不在字典中时__getitem__()实现self[key]dict子类。

object.__iter__（自我）

当容器需要迭代器时，将调用此方法。此方法应返回一个新的迭代器对象，该对象可以迭代容器中的所有对象。对于映射，它应该迭代容器的键。

Iterator对象也需要实现此方法; 他们被要求归还自己。有关迭代器对象的更多信息，请参阅迭代器类型。

object.__reversed__（自我）

由reversed()内置调用（如果存在）以实现反向迭代。它应该返回一个新的迭代器对象，它以相反的顺序迭代容器中的所有对象。

如果__reversed__()未提供该方法，则reversed() 内置将回退到使用序列协议（__len__()和__getitem__()）。支持序列协议的对象应仅提供__reversed__()它们是否可以提供比提供的更有效的实现reversed()。

成员资格测试运算符（in和）通常实现为序列的迭代。但是，容器对象可以使用更高效的实现提供以下特殊方法，这也不要求对象是序列。not in

object.__contains__（自我，项目）

被称为实施会员测试运营商。如果item 在self中，则返回true ，否则返回false。对于映射对象，这应该考虑映射的键而不是值或键 – 项对。

对于未定义的对象，__contains__()成员资格测试首先尝试迭代__iter__()，然后是旧的序列迭代协议__getitem__()，请参阅语言参考中的此部分。

3.3.8。模拟数字类型

可以定义以下方法来模拟数字对象。对应于所实现的特定种类数量不支持的操作的方法（例如，非整数的按位操作）应保持未定义。

object.__add__（自我，其他）

object.__sub__（自我，其他）

object.__mul__（自我，其他）

object.__matmul__（自我，其他）

object.__truediv__（自我，其他）

object.__floordiv__（自我，其他）

object.__mod__（自我，其他）

object.__divmod__（自我，其他）

object.__pow__（self，other [，modulo ] ）

object.__lshift__（自我，其他）

object.__rshift__（自我，其他）

object.__and__（自我，其他）

object.__xor__（自我，其他）

object.__or__（自我，其他）

这些方法称为执行二进制算术运算（+，-，*，@，/，//，%，divmod()， pow()，**，<<，>>，&，^，|）。例如，要计算表达式，其中x是具有方法的类的实例，则调用该表达式。该 方法应相当于使用 和; 它不应该与之相关 。请注意，如果 要支持内置函数的三元版本，则应定义为接受可选的第三个参数。x +y__add__()x.__add__(y)__divmod__()__floordiv__()__mod__()__truediv__()__pow__()pow()

如果其中一个方法不支持使用提供的参数进行操作，则应返回NotImplemented。

object.__radd__（自我，其他）

object.__rsub__（自我，其他）

object.__rmul__（自我，其他）

object.__rmatmul__（自我，其他）

object.__rtruediv__（自我，其他）

object.__rfloordiv__（自我，其他）

object.__rmod__（自我，其他）

object.__rdivmod__（自我，其他）

object.__rpow__（自我，其他）

object.__rlshift__（自我，其他）

object.__rrshift__（自我，其他）

object.__rand__（自我，其他）

object.__rxor__（自我，其他）

object.__ror__（自我，其他）

这些方法称为执行二进制算术运算（+，-，*，@，/，//，%，divmod()， pow()，**，<<，>>，&，^，|以反映（换）操作数）。仅当左操作数不支持相应的操作[3]并且操作数具有不同类型时，才调用这些函数。[4]例如，要计算表达式，其中y是具有方法的类的实例， 如果返回NotImplemented，则调用该表达式。x -y__rsub__()y.__rsub__(x)x.__sub__(y)

请注意，三元pow()不会尝试调用__rpow__()（强制规则会变得太复杂）。

注意

如果右操作数的类型是左操作数类型的子类，并且该子类提供了操作的反射方法，则此方法将在左操作数的非反射方法之前调用。此行为允许子类覆盖其祖先的操作。

object.__iadd__（自我，其他）

object.__isub__（自我，其他）

object.__imul__（自我，其他）

object.__imatmul__（自我，其他）

object.__itruediv__（自我，其他）

object.__ifloordiv__（自我，其他）

object.__imod__（自我，其他）

object.__ipow__（self，other [，modulo ] ）

object.__ilshift__（自我，其他）

object.__irshift__（自我，其他）

object.__iand__（自我，其他）

object.__ixor__（自我，其他）

object.__ior__（自我，其他）

这些方法称为实现增强的算术作业（+=，-=，*=，@=，/=，//=，%=，**=，<<=， >>=，&=，^=，|=）。这些方法应该尝试就地执行操作（修改self）并返回结果（可能是，但不一定是self）。如果未定义特定方法，则扩充分配将回退到常规方法。例如，如果x 是带有__iadd__()方法的类的实例，则等效于。否则，并 考虑与评估一样x += yx = x.__iadd__(y)x.__add__(y)y.__radd__(x)x + y。在某些情况下，增强赋值可能会导致意外错误（请参阅 为什么a_tuple [i] + = [‘item’]在添加时会引发异常？），但这种行为实际上是数据模型的一部分。

object.__neg__（自我）

object.__pos__（自我）

object.__abs__（自我）

object.__invert__（自我）

调用来实现一元算术运算（-，+，abs() 和~）。

object.__complex__（自我）

object.__int__（自我）

object.__float__（自我）

被称为实现内置函数complex()， int()和float()。应该返回适​​当类型的值。

object.__index__（自我）

称为实施operator.index()，并且无论何时需要的Python于数字对象无损转换为整数对象（如在切片，或在内置的bin()，hex()和oct() 函数）。此方法的存在表明数字对象是整数类型。必须返回一个整数。

注意

为了得到一个连贯的整数类型类，__index__()定义的时候也__int__()应该被定义，并且两者都应该返回相同的值。

object.__round__（自[，ndigits ] ）

object.__trunc__（自我）

object.__floor__（自我）

object.__ceil__（自我）

被称为实现内置功能round()和math 功能trunc()，floor()以及ceil()。除非将ndigits传递给__round__()所有这些方法，否则应将截断的对象的值返回到Integral （通常为a int）。

如果__int__()未定义，则内置函数将int() 回退__trunc__()。

3.3.9。使用语句上下文管理器

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

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

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

object.__enter__（自我）

输入与此对象相关的运行时上下文。该with语句将此方法的返回值绑定到as语句子句中指定的目标（ 如果有）。

object.__exit__（self，exc_type，exc_value，traceback ）

退出与此对象相关的运行时上下文。参数描述导致退出上下文的异常。如果上下文没有异常退出，那么所有三个参数都将是None。

如果提供了异常，并且该方法希望抑制异常（即，防止它被传播），则它应该返回一个真值。否则，在退出此方法时将正常处理异常。

请注意，__exit__()方法不应该重新加入传入的异常; 这是来电者的责任。

3.3.10。特殊方法查找

对于自定义类，只有在对象的类型上定义，而不是在对象的实例字典中，才能保证特殊方法的隐式调用正常工作。这种行为是以下代码引发异常的原因：

>>>
>>> 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__()被所有对象，包括类型对象实现。如果这些方法的隐式查找使用传统的查找过程，则在类型对象本身上调用它们时会失败：

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

__getattribute__()以这种方式绕过机器为解释器内的速度优化提供了很大的空间，代价是处理特殊方法的一些灵活性（必须在类对象本身上设置特殊方法以便由解释器一致地调用） 。

3.4.1。等待对象

一个awaitable对象一般实现的__await__()方法。 从函数返回的协程对象是等待的。async def

object.__await__（自我）

必须返回迭代器。应该用来实现 等待对象。例如，asyncio.Future实现此方法以与await表达式兼容。

3.4.2。协程对象

协程对象是等待的对象。可以通过调用__await__()和迭代结果来控制协程的执行。当协程完成执行并返回时，迭代器引发StopIteration，异常的 value属性保存返回值。如果协同程序引发异常，它将由迭代器传播。协同程序不应直接引发未处理的StopIteration异常。

协程也有下面列出的方法，类似于生成器的方法（参见Generator-iterator方法）。但是，与生成器不同，协同程序不直接支持迭代。

coroutine.send（值）

开始或恢复协程的执行。如果value为None，则相当于推进返回的迭代器 __await__()。如果value不是None，则此方法委托给send()导致协程挂起的迭代器的方法。结果（返回值， StopIteration或其他异常）与迭代__await__()返回值时的结果相同，如上所述。

coroutine.throw（类型[，值[，追溯] ] ）

在协程中引发指定的异常。throw()如果它有这样的方法，则此方法委托给迭代器的方法，该方法导致协程挂起。否则，在暂停点处引发异常。结果（返回值，StopIteration或其他异常）与迭代__await__()返回值时的结果相同，如上所述。如果协程中没有捕获异常，它会传播回调用方。

coroutine.close（）

使协程自行清理并退出。如果协程被挂起，这个方法首先委托close() 迭代器的方法，如果它有这样的方法，会导致协程挂起。然后它GeneratorExit在悬挂点上升，导致协程立即自我清理。最后，协程标记为已完成执行，即使它从未启动过。

当它们即将被销毁时，使用上述过程自动关闭协同程序对象。

3.4.3。异步迭代器

一个异步迭代器可以在它的调用异步代码__anext__的方法。

异步迭代器可以在语句中使用。async for

object.__aiter__（自我）

必须返回异步迭代器对象。

object.__anext__（自我）

必须返回等待，导致迭代器的下一个值。StopAsyncIteration迭代结束时应该引发错误。

异步可迭代对象的示例：

class Reader: 
    async def readline(self):
        ... 
    def __aiter__(self): 
        return self 
    async def __anext__(self): 
        val = await self.readline() 
        if val == b'': 
            raise StopAsyncIteration 
        return val

3.4.4。异步上下文管理器

一个异步上下文管理器是一个上下文管理器，它能够暂停其执行__aenter__和__aexit__方法。

可以在语句中使用异步上下文管理器。async with

object.__aenter__（自我）

这种方法在语义上类似于__enter__()，只有区别在于它必须返回等待。

object.__aexit__（self，exc_type，exc_value，traceback ）

这种方法在语义上类似于__exit__()，只有区别在于它必须返回等待。

异步上下文管理器类的示例：

class AsyncContextManager: 
    async def __aenter__(self): 
        await log('entering context') 
    async def __aexit__(self, exc_type, exc, tb): 
        await log('exiting context')

脚注