3.2.1.None¶

此类型只有一种取值。是一个具有此值的单独对象。此对象通过内置名称None 访问。在许多情况下它被用来表示空值，例如未显式指明返回值的函数将返回 None。它的逻辑值为假。

3.2.2.NotImplemented¶

此类型只有一种取值。 是一个具有该值的单独对象。 此对象通过内置名称NotImplemented 访问。 数值方法和丰富比较方法如未实现指定运算符表示的运算则应返回该值。 （解释器会根据具体运算符继续尝试反向运算或其他回退操作。） 它不应被解读为布尔值。

详情参见实现算术运算。

3.2.3.Ellipsis¶

此类型只有一种取值。是一个具有此值的单独对象。此对象通过字面值... 或内置名称Ellipsis 访问。它的逻辑值为真。

3.2.4.numbers.Number¶

此类对象由数字字面值创建，并会被作为算术运算符和算术内置函数的返回结果。数字对象是不可变的；一旦创建其值就不再改变。Python 中的数字当然非常类似数学中的数字，但也受限于计算机中的数字表示方法。

数字类的字符串表示形式，由__repr__() 和__str__() 算出，具有以下特征属性:

• 它们是有效的数字字面值，当被传给它们的类构造器时，将会产生具有原数字值的对象。

• 表示形式会在可能的情况下采用 10 进制。

• 开头的零，除小数点前可能存在的单个零之外，将不会被显示。

• 末尾的零，除小数点后可能存在的单个零之外，将不会被显示。

• 正负号仅在当数字为负值时会被显示。

Python 区分整型数、浮点型数和复数：

3.2.5.序列¶

这些代表以非负数为索引的有限有序集合。 内置函数len() 将返回序列的项数。 当序列 的长度为n 时，索引集合将包含数字 0, 1, ...,n-1。a[i] 是选择序列a 中的第i 项。 某些序列，包括内置的序列，可通过加上序列长度来解读负下标值。 例如，a[-2] 等价于a[n-2]，即长度为n 的 a 序列的倒数第二项。

序列还支持切片:a[i:j] 是选择索引为k 使得i<=k<j 的所有条目。 当用作表达式时，切片就是一个相同类型的新序列。 以上有关负索引的注释也适用于切片位置的负值。

有些序列还支持带有第三个 "step" 形参的 "扩展切片":a[i:j:k] 选择a 中索引号为x 的所有条目，x=i+n*k,n>=0 且i<=x<j。

序列可根据其可变性来加以区分:

3.2.6.集合类型¶

此类对象表示由不重复且不可变对象组成的无序且有限的集合。因此它们不能通过下标来索引。但是它们可被迭代，也可用内置函数len() 返回集合中的条目数。集合常见的用处是快速成员检测，去除序列中的重复项，以及进行交、并、差和对称差等数学运算。

对于集合元素所采用的不可变规则与字典的键相同。注意数字类型遵循正常的数字比较规则: 如果两个数字相等 (例如1 和1.0)，则同一集合中只能包含其中一个。

目前有两种内生集合类型:

集合

此类对象表示可变集合。它们可通过内置的set() 构造器创建，并且创建之后可以通过方法进行修改，例如add()。

冻结集合

此类对象表示不可变集合。它们可通过内置的frozenset() 构造器创建。由于 frozenset 对象不可变且hashable，它可以被用作另一个集合的元素或是字典的键。

3.2.7.映射¶

此类对象表示由任意索引集合所索引的对象的集合。通过下标a[k] 可在映射a 中选择索引为k 的条目；这可以在表达式中使用，也可作为赋值或del 语句的目标。内置函数len() 可返回一个映射中的条目数。

目前只有一种内生映射类型:

3.2.8.可调用类型¶

此类型可以被应用于函数调用操作 (参见调用 小节):

3.2.9.模块¶

模块是 Python 代码的基本组织单元，由导入系统 创建，它或是通过import 语句，或是通过调用importlib.import_module() 和内置的__import__() 等函数来唤起。 模块对象具有通过字典 对象实现的命名空间（就是被定义在模块中的函数的__globals__ 属性所引用的字典）。 属性引用将被转换为在该字典中的查找操作，例如m.x 就等价于m.__dict__["x"]。 模块对象不包含用于初始化模块的代码对象（因为初始化完成后已不再需要它）。

属性赋值会更新模块的命名空间字典，例如m.x=1 等同于m.__dict__["x"]=1。

>>>importtyping>>>typing.__name__,typing.__spec__.name('typing', 'typing')>>>typing.__spec__.name='spelling'>>>typing.__name__,typing.__spec__.name('typing', 'spelling')>>>typing.__name__='keyboard_smashing'>>>typing.__name__,typing.__spec__.name('keyboard_smashing', 'spelling')

3.2.10.自定义类¶

自定义类这种类型一般是通过类定义来创建 (参见类定义 一节)。 每个类都有一个通过字典对象实现的命名空间。 类属性引用会被转化为在此字典中查找，例如，C.x 会被转化为C.__dict__["x"] (不过也存在一些钩子对象允许其他定位属性的方式)。 当未在其中找到某个属性名称时，会继续在基类中查找。这种基类搜索使用 C3 方法解析顺序，即使存在 '钻石形' 继承结构既有多条继承路径连到一个共同祖先也能保持正确的行为。 有关 Python 使用的 C3 MRO 的详情可在Python 2.3 方法解析顺序 查看。

当一个类属性引用 (假设类名为C) 会产生一个类方法对象时，它将转化为一个__self__ 属性为C 的实例方法对象。 当它会产生一个staticmethod 对象时，它将转换为该静态方法对象所包装的对象。 有关有类的__dict__ 实际包含内容以外获取属性的其他方式请参阅实现描述器 一节。

类属性赋值会更新类的字典，但不会更新基类的字典。

类对象可被调用 (见上文) 以产生一个类实例 (见下文)。

3.2.11.类实例¶

类实例可通过调用类对象来创建（见上文）。 每个类实例都有通过一个字典对象实现的独立命名空间，属性引用会首先在此字典中进行查找。 当未在其中发现某个属性，而实例对应的类中有该属性时，会继续在类属性中查找。 如果找到的类属性是一个用户自定义函数对象，它会被转化为实例方法对象，其__self__ 属性即该实例。 静态方法和类方法对象也会被转化；参见上文的“类”小节。 要了解其他通过类实例来获取相应类属性的方式请参阅实现描述器 小节，这样得到的属性可能与实际存放在类的__dict__ 中的对象不同。 如果未找到类属性，而对象所属的类具有__getattr__() 方法，则会调用该方法来满足查找要求。

属性赋值和删除会更新实例的字典，但绝不会更新类的字典。 如果类具有__setattr__() 或__delattr__() 方法，则将调用该方法而不再直接更新实例的字典。

如果类实例具有某些特殊名称的方法，就可以伪装为数字、序列或映射。参见特殊方法名称 一节。

3.2.12.I/O 对象 (或称文件对象)¶

file object 表示一个打开的文件。有多种快捷方式可用来创建文件对象:open() 内置函数，以及os.popen(),os.fdopen() 和 socket 对象的makefile() 方法 (还可能使用某些扩展模块所提供的其他函数或方法)。

sys.stdin,sys.stdout 和sys.stderr 会初始化为对应于解释器标准输入、输出和错误流的文件对象；它们都会以文本模式打开，因此都遵循io.TextIOBase 抽象类所定义的接口。

3.2.13.内部类型¶

某些由解释器内部使用的类型也被暴露给用户。它们的定义可能随未来解释器版本的更新而变化，为内容完整起见在此处一并介绍。

3.3.1.基本定制¶

object.__new__(cls[,...])¶

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

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

如果__new__() 在构造对象期间被唤起并且它返回了一个cls 的实例，则新实例的__init__() 方法将以__init__(self[,...]) 的形式被唤起，其中self 为新实例而其余的参数与被传给对象构造器的参数相同。

如果__new__() 未返回一个cls 的实例，则新实例的__init__() 方法就不会被执行。

__new__() 的目的主要是允许不可变类型的子类 (例如 int, str 或 tuple) 定制实例创建过程。它也常会在自定义元类中被重载以便定制类创建过程。

object.__init__(self[,...])¶

在实例 (通过__new__()) 被创建之后，返回调用者之前调用。其参数与传递给类构造器表达式的参数相同。一个基类如果有__init__() 方法，则其所派生的类如果也有__init__() 方法，就必须显式地调用它以确保实例基类部分的正确初始化；例如:super().__init__([args...]).

因为对象是由__new__() 和__init__() 协作构造完成的 (由__new__() 创建，并由__init__() 定制)，所以__init__() 返回的值只能是None，否则会在运行时引发TypeError。

object.__del__(self)¶

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

__del__() 方法可以 (但不推荐!) 通过创建一个该实例的新引用来推迟其销毁。这被称为对象重生。__del__() 是否会在重生的对象将被销毁时再次被调用是由具体实现决定的 ；当前的CPython 实现只会调用一次。

当解释器退出时并不保证会为仍然存在的对象调用__del__() 方法。weakref.finalize 提供了一种直观的方式来注册当对象被作为垃圾回收时要调用的清理函数。

备注

delx 并不直接调用x.__del__() --- 前者会将x 的引用计数减一，而后者仅会在x 的引用计数变为零时被调用。

一个引用循环可以阻止对象的引用计数归零。 在这种情况下，循环将稍后被检测到并被循环垃圾回收器 删除。 导致引用循环的一个常见原因是当一个异常在局部变量中被捕获。 帧的局部变量将会引用该异常，这将引用它自己的回溯信息，它会又引用在回溯中捕获的所有帧的局部变量。

参见

gc 模块的文档。

警告

由于调用__del__() 方法时周边状况已不确定，在其执行期间发生的异常将被忽略，改为打印一个警告到sys.stderr。特别地：

• __del__() 可在任意代码被执行时启用，包括来自任意线程的代码。如果__del__() 需要接受锁或启用其他阻塞资源，可能会发生死锁，例如该资源已被为执行__del__() 而中断的代码所获取。

• __del__() 可以在解释器关闭阶段被执行。因此，它需要访问的全局变量（包含其他模块）可能已被删除或设为None。Python 会保证先删除模块中名称以单个下划线打头的全局变量再删除其他全局变量；如果已不存在其他对此类全局变量的引用，这有助于确保导入的模块在__del__() 方法被调用时仍然可用。

object.__repr__(self)¶

由repr() 内置函数调用以输出一个对象的“官方”字符串表示。如果可能，这应类似一个有效的 Python 表达式，能被用来重建具有相同取值的对象（只要有适当的环境）。如果这不可能，则应返回形式如<...someusefuldescription...> 的字符串。返回值必须是一个字符串对象。如果一个类定义了__repr__() 但未定义__str__()，则在需要该类的实例的“非正式”字符串表示时也会使用__repr__()。

此方法通常被用于调试，因此确保其表示的内容包含丰富信息且无歧义是很重要的。object 类本身提供了一个默认实现。

object.__str__(self)¶

由str(object), 默认的__format__() 实现以及内置函数print() 调用，以生成一个对象的“非正式”或适合打印的字符串表示形式。 返回值必须为一个str 对象。

此方法与object.__repr__() 的不同点在于__str__() 并不预期返回一个有效的 Python 表达式：可以使用更方便或更准确的描述信息。

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

object.__bytes__(self)¶

由bytes 调用以生成一个对象的字节串表示形式。 这应当返回一个bytes 对象。object 类本身不提供此方法。

object.__format__(self,format_spec)¶

通过format() 内置函数、扩展、格式化字符串字面值 的求值以及str.format() 方法调用以生成一个对象的“格式化”字符串表示。format_spec 参数为包含所需格式选项描述的字符串。format_spec 参数的解读是由实现__format__() 的类型决定的，不过大多数类或是将格式化委托给某个内置类型，或是使用相似的格式化选项语法。

请参看格式规格迷你语言 了解标准格式化语法的描述。

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

应当为由object 类提供的默认实现给出一个空的format_spec 字符串。 它将委托给__str__()。

在 3.4 版本发生变更:object 本身的 __format__ 方法如果被传入任何非空字符，将会引发一个TypeError。

在 3.7 版本发生变更:object.__format__(x,'') 现在等同于str(x) 而不再是format(str(x),'')。

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() 以确定结果为真还是假。

在默认情况下，object 通过使用is 来实现__eq__() ，并在比较结果为假值时返回NotImplemented :TrueifxisyelseNotImplemented 。 对于__ne__() ，默认会委托给__eq__() 并对结果取反，除非结果为NotImplemented 。 比较运算符之间没有其他隐含关系或默认实现；例如，(x<yorx==y) 为真并不意味着x<=y 。 要根据单根运算自动生成排序操作，请参看functools.total_ordering() 。

在默认情况下，object 类提供与值比较 一致的实现：相等比较是根据对象标识号，而顺序比较会引发TypeError。 每个默认方法都可能直接生成这样的结果，但也可能返回NotImplemented。

请查看__hash__() 的相关段落，了解创建可支持自定义比较运算并可用作字典键的hashable 对象时要注意的一些事项。

这些方法都没有对调参数版本（在左边参数不支持该操作但右边参数支持时使用）；而是__lt__() 和__gt__() 互为对方的反向，__le__() 和__ge__() 互为对方的反射，而__eq__() 和__ne__() 则是它们自己的反射。 如果两个操作数的类型不同，且右操作数的类型是左操作数类型的直接或间接子类，则优先选择右操作数的反射方法，在其他情况下优先选择左操作数的方法。 虚拟子类化不会被考虑。

当没有合适的方法返回任何NotImplemented 以外的值时，== 和!= 运算符将分别回退至is 和isnot。

object.__hash__(self)¶

通过内置函数hash() 调用以对哈希集的成员进行操作，属于哈希集的类型包括set、frozenset 以及dict。__hash__() 应该返回一个整数。对象比较结果相同所需的唯一特征属性是其具有相同的哈希值；建议的做法是把参与比较的对象全部组件的哈希值混在一起，即将它们打包为一个元组并对该元组做哈希运算。例如:

def__hash__(self):returnhash((self.name,self.nick,self.color))

备注

hash() 会从一个对象自定义的__hash__() 方法返回值中截断为Py_ssize_t 的大小。通常对 64 位构建为 8 字节，对 32 位构建为 4 字节。如果一个对象的__hash__() 必须在不同位大小的构建上进行互操作，请确保检查全部所支持构建的宽度。做到这一点的简单方法是使用python-c"importsys;print(sys.hash_info.width)"。

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

用户自定义的类默认带有__eq__() 和__hash__() 方法（继承自object 类）；因为它们的存在，所有对象（自己除外）相互比较必定不相等并且x.__hash__() 将返回一个恰当的值以使得x==y 同时意味着xisy 且hash(x)==hash(y)。

一个类如果重载了__eq__() 且没有定义__hash__() 则会将其__hash__() 隐式地设为None。当一个类的__hash__() 方法为None 时，该类的实例将在一个程序尝试获取其哈希值时正确地引发TypeError，并会在检测isinstance(obj,collections.abc.Hashable) 时被正确地识别为不可哈希对象。

如果一个重载了__eq__() 的类需要保留来自父类的__hash__() 实现，则必须通过设置__hash__=<ParentClass>.__hash__ 来显式地告知解释器。

如果一个没有重载__eq__() 的类需要去掉哈希支持，则应该在类定义中包含__hash__=None。一个自定义了__hash__() 以显式地引发TypeError 的类会被isinstance(obj,collections.abc.Hashable) 调用错误地识别为可哈希对象。

备注

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

这是为了防止通过精心选择输入来利用字典插入操作在最坏情况下的执行效率即O(n²) 复杂度制度的拒绝服务攻击。 请参阅http://ocert.org/advisories/ocert-2011-003.html 了解详情。

改变哈希值会影响集合的迭代次序。Python 也从不保证这个次序不会被改变（通常它在 32 位和 64 位构建上是不一致的）。

另见PYTHONHASHSEED.

在 3.3 版本发生变更:默认启用哈希随机化。

object.__bool__(self)¶

调用此方法以实现真值检测以及内置的bool() 操作；应当返回False 或True。 当未定义此方法时，则会在定义了__len__() 的情况下调用它，如果其结果不为零则该对象将被视为具有真值。 如果一个类的__len__() 和__bool__() 均未定义（这也是object 类本身的情况），则其所有实例都将被视为具有真值。

3.3.2.自定义属性访问¶

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

object.__getattr__(self,name)¶

当默认属性访问因引发AttributeError 而失败时被调用 (可能是调用__getattribute__() 时由于name 不是一个实例属性或self 的类层级树中的属性而引发了AttributeError；或者是由于name 特征属性的__get__() 引发了AttributeError)。 此方法应当返回（找到的）属性值或是引发一个AttributeError 异常。object 类本身没有提供此方法。

请注意如果属性是通过正常机制找到的，则__getattr__() 不会被调用。 （这是在__getattr__() 和__setattr__() 之间故意设置的不对称性。） 这既是出于执行效率理由也是因为不这样做的话__getattr__() 将无法访问实例的其他属性。 要注意至少对于实例变量来说，你不必在实例属性字典中插入任何值（而是通过插入到其他对象）就可以实现对它的完全控制。 请参阅下面的__getattribute__() 方法了解真正获取对属性访问的完全控制权的办法。

object.__getattribute__(self,name)¶

此方法会无条件地被调用以实现对类实例属性的访问。如果类还定义了__getattr__()，则后者不会被调用，除非__getattribute__() 显式地调用它或是引发了AttributeError。此方法应当返回（找到的）属性值或是引发一个AttributeError 异常。为了避免此方法中的无限递归，其实现应该总是调用具有相同名称的基类方法来访问它所需要的任何属性，例如object.__getattribute__(self,name)。

备注

此方法在作为通过特定语法或内置函数 隐式地调用的结果的情况下查找特殊方法时仍可能会被跳过。 参见特殊方法查找。

对于特定的敏感属性访问，引发一个审计事件object.__getattr__，附带参数obj 和name。

object.__setattr__(self,name,value)¶

此方法在一个属性被尝试赋值时被调用。这个调用会取代正常机制（即将值保存到实例字典）。name 为属性名称，value 为要赋给属性的值。

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

对特定敏感属性的赋值，会引发一个审计事件object.__setattr__，附带参数obj,name,value。

object.__delattr__(self,name)¶

类似于__setattr__() 但其作用为删除而非赋值。此方法应该仅在delobj.name 对于该对象有意义时才被实现。

对于特定的敏感属性删除，引发一个审计事件object.__delattr__，附带参数obj 和name。

object.__dir__(self)¶

此方法会在针对相应对象调用dir() 时被调用。 返回值必须为一个可迭代对象。dir() 会把返回的可迭代对象转换为列表并对其排序。

importsysfromtypesimportModuleTypeclassVerboseModule(ModuleType):def__repr__(self):returnf'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__ 则只作用于定义了该方法的类在未来的子类。

classmethodobject.__init_subclass__(cls)¶

当所在类派生子类时此方法就会被调用。cls 将指向新的子类。如果定义为一个普通实例方法，此方法将被隐式地转换为类方法。

传给一个新类的关键字参数会被传给上级类的__init_subclass__。 为了与其他使用__init_subclass__ 的类兼容，应当去掉需要的关键字参数再将其他参数传给基类，例如:

classPhilosopher:def__init_subclass__(cls,/,default_name,**kwargs):super().__init_subclass__(**kwargs)cls.default_name=default_nameclassAustralianPhilosopher(Philosopher,default_name="Bruce"):pass

object.__init_subclass__ 的默认实现什么都不做，只在带任意参数调用时引发一个错误。

备注

元类提示metaclass 将被其它类型机制消耗掉，并不会被传给__init_subclass__ 的实现。实际的元类（而非显式的提示）可通过type(cls) 访问。

Added in version 3.6.

当一个类被创建时，type.__new__() 会扫描类变量并对其中带有__set_name__() 钩子的对象执行回调。

object.__set_name__(self,owner,name)¶

在所有者类owner 被创建时自动调用。 此对象已被赋值给该类中的name:

classA:x=C()# 自动调用: x.__set_name__(A, 'x')

如果类变量赋值是在类被创建之后进行的，__set_name__() 将不会被自动调用。 如有必要，可以直接调用__set_name__():

classA:passc=C()A.x=c# 钩子未被调用c.__set_name__(A,'x')# 手动唤起钩子

详情参见创建类对象。

Added in version 3.6.

classMeta(type):passclassMyClass(metaclass=Meta):passclassMySubclass(MyClass):pass

3.3.4.自定义实例及子类检查¶

以下方法被用来重载isinstance() 和issubclass() 内置函数的默认行为。

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

type.__instancecheck__(self,instance)¶

如果instance 应被视为class 的一个（直接或间接）实例则返回真值。如果定义了此方法，则会被调用以实现isinstance(instance,class)。

type.__subclasscheck__(self,subclass)¶

Return true 如果subclass 应被视为class 的一个（直接或间接）子类则返回真值。如果定义了此方法，则会被调用以实现issubclass(subclass,class)。

请注意这些方法的查找是基于类的类型（元类）。它们不能作为类方法在实际的类中被定义。这与基于实例被调用的特殊方法的查找是一致的，只有在此情况下实例本身被当作是类。

3.3.5.模拟泛型类型¶

当使用类型标注 时，使用 Python 的方括号标记来形参化 一个generic type 往往会很有用处。 例如，list[int] 这样的标注可以被用来表示一个list 中的所有元素均为int 类型。

一个类通常 只有在定义了特殊的类方法__class_getitem__() 时才能被形参化。

classmethodobject.__class_getitem__(cls,key)¶

按照key 参数指定的类型返回一个表示泛型类的专门化对象。

当在类上定义时，__class_getitem__() 会自动成为类方法。 因此，当它被定义时没有必要使用@classmethod 来装饰。

frominspectimportisclassdefsubscribe(obj,x):"""返回表达式 'obj[x]' 的结果"""class_of_obj=type(obj)# 如果 obj 所属的类定义了 __getitem__，# 则调用 class_of_obj.__getitem__(obj, x)ifhasattr(class_of_obj,'__getitem__'):returnclass_of_obj.__getitem__(obj,x)# 否则，如果 obj 是一个类并且定义了 __class_getitem__，# 则调用 obj.__class_getitem__(x)elifisclass(obj)andhasattr(obj,'__class_getitem__'):returnobj.__class_getitem__(x)# 否则，引发一个异常else:raiseTypeError(f"'{class_of_obj.__name__}' object is not subscriptable")

>>># list 以 "type" 类作为其元类，与大多数类一样：>>>type(list)<class 'type'>>>>type(dict)==type(list)==type(tuple)==type(str)==type(bytes)True>>># "list[int]" 将调用 "list.__class_getitem__(int)">>>list[int]list[int]>>># list.__class_getitem__ 将返回一个 GenericAlias 对象：>>>type(list[int])<class 'types.GenericAlias'>

>>>fromenumimportEnum>>>classMenu(Enum):..."""A breakfast menu"""...SPAM='spam'...BACON='bacon'...>>># 枚举类有一个自定义元类：>>>type(Menu)<class 'enum.EnumMeta'>>>># EnumMeta 定义了 __getitem__，>>># 因此 __class_getitem__ 不会被调用，>>># 并且结果不是一个 GenericAlias 对象：>>>Menu['SPAM']<Menu.SPAM: 'spam'>>>>type(Menu['SPAM'])<enum 'Menu'>

3.3.6.模拟可调用对象¶

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

此方法会在实例作为一个函数被“调用”时被调用；如果定义了此方法，则x(arg1,arg2,...) 大致可以被转写为type(x).__call__(x,arg1,...)。object 类本身没有提供此方法。

3.3.7.模拟容器类型¶

可以定义下列方法来实现容器对象。object 类本身没有提供它们。 容器通常是序列 (如列表 或元组) 或者映射 (如字典)，但也存在其他的容器表示形式。 前面的一组方法被用来模拟序列或模拟映射；两者的区别在于序列所允许的键应为整数k 且0<=k<N 其中N 为整个序列或者定义条目范围的slice 对象的长度。 此外还建议让映射提供keys(),values(),items(),get(),clear(),setdefault(),pop(),popitem(),copy() 以及update() 等方法，它们的行为应与 Python 的标准字典 对象的类似。collections.abc 模块提供了一个MutableMappingabstract base class 以根据由__getitem__(),__setitem__(),__delitem__() 和keys() 组成的基本集来创建这些方法。 可变序列应当提供append(),count(),index(),extend(),insert(),pop(),remove(),reverse() 和sort() 等方法，就像 Python 标准list 对象那样。 最后，序列类型还应当通过定义下文描述的__add__(),__radd__(),__iadd__(),__mul__(),__rmul__() 和__imul__() 等方法来实现加法（即拼接）和乘法（即重复）；它们不应定义其他数值运算符。 此外还建议映射和序列都实现__contains__() 方法以允许高效地使用in 运算符；对于映射，in 应当搜索映射的键；对于序列，则应当搜索其中的值。 另外还建议映射和序列都实现__iter__() 方法以允许高效地迭代容器；对于映射，__iter__() 应当迭代对象的键；对于序列，则应当迭代其中的值。

object.__len__(self)¶

调用此方法以实现内置函数len()。 应该返回对象的长度，以一个>= 0 的整数表示。 此外，如果一个对象未定义__bool__() 方法而其__len__() 方法返回值为零则它在布尔运算中将被视为具有假值。

在 CPython 中，要求长度最大只能为sys.maxsize。 如果长度大于sys.maxsize 则某些特性 (如len()) 可能会引发OverflowError。 要防止真值测试引发OverflowError，对象必须定义__bool__() 方法。

object.__length_hint__(self)¶

调用此方法以实现operator.length_hint()。 应该返回对象长度的估计值（可能大于或小于实际长度）。 此长度应为一个>= 0 的整数。 返回值也可以为NotImplemented ，这会被视作与__length_hint__ 方法完全不存在时一样处理。 此方法纯粹是为了优化性能，并不要求正确无误。

Added in version 3.4.

a[1:2]=b

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

object.__getitem__(self,key)¶

调用此方法以实现self[key] 的求值。 对于sequence 类型，接受的键应为整数。 作为可选项，它们也可能支持slice 对象。 对负数索引的支持也是可选项。 如果key 的类型不正确，则可能引发TypeError。 如果key 为序列索引集合范围以外的值（在进行任何负数索引的特殊解读之后），则应当引发IndexError。 对于mapping 类型，如果key 找不到（不在容器中），则应当引发KeyError。

备注

for 循环在有不合法索引时会期待捕获IndexError 以便正确地检测到序列的结束。

备注

当抽取 一个class 时，可能会调用特殊类方法__class_getitem__() 而不是__getitem__()。 请参阅__class_getitem__ 与 __getitem__ 了解详情。

object.__setitem__(self,key,value)¶

调用此方法以实现向self[key] 赋值。注意事项与__getitem__() 相同。为对象实现此方法应该仅限于需要映射允许基于键修改值或添加键，或是序列允许元素被替换时。不正确的key 值所引发的异常应与__getitem__() 方法的情况相同。

object.__delitem__(self,key)¶

调用此方法以实现self[key] 的删除。注意事项与__getitem__() 相同。为对象实现此方法应该权限于需要映射允许移除键，或是序列允许移除元素时。不正确的key 值所引发的异常应与__getitem__() 方法的情况相同。

object.__missing__(self,key)¶

此方法由dict.__getitem__() 在找不到字典中的键时调用以实现 dict 子类的self[key]。

object.__iter__(self)¶

此方法会在需要为一个容器创建iterator 时被调用。 此方法应当返回一个新的迭代器对象，它可以对容器中的所有对象执行迭代。 对于映射，它应当对窗口中的键执行迭代。

object.__reversed__(self)¶

此方法（如果存在）会被reversed() 内置函数调用以实现逆向迭代。它应当返回一个新的以逆序逐个迭代容器内所有对象的迭代器对象。

如果未提供__reversed__() 方法，则reversed() 内置函数将回退到使用序列协议 (__len__() 和__getitem__())。支持序列协议的对象应当仅在能够提供比reversed() 所提供的实现更高效的实现时才提供__reversed__() 方法。

成员检测运算符 (in 和notin) 通常以对容器进行逐个迭代的方式来实现。 不过，容器对象可以提供以下特殊方法并采用更有效率的实现，这样也不要求对象必须为可迭代对象。

object.__contains__(self,item)¶

调用此方法以实现成员检测运算符。如果item 是self 的成员则应返回真，否则返回假。对于映射类型，此检测应基于映射的键而不是值或者键值对。

对于未定义__contains__() 的对象，成员检测将首先尝试通过__iter__() 进行迭代，然后再使用__getitem__() 的旧式序列迭代协议，参看语言参考中的相应部分。

3.3.8.模拟数字类型¶

定义以下方法即可模拟数字类型。特定种类的数字不支持的运算（例如非整数不能进行位运算）所对应的方法应当保持未定义状态。

object.__add__(self,other)¶

object.__sub__(self,other)¶

object.__mul__(self,other)¶

object.__matmul__(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(),**,<<,>>,&,^,|). For instance, toevaluate the expressionx+y, wherex is an instance of a class thathas an__add__() method,type(x).__add__(x,y) is called. The__divmod__() method should be the equivalent to using__floordiv__() and__mod__(); it should not be related to__truediv__(). Note that__pow__() should be defined to acceptan optional third argument if the ternary version of the built-inpow()function is to be supported.

如果这些方法中的某一个不支持与所提供参数进行运算，它应该返回NotImplemented 。

object.__radd__(self,other)¶

object.__rsub__(self,other)¶

object.__rmul__(self,other)¶

object.__rmatmul__(self,other)¶

object.__rtruediv__(self,other)¶

object.__rfloordiv__(self,other)¶

object.__rmod__(self,other)¶

object.__rdivmod__(self,other)¶

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

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. These functions are only called if the left operand doesnot support the corresponding operation[3] and the operands are of differenttypes.[4] For instance, to evaluate the expressionx-y, wherey isan instance of a class that has an__rsub__() method,type(y).__rsub__(y,x) is called iftype(x).__sub__(x,y) returnsNotImplemented.

Note that ternarypow() will not try calling__rpow__() (thecoercion rules would become too complicated).

备注

如果右操作数类型为左操作数类型的一个子类，且该子类提供了指定运算的反射方法，则此方法将先于左操作数的非反射方法被调用。 此行为可允许子类重载其祖先类的运算符。

object.__iadd__(self,other)¶

object.__isub__(self,other)¶

object.__imul__(self,other)¶

object.__imatmul__(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 但这并非必须)。 如果某个方法未被定义，或者如果该方法返回NotImplemented，则相应的增强赋值将回退到普通方法。 举例来说，如果x 是一个具有__iadd__() 方法的类的实例，则x+=y 就等价于x=x.__iadd__(y)。 如果__iadd__() 不存在，或者如果x.__iadd__(y) 返回NotImplemented，则将使用x.__add__(y) 和y.__radd__(x)，如同对x+y 求值一样。 在某些情况下，增强赋值可能导致未预期的错误 (参见为什么 a_tuple[i] += ['item'] 会引发异常？)，但此行为实际上是数据模型的一部分。

object.__neg__(self)¶

object.__pos__(self)¶

object.__abs__(self)¶

object.__invert__(self)¶

调用此方法以实现一元算术运算 (-,+,abs() 和~)。

object.__complex__(self)¶

object.__int__(self)¶

object.__float__(self)¶

调用这些方法以实现内置函数complex(),int() 和float()。应当返回一个相应类型的值。

object.__index__(self)¶

调用此方法以实现operator.index() 以及 Python 需要无损地将数字对象转换为整数对象的场合（例如切片或是内置的bin(),hex() 和oct() 函数)。 存在此方法表明数字对象属于整数类型。 必须返回一个整数。

如果未定义__int__(),__float__() 和__complex__() 则相应的内置函数int(),float() 和complex() 将回退为__index__()。

object.__round__(self[,ndigits])¶

object.__trunc__(self)¶

object.__floor__(self)¶

object.__ceil__(self)¶

调用这些方法以实现内置函数round() 以及math 函数trunc(),floor() 和ceil()。 除了将ndigits 传给__round__() 的情况之外这些方法的返回值都应当是原对象截断为Integral (通常为int)。

The built-in functionint() falls back to__trunc__() if neither__int__() nor__index__() is defined.

在 3.11 版本发生变更:The delegation ofint() to__trunc__() is deprecated.

3.3.9.with 语句上下文管理器¶

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

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

有关上下文管理器的更多信息，请参阅上下文管理器类型。object 类本身不提供上下文管理器方法。

object.__enter__(self)¶

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

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

退出关联到此对象的运行时上下文。 各个参数描述了导致上下文退出的异常。 如果上下文是无异常地退出的，三个参数都将为None。

如果提供了异常，并且希望方法屏蔽此异常（即避免其被传播），则应当返回真值。 否则的话，异常将在退出此方法时按正常流程处理。

请注意__exit__() 方法不应该重新引发被传入的异常，这是调用者的责任。

3.3.10.定制类模式匹配中的位置参数¶

当在模式中使用类名称时，默认不允许模式中出现位置参数，例如在MyClass 没有特别支持的情况下caseMyClass(x,y) 通常是无效的。 要能使用这样的模式，类必须定义一个__match_args__ 属性。

object.__match_args__¶

该类变量可以被赋值为一个字符串元组。 当该类被用于带位置参数的类模式时，每个位置参数都将被转换为关键字参数，并使用__match_args__ 中的对应值作为关键字。 缺失此属性就等价于将其设为()。

举例来说，如果MyClass.__match_args__ 为("left","center","right") 则意味着caseMyClass(x,y) 就等价于caseMyClass(left=x,center=y)。 请注意模式中参数的数量必须小于等于__match_args__ 中元素的数量；如果前者大于后者，则尝试模式匹配时将引发TypeError。

3.3.11.模拟缓冲区类型¶

缓冲区协议 为 Python 对象提供了一种向低层级内存数组暴露高效访问的方式。 该协议是通过内置类型如bytes 和memoryview 实现的，还可能由第三方库定义额外的缓冲区类型。

虽然缓冲区类型通常都是用 C 实现的，但用 Python 来实现该协议也是可能的。

object.__buffer__(self,flags)¶

当从self 请求一个缓冲区时将被调用（例如，从memoryview 构造器）。flags 参数是代表所请求缓冲区的类别的整数，例如这会影响返回的缓冲区是只读还是可写。inspect.BufferFlags 提供了解读旗标的便利方式。 此方法必须返回一个memoryview 对象。

object.__release_buffer__(self,buffer)¶

当一个缓冲区不再需要时将被调用。buffer 参数是在此之前由__buffer__() 返回的memoryview 对象。 此方法必须释放任何关联到该缓冲区的资源。 此方法应当返回None。 不需要执行任何清理的缓冲区对象不要求实现此方法。

3.3.12.特殊方法查找¶

对于自定义类来说，特殊方法的隐式唤起仅保证在其定义于对象类型中时能正确地发挥作用，而不能定义在对象实例字典中。 该行为就是以下代码会引发异常的原因。:

>>>classC:...pass...>>>c=C()>>>c.__len__=lambda:5>>>len(c)Traceback (most recent call last):  File"<stdin>", line1, 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>", line1, 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__() 方法，甚至包括对象的元类:

>>>classMeta(type):...def__getattribute__(*args):...print("Metaclass getattribute invoked")...returntype.__getattribute__(*args)...>>>classC(object,metaclass=Meta):...def__len__(self):...return10...def__getattribute__(*args):...print("Class getattribute invoked")...returnobject.__getattribute__(*args)...>>>c=C()>>>c.__len__()# 通过实例的显式查找Class getattribute invoked10>>>type(c).__len__(c)# 通过类型的显式查找Metaclass getattribute invoked10>>>len(c)# 隐式查找10

以这种方式绕过__getattribute__() 机制为解释器内部的速度优化提供了显著的空间，其代价则是牺牲了一些处理特殊方法时的灵活性（特殊方法must 必须设置在类对象自身上以便始终一致地由解释器唤起）。

3.4.1.可等待对象¶

awaitable 对象主要实现了__await__() 方法。 从asyncdef 函数返回的协程对象 即为可等待对象。

object.__await__(self)¶

必须返回一个iterator。 应当被用来实现awaitable 对象。 例如，asyncio.Future 实现了此方法以与await 表达式兼容。object 类本身不是可等待对象因而不提供此方法。

备注

本语言不会对__await__ 所返回的迭代器产生的对象的类型或值施加任何限制，因为这是负责管理awaitable 对象的异步执行框架的具体实现 (如asyncio) 专属特性。

3.4.2.协程对象¶

协程对象 属于awaitable 对象。 协程的执行可以通过调用__await__() 并迭代其结果来控制。 当协程结束执行并返回时，迭代器会引发StopIteration，而该异常的value 属性将存放返回值。 如果协程引发了异常，它会被迭代器传播出去。 协程不应当直接引发未被处理的StopIteration 异常。

协程也具有下面列出的方法，它们类似于生成器的对应方法 (参见生成器-迭代器的方法)。 但是，与生成器不同，协程并不直接支持迭代。

coroutine.send(value)¶

开始或恢复协程的执行。 如果value 为None，这将等价于前往__await__() 所返回的迭代器的下一项。 如果value 不为None，此方法将委托给导致协挂起的迭代器的send() 方法。 其结果（返回值,StopIteration 或是其他异常）将与上述对__await__() 返回值进行迭代的结果相同。

coroutine.throw(value)¶

coroutine.throw(type[,value[,traceback]])

在协程内引发指定的异常。 此方法将委托给导致该协程挂起的迭代器的throw() 方法，如果存在此方法的话。 否则，该异常将在挂起点被引发。 其结果（返回值，StopIteration 或是其他异常）将与上述对__await__() 返回值进行迭代的结果相同。 如果该异常未在协程内被捕获，则将回传给调用方。

在 3.12 版本发生变更:第二个签名 (type[, value[, traceback]]) 已被弃用并可能在未来的 Python 版本中移除。

coroutine.close()¶

此方法会使得协程清理自身并退出。 如果协程被挂起，此方法会先委托给导致协程挂起的迭代器的close() 方法，如果存在该方法。 然后它会在挂起点引发GeneratorExit，使得协程立即清理自身。 最后，协程会被标记为已结束执行，即使它根本未被启动。

当协程对象将要被销毁时，会使用以上处理过程来自动关闭。

3.4.3.异步迭代器¶

异步迭代器 可以在其__anext__ 方法中调用异步代码。

异步迭代器可在asyncfor 语句中使用。

object 类本身不提供这些方法。

object.__aiter__(self)¶

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

object.__anext__(self)¶

必须返回一个可等待对象 输出迭代器的下一结果值。 当迭代结束时应该引发StopAsyncIteration 错误。

异步可迭代对象的一个示例:

classReader:asyncdefreadline(self):...def__aiter__(self):returnselfasyncdef__anext__(self):val=awaitself.readline()ifval==b'':raiseStopAsyncIterationreturnval

3.4.4.异步上下文管理器¶

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

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

object 类本身不提供这些方法。

object.__aenter__(self)¶

在语义上类似于__enter__()，仅有的区别在于它必须返回一个可等待对象。

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

在语义上类似于__exit__()，仅有的区别在于它必须返回一个可等待对象。

异步上下文管理器类的一个示例:

classAsyncContextManager:asyncdef__aenter__(self):awaitlog('entering context')asyncdef__aexit__(self,exc_type,exc,tb):awaitlog('exiting context')

备注

在某些情况下有可能 基于可控的条件改变一个对象的类型。 但这通常不是个好主意，因为如果处理不当会导致一些非常怪异的行为。

__hash__(),__iter__(),__reversed__(),__contains__(),__class_getitem__() 和__fspath__() 方法对此有特殊处理。 其他方法仍然会引发TypeError，但可能会依赖None 是不可调用对象的行为来做到这一点。

这里的“不支持”是指该类无此方法，或方法返回NotImplemented 。 如果你想强制回退到右操作数的反射方法，请不要设置方法为None — 那会造成显式地阻塞 此种回退的相反效果。

For operands of the same type, it is assumed that if the non-reflectedmethod -- such as__add__() -- fails then the overalloperation is notsupported, which is why the reflected method is not called.