3. 数据模型¶
3.1. 对象、值与类型¶
Objects are Python’s abstraction for data. All data in a Python program is represented by objects or by relations between objects. (In a sense, and in conformance to Von Neumann’s model of a “stored program computer,” code is also represented by objects.)
每个对象都有各自的编号、类型和值。一个对象被创建后,它的 编号 就绝不会改变;你可以将其理解为该对象在内存中的地址。 ‘is
’ 运算符可以比较两个对象的编号是否相同;id()
函数能返回一个代表其编号的整型数。
在 CPython 中,id(x)
就是存放 x
的内存的地址。
对象的类型决定该对象所支持的操作 (例如 “对象是否有长度属性?”) 并且定义了该类型的对象可能的取值。type()
函数能返回一个对象的类型 (类型本身也是对象)。与编号一样,一个对象的 类型 也是不可改变的。[1]
有些对象的 值 可以改变。值可以改变的对象被称为 可变的;值不可以改变的对象就被称为 不可变的。(一个不可变容器对象如果包含对可变对象的引用,当后者的值改变时,前者的值也会改变;但是该容器仍属于不可变对象,因为它所包含的对象集是不会改变的。因此,不可变并不严格等同于值不能改变,实际含义要更微妙。) 一个对象的可变性是由其类型决定的;例如,数字、字符串和元组是不可变的,而字典和列表是可变的。
对象绝不会被显式地销毁;然而,当无法访问时它们可能会被作为垃圾回收。允许具体的实现推迟垃圾回收或完全省略此机制 — 如何实现垃圾回收是实现的质量问题,只要可访问的对象不会被回收即可。
CPython 目前使用带有 (可选) 延迟检测循环链接垃圾的引用计数方案,会在对象不可访问时立即回收其中的大部分,但不保证回收包含循环引用的垃圾。请查看 gc
模块的文档了解如何控制循环垃圾的收集相关信息。其他实现会有不同的行为方式,CPython 现有方式也可能改变。不要依赖不可访问对象的立即终结机制 (所以你应当总是显式地关闭文件)。
注意:使用实现的跟踪或调试功能可能令正常情况下会被回收的对象继续存活。还要注意通过 ‘try
…except
’ 语句捕捉异常也可能令对象保持存活。
有些对象包含对 “外部” 资源的引用,例如打开文件或窗口。当对象被作为垃圾回收时这些资源也应该会被释放,但由于垃圾回收并不确保发生,这些对象还提供了明确地释放外部资源的操作,通常为一个 close()
方法。强烈推荐在程序中显式关闭此类对象。’try
…finally
’ 语句和 ‘with
’ 语句提供了进行此种操作的更便捷方式。
有些对象包含对其他对象的引用;它们被称为 容器。容器的例子有元组、列表和字典等。这些引用是容器对象值的组成部分。在多数情况下,当谈论一个容器的值时,我们是指所包含对象的值而不是其编号;但是,当我们谈论一个容器的可变性时,则仅指其直接包含的对象的编号。因此,如果一个不可变容器 (例如元组) 包含对一个可变对象的引用,则当该可变对象被改变时容器的值也会改变。
类型会影响对象行为的几乎所有方面。甚至对象编号的重要性也在某种程度上受到影响: 对于不可变类型,会得出新值的运算实际上会返回对相同类型和取值的任一现有对象的引用,而对于可变类型来说这是不允许的。例如在 a = 1; b = 1
之后,a
和 b
可能会也可能不会指向同一个值为一的对象,这取决于具体实现,但是在 c = []; d = []
之后,c
和 d
保证会指向两个不同、单独的新建空列表。(请注意 c = d = []
则是将同一个对象赋值给 c
和 d
。)
3.2. 标准类型层级结构¶
以下是 Python 内置类型的列表。扩展模块 (具体实现会以 C, Java 或其他语言编写) 可以定义更多的类型。未来版本的 Python 可能会加入更多的类型 (例如有理数、高效存储的整型数组等等),不过新增类型往往都是通过标准库来提供的。
以下部分类型的描述中包含有 ‘特殊属性列表’ 段落。这些属性提供对具体实现的访问而非通常使用。它们的定义在未来可能会改变。
- None
此类型只有一种取值。是一个具有此值的单独对象。此对象通过内置名称
None
访问。在许多情况下它被用来表示空值,例如未显式指明返回值的函数将返回 None。它的逻辑值为假。- NotImplemented
此类型只有一种取值。是一个具有此值的单独对象。此对象通过内置名称
NotImplemented
访问。数值方法和丰富比较方法如未实现指定运算符表示的运算则应返回此值。(解释器会根据指定运算符继续尝试反向运算或其他回退操作)。它的逻辑值为真。详情参见 实现算数运算。
- Ellipsis
此类型只有一种取值。是一个具有此值的单独对象。此对象通过字面值
...
或内置名称Ellipsis
访问。它的逻辑值为真。numbers.Number
此类对象由数字字面值创建,并会被作为算术运算符和算术内置函数的返回结果。数字对象是不可变的;一旦创建其值就不再改变。Python 中的数字当然非常类似数学中的数字,但也受限于计算机中的数字表示方法。
Python 区分整型数、浮点型数和复数:
numbers.Integral
此类对象表示数学中整数集合的成员 (包括正数和负数)。
整型数可细分为两种类型:
整型 (
int
)此类对象表示任意大小的数字,仅受限于可用的内存 (包括虚拟内存)。在变换和掩码运算中会以二进制表示,负数会以 2 的补码表示,看起来像是符号位向左延伸补满空位。- 布尔型 (
bool
) 此类对象表示逻辑值 False 和 True。代表
False
和True
值的两个对象是唯二的布尔对象。布尔类型是整型的子类型,两个布尔值在各种场合的行为分别类似于数值 0 和 1,例外情况只有在转换为字符串时分别返回字符串"False"
或"True"
。
整型数表示规则的目的是在涉及负整型数的变换和掩码运算时提供最为合理的解释。
- 布尔型 (
numbers.Real
(float
)此类对象表示机器级的双精度浮点数。其所接受的取值范围和溢出处理将受制于底层的机器架构 (以及 C 或 Java 实现)。Python 不支持单精度浮点数;支持后者通常的理由是节省处理器和内存消耗,但这点节省相对于在 Python 中使用对象的开销来说太过微不足道,因此没有理由包含两种浮点数而令该语言变得复杂。
numbers.Complex
(complex
)此类对象以一对机器级的双精度浮点数来表示复数值。有关浮点数的附带规则对其同样有效。一个复数值
z
的实部和虚部可通过只读属性z.real
和z.imag
来获取。
- 序列
此类对象表示以非负整数作为索引的有限有序集。内置函数
len()
可返回一个序列的条目数量。当一个序列的长度为 n 时,索引集包含数字 0, 1, …, n-1。序列 a 的条目 i 可通过a[i]
选择。序列还支持切片:
a[i:j]
选择索引号为 k 的所有条目,i<=
k<
j。当用作表达式时,序列的切片就是一个与序列类型相同的新序列。新序列的索引还是从 0 开始。有些序列还支持带有第三个 “step” 形参的 “扩展切片”:
a[i:j:k]
选择 a 中索引号为 x 的所有条目,x = i + n*k
, n>=
0
且 i<=
x<
j。序列可根据其可变性来加以区分:
- 不可变序列
不可变序列类型的对象一旦创建就不能再改变。(如果对象包含对其他对象的引用,其中的可变对象就是可以改变的;但是,一个不可变对象所直接引用的对象集是不能改变的。)
以下类型属于不可变对象:
- 字符串
字符串是由 Unicode 码位值组成的序列。范围在
U+0000 - U+10FFFF
之内的所有码位值都可在字符串中使用。Python 没有char
类型;而是将字符串中的每个码位表示为一个长度为1
的字符串对象。内置函数ord()
可将一个码位由字符串形式转换成一个范围在0 - 10FFFF
之内的整型数;chr()
可将一个范围在0 - 10FFFF
之内的整型数转换为长度为1
的对应字符串对象。str.encode()
可以使用指定的文本编码将str
转换为bytes
,而bytes.decode()
则可以实现反向的解码。- 元组
一个元组中的条目可以是任意 Python 对象。包含两个或以上条目的元组由逗号分隔的表达式构成。只有一个条目的元组 (‘单项元组’) 可通过在表达式后加一个逗号来构成 (一个表达式本身不能创建为元组,因为圆括号要用来设置表达式分组)。一个空元组可通过一对内容为空的圆括号创建。
- 字节串
A bytes object is an immutable array. The items are 8-bit bytes, represented by integers in the range 0 <= x < 256. Bytes literals (like
b'abc'
) and the built-in functionbytes()
can be used to construct bytes objects. Also, bytes objects can be decoded to strings via thedecode()
method.
- 可变序列
可变序列在被创建后仍可被改变。下标和切片标注可被用作赋值和
del
(删除) 语句的目标。目前有两种内生可变序列类型:
- 列表
列表中的条目可以是任意 Python 对象。列表由用方括号括起并由逗号分隔的多个表达式构成。(注意创建长度为 0 或 1 的列表无需使用特殊规则。)
- 字节数组
A bytearray object is a mutable array. They are created by the built-in
bytearray()
constructor. Aside from being mutable (and hence unhashable), byte arrays otherwise provide the same interface and functionality as immutable bytes objects.
扩展模块
array
提供了一个额外的可变序列类型示例,collections
模块也是如此。
- 集合类型
此类对象表示由不重复且不可变对象组成的无序且有限的集合。因此它们不能通过下标来索引。但是它们可被迭代,也可用内置函数
len()
返回集合中的条目数。集合常见的用处是快速成员检测,去除序列中的重复项,以及进行交、并、差和对称差等数学运算。对于集合元素所采用的不可变规则与字典的键相同。注意数字类型遵循正常的数字比较规则: 如果两个数字相等 (例如
1
和1.0
),则同一集合中只能包含其中一个。目前有两种内生集合类型:
- 集合
此类对象表示可变集合。它们可通过内置的
set()
构造器创建,并且创建之后可以通过方法进行修改,例如add()
。- 冻结集合
此类对象表示不可变集合。它们可通过内置的
frozenset()
构造器创建。由于 frozenset 对象不可变且 hashable,它可以被用作另一个集合的元素或是字典的键。
- 映射
此类对象表示由任意索引集合所索引的对象的集合。通过下标
a[k]
可在映射a
中选择索引为k
的条目;这可以在表达式中使用,也可作为赋值或del
语句的目标。内置函数len()
可返回一个映射中的条目数。目前只有一种内生映射类型:
- 字典
此类对象表示由几乎任意值作为索引的有限个对象的集合。不可作为键的值类型只有包含列表或字典或其他可变类型,通过值而非对象编号进行比较的值,其原因在于高效的字典实现需要使用键的哈希值以保持一致性。用作键的数字类型遵循正常的数字比较规则: 如果两个数字相等 (例如
1
和1.0
) 则它们均可来用来索引同一个字典条目。字典是可变的;它们可通过
{...}
标注来创建 (参见 字典显示 小节)。扩展模块
dbm.ndbm
和dbm.gnu
提供了额外的映射类型示例,collections
模块也是如此。
- 可调用类型
此类型可以被应用于函数调用操作 (参见 调用 小节):
- 用户定义函数
用户定义函数对象可通过函数定义来创建 (参见 函数定义 小节)。它被调用时应附带一个参数列表,其中包含的条目应与函数所定义的形参列表一致。
特殊属性:
属性 含义 __doc__
The function’s documentation string, or None
if unavailable; not inherited by subclasses可写 __name__
The function’s name 可写 __qualname__
The function’s qualified name
3.3 新版功能.
可写 __module__
该函数所属模块的名称,没有则为 None
。可写 __defaults__
A tuple containing default argument values for those arguments that have defaults, or None
if no arguments have a default value可写 __code__
表示编译后的函数体的代码对象。 可写 __globals__
对存放该函数中全局变量的字典的引用 — 函数所属模块的全局命名空间。 只读 __dict__
命名空间支持的函数属性。 可写 __closure__
None
or a tuple of cells that contain bindings for the function’s free variables.只读 __annotations__
包含参数标注的字典。字典的键是参数名,如存在返回标注则为 'return'
。可写 __kwdefaults__
仅包含关键字参数默认值的字典。 可写 大部分标有 “Writable” 的属性均会检查赋值的类型。
函数对象也支持获取和设置任意属性,例如这可以被用来给函数附加元数据。使用正规的属性点号标注获取和设置此类属性。注意当前实现仅支持用户定义函数属性。未来可能会增加支持内置函数属性。
有关函数定义的额外信息可以从其代码对象中提取;参见下文对内部类型的描述。
- 实例方法
实例方法用于结合类、类实例和任何可调用对象 (通常为用户定义函数)。
特殊的只读属性:
__self__
为类实例对象本身,__func__
为函数对象;__doc__
为方法的文档 (与__func__.__doc__
作用相同);__name__
为方法名称 (与__func__.__name__
作用相同);__module__
为方法所属模块的名称,没有则为None
。方法还支持获取 (但不能设置) 下层函数对象的任意函数属性。
用户定义方法对象可在获取一个类的属性时被创建 (也可能通过该类的一个实例),如果该属性为用户定义函数对象或类方法对象。
当通过从类实例获取一个用户定义函数对象的方式创建一个实例方法对象时,类实例对象的
__self__
属性即为该实例,并会绑定方法对象。该新建方法的__func__
属性就是原来的函数对象。当通过从类或实例获取另一个方法对象的方式创建一个用户定义方法对象时,其行为将等同于一个函数对象,例外的只有新实例的
__func__
属性将不是原来的方法对象,而是其__func__
属性。当通过从类或实例获取一个类方法对象的方式创建一个实例对象时,实例对象的
__self__
属性为该类本身,其__func__
属性为类方法对应的下层函数对象。当一个实例方法对象被调用时,会调用对应的下层函数 (
__func__
),并将类实例 (__self__
) 插入参数列表的开头。例如,当C
是一个包含了f()
函数定义的类,而x
是C
的一个实例,则调用x.f(1)
就等同于调用C.f(x, 1)
。当一个实例方法对象是衍生自一个类方法对象时,保存在
__self__
中的 “类实例” 实际上会是该类本身,因此无论是调用x.f(1)
还是C.f(1)
都等同于调用f(C,1)
,其中f
为对应的下层函数。请注意从函数对象到实例方法对象的变换会在每一次从实例获取属性时发生。在某些情况下,一种高效的优化方式是将属性赋值给一个本地变量并调用该本地变量。还要注意这样的变换只发生于用户定义函数;其他可调用对象 (以及所有不可调用对象) 在被获取时都不会发生变换。还有一个需要关注的要点是作为一个类实例属性的用户定义函数不会被转换为绑定方法;这样的变换 仅当 函数是类属性时才会发生。
- 生成器函数
A function or method which uses the
yield
statement (see section The yield statement) is called a generator function. Such a function, when called, always returns an iterator object which can be used to execute the body of the function: calling the iterator’siterator.__next__()
method will cause the function to execute until it provides a value using theyield
statement. When the function executes areturn
statement or falls off the end, aStopIteration
exception is raised and the iterator will have reached the end of the set of values to be returned.- 协程函数
使用
async def
来定义的函数或方法就被称为 协程函数。这样的函数在被调用时会返回一个 coroutine 对象。它可能包含await
表达式以及async with
和async for
语句。详情可参见 协程对象 一节。- 内置函数
内置函数对象是对于 C 函数的外部封装。内置函数的例子包括
len()
和math.sin()
(math
是一个标准内置模块)。内置函数参数的数量和类型由 C 函数决定。特殊的只读属性:__doc__
是函数的文档字符串,如果没有则为None
;__name__
是函数的名称;__self__
设定为None
(参见下一条目);__module__
是函数所属模块的名称,如果没有则为None
。- 内置方法
此类型实际上是内置函数的另一种形式,只不过还包含了一个传入 C 函数的对象作为隐式的额外参数。内置方法的一个例子是
alist.append()
,其中 alist 为一个列表对象。在此示例中,特殊的只读属性__self__
会被设为 alist 所标记的对象。- 类
- 类是可调用的。此种对象通常是作为“工厂”来创建自身的实例,类也可以有重载
__new__()
的变体类型。调用的参数会传给__new__()
,而且通常也会传给__init__()
来初始化新的实例。 - 类实例
- 任意类的实例通过在所属类中定义
__call__()
方法即能成为可调用的对象。
- 模块
Modules are a basic organizational unit of Python code, and are created by the import system as invoked either by the
import
statement (seeimport
), or by calling functions such asimportlib.import_module()
and built-in__import__()
. A module object has a namespace implemented by a dictionary object (this is the dictionary referenced by the__globals__
attribute of functions defined in the module). Attribute references are translated to lookups in this dictionary, e.g.,m.x
is equivalent tom.__dict__["x"]
. A module object does not contain the code object used to initialize the module (since it isn’t needed once the initialization is done).属性赋值会更新模块的命名空间字典,例如
m.x = 1
等同于m.__dict__["x"] = 1
。特殊的只读属性:
__dict__
为以字典对象表示的模块命名空间。由于 CPython 清理模块字典的设定,当模块离开作用域时模块字典将会被清理,即使该字典还有活动的引用。想避免此问题,可复制该字典或保持模块状态以直接使用其字典。
Predefined (writable) attributes:
__name__
is the module’s name;__doc__
is the module’s documentation string, orNone
if unavailable;__file__
is the pathname of the file from which the module was loaded, if it was loaded from a file. The__file__
attribute may be missing for certain types of modules, such as C modules that are statically linked into the interpreter; for extension modules loaded dynamically from a shared library, it is the pathname of the shared library file.- 自定义类
自定义类这种类型一般通过类定义来创建 (参见 类定义 一节)。每个类都有通过一个字典对象实现的独立命名空间。类属性引用会被转化为在此字典中查找,例如
C.x
会被转化为C.__dict__["x"]
(不过也存在一些钩子对象以允许其他定位属性的方式)。当未在其中发现某个属性名称时,会继续在基类中查找。这种基类查找使用 C3 方法解析顺序,即使存在 ‘钻石形’ 继承结构即有多条继承路径连到一个共同祖先也能保持正确的行为。有关 Python 使用的 C3 MRO 的详情可查看配合 2.3 版发布的文档 https://www.python.org/download/releases/2.3/mro/.When a class attribute reference (for class
C
, say) would yield a class method object, it is transformed into an instance method object whose__self__
attributes isC
. When it would yield a static method object, it is transformed into the object wrapped by the static method object. See section 实现描述器 for another way in which attributes retrieved from a class may differ from those actually contained in its__dict__
.类属性赋值会更新类的字典,但不会更新基类的字典。
类对象可被调用 (见上文) 以产生一个类实例 (见下文)。
Special attributes:
__name__
is the class name;__module__
is the module name in which the class was defined;__dict__
is the dictionary containing the class’s namespace;__bases__
is a tuple containing the base classes, in the order of their occurrence in the base class list;__doc__
is the class’s documentation string, orNone
if undefined.- 类实例
类实例可通过调用类对象来创建 (见上文)。每个类实例都有通过一个字典对象实现的独立命名空间,属性引用会首先在此字典中查找。当未在其中发现某个属性,而实例对应的类中有该属性时,会继续在类属性中查找。如果找到的类属性为一个用户定义函数对象,它会被转化为实例方法对象,其
__self__
属性即该实例。静态方法和类方法对象也会被转化;参见上文 “Classes” 一节。要了解其他通过类实例来获取相应类属性的方式可参见 实现描述器 一节,这样得到的属性可能与实际存放于类的__dict__
中的对象不同。如果未找到类属性,而对象对应的类具有__getattr__()
方法,则会调用该方法来满足查找要求。属性赋值和删除会更新实例的字典,但不会更新对应类的字典。如果类具有
__setattr__()
或__delattr__()
方法,则将调用方法而不再直接更新实例的字典。如果类实例具有某些特殊名称的方法,就可以伪装为数字、序列或映射。参见 特殊方法名称 一节。
- I/O 对象 (或称文件对象)
file object 表示一个打开的文件。有多种快捷方式可用来创建文件对象:
open()
内置函数,以及os.popen()
,os.fdopen()
和 socket 对象的makefile()
方法 (还可能使用某些扩展模块所提供的其他函数或方法)。sys.stdin
,sys.stdout
和sys.stderr
会初始化为对应于解释器标准输入、输出和错误流的文件对象;它们都会以文本模式打开,因此都遵循io.TextIOBase
抽象类所定义的接口。- 内部类型
某些由解释器内部使用的类型也被暴露给用户。它们的定义可能随未来解释器版本的更新而变化,为内容完整起见在此处一并介绍。
- 代码对象
代码对象表示 编译为字节的 可执行 Python 代码,或称 bytecode。代码对象和函数对象的区别在于函数对象包含对函数全局对象 (函数所属的模块) 的显式引用,而代码对象不包含上下文;而且默认参数值会存放于函数对象而不是代码对象内 (因为它们表示在运行时算出的值)。与函数对象不同,代码对象不可变,也不包含对可变对象的引用 (不论是直接还是间接)。
Special read-only attributes:
co_name
gives the function name;co_argcount
is the number of positional arguments (including arguments with default values);co_nlocals
is the number of local variables used by the function (including arguments);co_varnames
is a tuple containing the names of the local variables (starting with the argument names);co_cellvars
is a tuple containing the names of local variables that are referenced by nested functions;co_freevars
is a tuple containing the names of free variables;co_code
is a string representing the sequence of bytecode instructions;co_consts
is a tuple containing the literals used by the bytecode;co_names
is a tuple containing the names used by the bytecode;co_filename
is the filename from which the code was compiled;co_firstlineno
is the first line number of the function;co_lnotab
is a string encoding the mapping from bytecode offsets to line numbers (for details see the source code of the interpreter);co_stacksize
is the required stack size (including local variables);co_flags
is an integer encoding a number of flags for the interpreter.以下是可用于
co_flags
的标志位定义:如果函数使用*arguments
语法来接受任意数量的位置参数,则0x04
位被设置;如果函数使用**keywords
语法来接受任意数量的关键字参数,则0x08
位被设置;如果函数是一个生成器,则0x20
位被设置。未来特性声明 (
from __future__ import division
) 也使用co_flags
中的标志位来指明代码对象的编译是否启用特定的特性: 如果函数编译时启用未来除法特性则设置0x2000
位; 在更早的 Python 版本中则使用0x10
和0x1000
位。co_flags
中的其他位被保留为内部使用。如果代码对象表示一个函数,
co_consts
中的第一项将是函数的文档字符串,如果未定义则为None
。
- 帧对象
Frame objects represent execution frames. They may occur in traceback objects (see below).
特殊的只读属性:
f_back
为前一堆栈帧 (指向调用者),如是最底层堆栈帧则为None
;f_code
为此帧中所执行的代码对象;f_locals
为用于查找本地变量的字典;f_globals
则用于查找全局变量;f_builtins
用于查找内置 (固有) 名称;f_lasti
给出精确指令 (这是代码对象的字节码字符串的一个索引)。Special writable attributes:
f_trace
, if notNone
, is a function called at the start of each source code line (this is used by the debugger);f_lineno
is the current line number of the frame — writing to this from within a trace function jumps to the given line (only for the bottom-most frame). A debugger can implement a Jump command (aka Set Next Statement) by writing to f_lineno.帧对象支持一个方法:
-
frame.
clear
()¶ 此方法清除该帧持有的全部对本地变量的引用。而且如果该帧属于一个生成器,生成器会被完成。这有助于打破包含帧对象的循环引用 (例如当捕获一个异常并保存其回溯在之后使用)。
如果该帧当前正在执行则会引发
RuntimeError
。3.4 新版功能.
-
- 回溯对象
Traceback objects represent a stack trace of an exception. A traceback object is created when an exception occurs. When the search for an exception handler unwinds the execution stack, at each unwound level a traceback object is inserted in front of the current traceback. When an exception handler is entered, the stack trace is made available to the program. (See section The try statement.) It is accessible as the third item of the tuple returned by
sys.exc_info()
. When the program contains no suitable handler, the stack trace is written (nicely formatted) to the standard error stream; if the interpreter is interactive, it is also made available to the user assys.last_traceback
.Special read-only attributes:
tb_next
is the next level in the stack trace (towards the frame where the exception occurred), orNone
if there is no next level;tb_frame
points to the execution frame of the current level;tb_lineno
gives the line number where the exception occurred;tb_lasti
indicates the precise instruction. The line number and last instruction in the traceback may differ from the line number of its frame object if the exception occurred in atry
statement with no matching except clause or with a finally clause.- 切片对象
切片对象用来表示
__getitem__()
方法用到的切片。 该对象也可使用内置的slice()
函数来创建。特殊的只读属性:
start
为下界;stop
为上界;step
为步长值; 各值如省略则为None
。这些属性可具有任意类型。切片对象支持一个方法:
-
slice.
indices
(self, length)¶ 此方法接受一个整型参数 length 并计算在切片对象被应用到 length 指定长度的条目序列时切片的相关信息应如何描述。 其返回值为三个整型数组成的元组;这些数分别为切片的 start 和 stop 索引号以及 step 步长值。索引号缺失或越界则按照与正规切片相一致的方式处理。
-
- 静态方法对象
- 静态方法对象提供了一种避免上文所述将函数对象转换为方法对象的方式。静态方法对象为对任意其他对象的封装,通常用来封装用户定义方法对象。当从类或类实例获取一个静态方法对象时,实际返回的对象是封装的对象,它不会被进一步转换。静态方法对象自身不是可调用的,但它们所封装的对象通常都是可调用的。静态方法对象可通过内置的
staticmethod()
构造器来创建。 - 类方法对象
- 类方法对象和静态方法一样是对其他对象的封装,会改变从类或类实例获取该对象的方式。类方法对象在此类获取操作中的行为已在上文 “用户定义方法” 一节中描述。类方法对象可通过内置的
classmethod()
构造器来创建。
3.3. 特殊方法名称¶
一个类可以通过定义具有特殊名称的方法来实现由特殊语法所引发的特定操作 (例如算术运算或下标与切片)。这是 Python 实现 操作符重载 的方式,允许每个类自行定义基于操作符的特定行为。例如,如果一个类定义了名为 __getitem__()
的方法,并且 x
为该类的一个实例,则 x[i]
基本就等同于 type(x).__getitem__(x, i)
。除非有说明例外情况,在没有定义适当方法的情况下尝试执行一种操作将引发一个异常 (通常为 AttributeError
或 TypeError
)。
在实现模拟任何内置类型的类时,很重要的一点是模拟的实现程度对于被模拟对象来说应当是有意义的。例如,提取单个元素的操作对于某些序列来说是适宜的,但提取切片可能就没有意义。(这种情况的一个实例是 W3C 的文档对象模型中的 NodeList
接口。)
3.3.1. 基本定制¶
-
object.
__new__
(cls[, ...])¶ 调用以创建一个 cls 类的新实例。
__new__()
是一个静态方法 (因为是特例所以你不需要显式地声明),它会将所请求实例所属的类作为第一个参数。其余的参数会被传递给对象构造器表达式 (对类的调用)。__new__()
的返回值应为新对象实例 (通常是 cls 的实例)。典型的实现会附带适宜的参数使用
super().__new__(cls[, ...])
,通过超类的__new__()
方法来创建一个类的新实例,然后根据需要修改新创建的实例再将其返回。如果
__new__()
返回一个 cls 的实例,则新实例的__init__()
方法会在之后被执行,例如__init__(self[, ...])
,其中 self 为新实例,其余的参数与被传递给__new__()
的相同。如果
__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)¶ Called when the instance is about to be destroyed. This is also called a destructor. If a base class has a
__del__()
method, the derived class’s__del__()
method, if any, must explicitly call it to ensure proper deletion of the base class part of the instance. Note that it is possible (though not recommended!) for the__del__()
method to postpone destruction of the instance by creating a new reference to it. It may then be called at a later time when this new reference is deleted. It is not guaranteed that__del__()
methods are called for objects that still exist when the interpreter exits.注解
del x
doesn’t directly callx.__del__()
— the former decrements the reference count forx
by one, and the latter is only called whenx
’s reference count reaches zero. Some common situations that may prevent the reference count of an object from going to zero include: circular references between objects (e.g., a doubly-linked list or a tree data structure with parent and child pointers); a reference to the object on the stack frame of a function that caught an exception (the traceback stored insys.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 insys.last_traceback
keeps the stack frame alive). The first situation can only be remedied by explicitly breaking the cycles; 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 storingNone
insys.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 thegc
module for more information about this topic.警告
Due to the precarious circumstances under which
__del__()
methods are invoked, exceptions that occur during their execution are ignored, and a warning is printed tosys.stderr
instead. Also, when__del__()
is invoked in response to a module being deleted (e.g., when execution of the program is done), other globals referenced by the__del__()
method may already have been deleted or in the process of being torn down (e.g. the import machinery shutting down). For this reason,__del__()
methods should do the absolute minimum needed to maintain external invariants. Starting with version 1.5, Python guarantees that globals whose name begins with a single underscore are deleted from their module before other globals are deleted; if no other references to such globals exist, this may help in assuring that imported modules are still available at the time when the__del__()
method is called.
-
object.
__repr__
(self)¶ 由
repr()
内置函数调用以输出一个对象的“官方”字符串表示。如果可能,这应类似一个有效的 Python 表达式,能被用来重建具有相同取值的对象(只要有适当的环境)。如果这不可能,则应返回形式如<...some useful description...>
的字符串。返回值必须是一个字符串对象。如果一个类定义了__repr__()
但未定义__str__()
,则在需要该类的实例的“非正式”字符串表示时也会使用__repr__()
。此方法通常被用于调试,因此确保其表示的内容包含丰富信息且无歧义是很重要的。
-
object.
__str__
(self)¶ 通过
str(object)
以及内置函数format()
和print()
调用以生成一个对象的“非正式”或格式良好的字符串表示。返回值必须为一个 字符串 对象。此方法与
object.__repr__()
的不同点在于__str__()
并不预期返回一个有效的 Python 表达式:可以使用更方便或更准确的描述信息。内置类型
object
所定义的默认实现会调用object.__repr__()
。
-
object.
__bytes__
(self)¶ Called by
bytes()
to compute a byte-string representation of an object. This should return abytes
object.
-
object.
__format__
(self, format_spec)¶ Called by the
format()
built-in function (and by extension, thestr.format()
method of classstr
) to produce a “formatted” string representation of an object. Theformat_spec
argument is a string that contains a description of the formatting options desired. The interpretation of theformat_spec
argument is up to the type implementing__format__()
, however most classes will either delegate formatting to one of the built-in types, or use a similar formatting option syntax.请参看 格式规格迷你语言 了解标准格式化语法的描述。
返回值必须为一个字符串对象。
在 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()
以确定结果为真还是假。在默认情况下
__ne__()
会委托给__eq__()
并将结果取反,除非结果为NotImplemented
。比较运算符之间没有其他隐含关系,例如(x<y or x==y)
为真并不意味着x<=y
。要根据单根运算自动生成排序操作,请参看functools.total_ordering()
。请查看
__hash__()
的相关段落,了解创建可支持自定义比较运算并可用作字典键的 hashable 对象时要注意的一些事项。这些方法并没有对调参数版本(在左边参数不支持该操作但右边参数支持时使用);而是
__lt__()
和__gt__()
互为对方的反射,__le__()
和__ge__()
互为对方的反射,而__eq__()
和__ne__()
则是它们自己的反射。如果两个操作数的类型不同,且右操作数类型是左操作数类型的直接或间接子类,则优先选择右操作数的反射方法,否则优先选择左操作数的方法。虚拟子类不会被考虑。
-
object.
__hash__
(self)¶ 通过内置函数
hash()
调用以对哈希集的成员进行操作,属于哈希集的类型包括set
、frozenset
以及dict
。__hash__()
应该返回一个整数。对象比较结果相同所需的唯一特征属性是其具有相同的哈希值;建议的做法是把参与比较的对象全部组件的哈希值混在一起,即将它们打包为一个元组并对该元组做哈希运算。例如:def __hash__(self): return hash((self.name, self.nick, self.color))
注解
hash()
会从一个对象自定义的__hash__()
方法返回值中截断为Py_ssize_t
的大小。通常对 64 位构建为 8 字节,对 32 位构建为 4 字节。如果一个对象的__hash__()
必须在不同位大小的构建上进行互操作,请确保检查全部所支持构建的宽度。做到这一点的简单方法是使用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 toNone
. When the__hash__()
method of a class isNone
, instances of the class will raise an appropriateTypeError
when a program attempts to retrieve their hash value, and will also be correctly identified as unhashable when checkingisinstance(obj, collections.Hashable)
.如果一个重载了
__eq__()
的类需要保留来自父类的__hash__()
实现,则必须通过设置__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 aTypeError
would be incorrectly identified as hashable by anisinstance(obj, collections.Hashable)
call.注解
在默认情况下,str、bytes 和 datetime 对象的
__hash__()
值会使用一个不可预知的随机值“加盐”。虽然它们会在一个单独 Python 进程中保持不变,它们的哈希值在重复运行的 Python 之间是不可预测的。这种做法是为了防止以下形式的拒绝服务攻击:通过仔细选择输入来利用字典插入操作在最坏情况下的执行效率即 O(n^2) 复杂度。详情见 http://www.ocert.org/advisories/ocert-2011-003.html
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).
另见
PYTHONHASHSEED
.在 3.3 版更改: 默认启用哈希随机化。
-
object.
__bool__
(self)¶ 调用此方法以实现真值检测以及内置的
bool()
操作;应该返回False
或True
。如果未定义此方法,则会查找并调用__len__()
并在其返回非零值时视对象的逻辑值为真。如果一个类既未定义__len__()
也未定义__bool__()
则视其所有实例的逻辑值为真。
3.3.2. 自定义属性访问¶
可以定义下列方法来自定义对类实例属性访问(x.name
的使用、赋值或删除)的具体含义.
-
object.
__getattr__
(self, name)¶ Called when an attribute lookup has not found the attribute in the usual places (i.e. it is not an instance attribute nor is it found in the class tree for
self
).name
is the attribute name. This method should return the (computed) attribute value or raise anAttributeError
exception.请注意如果属性是通过正常机制找到的,
__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
对于该对象有意义时才被实现。
3.3.2.1. 实现描述器¶
以下方法仅当一个包含该方法的类(称为 描述器 类)的实例出现于一个 所有者 类中的时候才会起作用(该描述器必须在所有者类或其某个上级类的字典中)。在以下示例中,“属性”指的是名称为所有者类 __dict__
中的特征属性的键名的属性。
-
object.
__get__
(self, instance, owner)¶ 调用此方法以获取所有者类的属性(类属性访问)或该类的实例的属性(实例属性访问)。所有者 是指所有者类,而 实例 是指被用来访问属性的实例,如果是 所有者 被用来访问属性时则为
None
。此方法应当返回(计算出的)属性值或是引发一个AttributeError
异常。
-
object.
__set__
(self, instance, value)¶ 调用此方法以设置 instance 指定的所有者类的实例的属性为新值 value。
-
object.
__delete__
(self, instance)¶ 调用此方法以删除 instance 指定的所有者类的实例的属性。
属性 __objclass__
会被 inspect
模块解读为指定此对象定义所在的类(正确设置此属性有助于动态类属性的运行时内省)。对于可调用对象来说,它可以指明预期或要求提供一个特定类型(或子类)的实例作为第一个位置参数(例如,CPython 会为实现于 C 中的未绑定方法设置此属性)。
3.3.2.2. 发起调用描述器¶
总的说来,描述器就是具有“绑定行为”的对象属性,其属性访问已被描述器协议中的方法所重载,包括 __get__()
, __set__()
和 __delete__()
。如果一个对象定义了以上方法中的任意一个,它就被称为描述器。
属性访问的默认行为是从一个对象的字典中获取、设置或删除属性。例如,a.x
的查找顺序会从 a.__dict__['x']
开始,然后是 type(a).__dict__['x']
,接下来依次查找 type(a)
的上级基类,不包括元类。
但是,如果找到的值是定义了某个描述器方法的对象,则 Python 可能会重载默认行为并转而发起调用描述器方法。这具体发生在优先级链的哪个环节则要根据所定义的描述器方法及其被调用的方式来决定。
描述器发起调用的开始点是一个绑定 a.x
。参数的组合方式依 a
而定:
- 直接调用
- 最简单但最不常见的调用方式是用户代码直接发起调用一个描述器方法:
x.__get__(a)
。 - 实例绑定
- 如果绑定到一个对象实例,
a.x
会被转换为调用:type(a).__dict__['x'].__get__(a, type(a))
。 - 类绑定
- 如果绑定到一个类,
A.x
会被转换为调用:A.__dict__['x'].__get__(None, A)
。 - 超绑定
- 如果
a
是super
的一个实例,则绑定super(B, obj).m()
会在obj.__class__.__mro__
中搜索B
的直接上级基类A
然后通过以下调用发起调用描述器:A.__dict__['m'].__get__(obj, obj.__class__)
。
对于实例绑定,发起描述器调用的优先级取决于定义了哪些描述器方法。一个描述器可以定义 __get__()
、__set__()
和 __delete__()
的任意组合。如果它没有定义 __get__()
,则访问属性会返回描述器对象自身,除非对象的实例字典中有相应属性值。如果描述器定义了 __set__()
和/或 __delete__()
,则它是一个数据描述器;如果以上两个都未定义,则它是一个非数据描述器。通常,数据描述器会同时定义 __get__()
和 __set__()
,而非数据描述器只有 __get__()
方法。定义了 __set__()
和 __get__()
的数据描述器总是会重载实例字典中的定义。与之相对的,非数据描述器可被实例所重载。
Python 方法 (包括 staticmethod()
和 classmethod()
) 都是作为非描述器来实现的。因此实例可以重定义并重载方法。这允许单个实例获得与相同类的其他实例不一样的行为。
property()
函数是作为数据描述器来实现的。因此实例不能重载特性属性的行为。
3.3.2.3. __slots__¶
By default, instances of classes have a dictionary for attribute storage. This wastes space for objects having very few instance variables. The space consumption can become acute when creating large numbers of instances.
The default can be overridden by defining __slots__ in a class definition. The __slots__ declaration takes a sequence of instance variables and reserves just enough space in each instance to hold a value for each variable. Space is saved because __dict__ is not created for each instance.
-
object.
__slots__
¶ 这个类变量可赋值为字符串、可迭代对象或由实例使用的变量名构成的字符串序列。 __slots__ 会为已声明的变量保留空间,并阻止自动为每个实例创建 __dict__ 和 __weakref__。
3.3.2.3.1. 使用 __slots__ 的注意事项¶
- When inheriting from a class without __slots__, the __dict__ attribute of that class will always be accessible, so a __slots__ definition in the subclass is meaningless.
- 没有 __dict__ 变量,实例就不能给未在 __slots__ 定义中列出的新变量赋值。尝试给一个未列出的变量名赋值将引发
AttributeError
。新变量需要动态赋值,就要将'__dict__'
加入到 __slots__ 声明的字符串序列中。 - 如果未给每个实例设置 __weakref__ 变量,定义了 __slots__ 的类就不支持对其实际的弱引用。如果需要弱引用支持,就要将
'__weakref__'
加入到 __slots__ 声明的字符串序列中。 - __slots__ 是通过为每个变量名创建描述器 (实现描述器) 在类层级上实现的。因此,类属性不能被用来为通过 __slots__ 定义的实例变量设置默认值;否则,类属性就会覆盖描述器赋值。
- The action of a __slots__ declaration is limited to the class where it is defined. As a result, subclasses will have a __dict__ unless they also define __slots__ (which must only contain names of any additional slots).
- 如果一个类定义的位置在某个基类中也有定义,则由基类位置定义的实例变量将不可访问(除非通过直接从基类获取其描述器的方式)。这会使得程序的含义变成未定义。未来可能会添加一个防止此情况的检查。
- 非空的 __slots__ 不适用于派生自“可变长度”内置类型例如
int
、bytes
和tuple
的派生类。 - 任何非字符串可迭代对象都可以被赋值给 __slots__。映射也可以被使用;不过,未来可能会分别赋给每个键具有特殊含义的值。
- __class__ 赋值仅在两个类具有相同的 __slots__ 时才会起作用。
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
在类定义内指定的任何其他关键字参数都会在下面所描述的所有元类操作中进行传递。
当一个类定义被执行时,将发生以下步骤:
- the appropriate metaclass is determined
- the class namespace is prepared
- the class body is executed
- the class object is created
3.3.3.1. 确定适当的元类¶
为一个类定义确定适当的元类是根据以下规则:
- if no bases and no explicit metaclass are given, then
type()
is used - if an explicit metaclass is given and it is not an instance of
type()
, then it is used directly as the metaclass - if an instance of
type()
is given as the explicit metaclass, or bases are defined, then the most derived metaclass is used
最近派生的元类会从显式指定的元类(如果有)以及所有指定的基类的元类(即 type(cls)
)中选取。最近派生的元类应为 所有 这些候选元类的一个子类型。如果没有一个候选元类符合该条件,则类定义将失败并抛出 TypeError
。
3.3.3.2. 准备类命名空间¶
Once the appropriate metaclass has been identified, then the class namespace
is prepared. If the metaclass has a __prepare__
attribute, it is called
as namespace = metaclass.__prepare__(name, bases, **kwds)
(where the
additional keyword arguments, if any, come from the class definition).
If the metaclass has no __prepare__
attribute, then the class namespace
is initialised as an empty dict()
instance.
参见
- PEP 3115 - Python 3000 中的元类
- 引入
__prepare__
命名空间钩子
3.3.3.3. 执行类主体¶
类主体会以(类似于) exec(body, globals(), namespace)
的形式被执行。普通调用与 exec()
的关键区别在于当类定义发生于函数内部时,词法作用域允许类主体(包括任何方法)引用来自当前和外部作用域的名称。
However, even when the class definition occurs inside the function, methods defined inside the class still cannot see names defined at the class scope. Class variables must be accessed through the first parameter of instance or class methods, and cannot be accessed at all from static methods.
3.3.3.4. 创建类对象¶
一旦执行类主体完成填充类命名空间,将通过调用 metaclass(name, bases, namespace, **kwds)
创建类对象(此处的附加关键字参数与传入 __prepare__
的相同)。
如果类主体中有任何方法引用了 __class__
或 super
,这个类对象会通过零参数形式的 super()
. __class__
所引用,这是由编译器所创建的隐式闭包引用。这使用零参数形式的 super()
能够正确标识正在基于词法作用域来定义的类,而被用于进行当前调用的类或实例则是基于传递给方法的第一个参数来标识的。
在类对象创建之后,它会被传给包含在类定义中的类装饰器(如果有的话),得到的对象将作为已定义的类绑定到局部命名空间。
When a new class is created by type.__new__
, the object provided as the
namespace parameter is copied to a standard Python dictionary and the original
object is discarded. The new copy becomes the __dict__
attribute
of the class object.
参见
- PEP 3135 - 新的超类型
- 描述隐式的
__class__
闭包引用
3.3.3.5. Metaclass example¶
The potential uses for metaclasses are boundless. Some ideas that have been explored include logging, interface checking, automatic delegation, automatic property creation, proxies, frameworks, and automatic resource locking/synchronization.
Here is an example of a metaclass that uses an collections.OrderedDict
to remember the order that class variables are defined:
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')
When the class definition for A gets executed, the process begins with
calling the metaclass’s __prepare__()
method which returns an empty
collections.OrderedDict
. That mapping records the methods and
attributes of A as they are defined within the body of the class statement.
Once those definitions are executed, the ordered dictionary is fully populated
and the metaclass’s __new__()
method gets invoked. That method builds
the new type and it saves the ordered dictionary keys in an attribute
called members
.
3.3.4. 自定义实例及子类检查¶
以下方法被用来重载 isinstance()
和 issubclass()
内置函数的默认行为。
特别地,元类 abc.ABCMeta
实现了这些方法以便允许将抽象基类(ABC)作为“虚拟基类”添加到任何类或类型(包括内置类型),包括其他 ABC 之中。
-
class.
__instancecheck__
(self, instance)¶ 如果 instance 应被视为 class 的一个(直接或间接)实例则返回真值。如果定义了此方法,则会被调用以实现
isinstance(instance, class)
。
-
class.
__subclasscheck__
(self, subclass)¶ Return true 如果 subclass 应被视为 class 的一个(直接或间接)子类则返回真值。如果定义了此方法,则会被调用以实现
issubclass(subclass, class)
。
请注意这些方法的查找是基于类的类型(元类)。它们不能作为类方法在实际的类中被定义。这与基于实例被调用的特殊方法的查找是一致的,只有在此情况下实例本身被当作是类。
参见
- PEP 3119 - 引入抽象基类
- 新增功能描述,通过
__instancecheck__()
和__subclasscheck__()
来定制isinstance()
和issubclass()
行为,加入此功能的动机是出于向该语言添加抽象基类的内容(参见abc
模块)。
3.3.5. 模拟可调用对象¶
-
object.
__call__
(self[, args...])¶ 此方法会在实例作为一个函数被“调用”时被调用;如果定义了此方法,则
x(arg1, arg2, ...)
就相当于x.__call__(arg1, arg2, ...)
的快捷方式。
3.3.6. 模拟容器类型¶
The following methods can be defined to implement container objects. Containers
usually are sequences (such as lists or tuples) or mappings (like dictionaries),
but can represent other containers as well. The first set of methods is used
either to emulate a sequence or to emulate a mapping; the difference is that for
a sequence, the allowable keys should be the integers k for which 0 <= k <
N
where N is the length of the sequence, or slice objects, which define a
range of items. 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()
.
Mutable sequences should provide methods append()
, count()
,
index()
, extend()
, insert()
, pop()
, remove()
,
reverse()
and sort()
, like Python standard list objects. Finally,
sequence types should implement addition (meaning concatenation) and
multiplication (meaning repetition) by defining the methods __add__()
,
__radd__()
, __iadd__()
, __mul__()
, __rmul__()
and
__imul__()
described below; they should not define other numerical
operators. It is recommended that both mappings and sequences implement the
__contains__()
method to allow efficient use of the in
operator; for
mappings, in
should search the mapping’s keys; for sequences, it should
search through the values. It is further recommended that both mappings and
sequences implement the __iter__()
method to allow efficient iteration
through the container; for mappings, __iter__()
should be the same as
keys()
; for sequences, it should iterate through the values.
-
object.
__len__
(self)¶ 调用此方法以实现内置函数
len()
。应该返回对象的长度,以一个>=
0 的整数表示。此外,如果一个对象未定义__bool__()
方法而其__len__()
方法返回值为零,则在布尔运算中会被视为假值。在 CPython 中,要求长度最大为
sys.maxsize
。如果长度大于sys.maxsize
则某些特性 (例如len()
) 可能会引发OverflowError
。要通过真值检测来防止引发OverflowError
,对象必须定义__bool__()
方法。
-
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.3.4 新版功能.
注解
切片是通过下述三个专门方法完成的。以下形式的调用
a[1:2] = b
会为转写为
a[slice(1, 2, None)] = b
其他形式以此类推。略去的切片项总是以 None
补全。
-
object.
__getitem__
(self, key)¶ 调用此方法以实现
self[key]
的求值。对于序列类型,接受的键应为整数和切片对象。请注意负数索引(如果类想要模拟序列类型)的特殊解读是取决于__getitem__()
方法。如果 key 的类型不正确则会引发TypeError
异常;如果为序列索引集范围以外的值(在进行任何负数索引的特殊解读之后)则应引发IndexError
异常。对于映射类型,如果 key 找不到(不在容器中)则应引发KeyError
异常。注解
for
循环在有不合法索引时会期待捕获IndexError
以便正确地检测到序列的结束。
-
object.
__missing__
(self, key)¶ 此方法由
dict
.__getitem__()
在找不到字典中的键时调用以实现 dict 子类的self[key]
。
-
object.
__setitem__
(self, key, value)¶ 调用此方法以实现向
self[key]
赋值。注意事项与__getitem__()
相同。为对象实现此方法应该仅限于需要映射允许基于键修改值或添加键,或是序列允许元素被替换时。不正确的 key 值所引发的异常应与__getitem__()
方法的情况相同。
-
object.
__delitem__
(self, key)¶ 调用此方法以实现
self[key]
的删除。注意事项与__getitem__()
相同。为对象实现此方法应该权限于需要映射允许移除键,或是序列允许移除元素时。不正确的 key 值所引发的异常应与__getitem__()
方法的情况相同。
-
object.
__iter__
(self)¶ 此方法在需要为容器创建迭代器时被调用。此方法应该返回一个新的迭代器对象,它能够逐个迭代容器中的所有对象。对于映射,它应该逐个迭代容器中的键。
迭代器对象也需要实现此方法;它们需要返回对象自身。有关迭代器对象的详情请参看 迭代器类型 一节。
-
object.
__reversed__
(self)¶ 此方法(如果存在)会被
reversed()
内置函数调用以实现逆向迭代。它应当返回一个新的以逆序逐个迭代容器内所有对象的迭代器对象。如果未提供
__reversed__()
方法,则reversed()
内置函数将回退到使用序列协议 (__len__()
和__getitem__()
)。支持序列协议的对象应当仅在能够提供比reversed()
所提供的实现更高效的实现时才提供__reversed__()
方法。
The membership test operators (in
and not in
) are normally
implemented as an iteration through a sequence. However, container objects can
supply the following special method with a more efficient implementation, which
also does not require the object be a sequence.
-
object.
__contains__
(self, item)¶ 调用此方法以实现成员检测运算符。如果 item 是 self 的成员则应返回真,否则返回假。对于映射类型,此检测应基于映射的键而不是值或者键值对。
对于未定义
__contains__()
的对象,成员检测将首先尝试通过__iter__()
进行迭代,然后再使用__getitem__()
的旧式序列迭代协议,参看 语言参考中的相应部分。
3.3.7. 模拟数字类型¶
定义以下方法即可模拟数字类型。特定种类的数字不支持的运算(例如非整数不能进行位运算)所对应的方法应当保持未定义状态。
-
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)¶ 调用这些方法来实现二进制算术运算 (
+
,-
,*
,@
,/
,//
,%
,divmod()
,pow()
,**
,<<
,>>
,&
,^
,|
)。例如,求表达式x + y
的值,其中 x 是具有__add__()
方法的类的一个实例,则会调用x.__add__(y)
。__divmod__()
方法应该等价于使用__floordiv__()
和__mod__()
,它不应该被关联到__truediv__()
。请注意如果要支持三元版本的内置pow()
函数,则__pow__()
的定义应该接受可选的第三个参数。如果这些方法中的某一个不支持与所提供参数进行运算,它应该返回
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)¶ -
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 does not support the corresponding operation and the operands are of different types. [2] For instance, to evaluate the expressionx - y
, where y is an instance of a class that has an__rsub__()
method,y.__rsub__(x)
is called ifx.__sub__(y)
returns NotImplemented.请注意三元版的
pow()
并不会尝试调用__rpow__()
(因为强制转换规则会太过复杂)。注解
如果右操作数类型为左操作数类型的一个子类,且该子类提供了指定运算的反射方法,则此方法会先于左操作数的非反射方法被调用。此行为可允许子类重载其祖先类的运算符。
-
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)。如果某个方法未被定义,相应的扩展算术赋值将回退到普通方法。例如,如果 x 是具有__iadd__()
方法的类的一个实例,则x += y
就等价于x = x.__iadd__(y)
。否则就如x + y
的求值一样选择x.__add__(y)
和y.__radd__(x)
。在某些情况下,扩展赋值可导致未预期的错误 (参见 为什么 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)¶ -
object.
__round__
(self[, n])¶ Called to implement the built-in functions
complex()
,int()
,float()
andround()
. Should return a value of the appropriate type.
-
object.
__index__
(self)¶ 调用此方法以实现
operator.index()
以及 Python 需要无损地将数字对象转换为整数对象的场合(例如切片或是内置的bin()
,hex()
和oct()
函数)。 存在此方法表明数字对象属于整数类型。 必须返回一个整数。注解
为了具有一致的整数类型类,当定义了
__index__()
的时候也应当定义__int__()
,两者应当返回相同的值。
3.3.8. with 语句上下文管理器¶
A context manager is an object that defines the runtime context to be
established when executing a with
statement. The context manager
handles the entry into, and the exit from, the desired runtime context for the
execution of the block of code. Context managers are normally invoked using the
with
statement (described in section The with statement), but can also be
used by directly invoking their methods.
上下文管理器的典型用法包括保存和恢复各种全局状态,锁定和解锁资源,关闭打开的文件等等。
要了解上下文管理器的更多信息,请参阅 上下文管理器类型。
-
object.
__enter__
(self)¶ Enter the runtime context related to this object. The
with
statement will bind this method’s return value to the target(s) specified in theas
clause of the statement, if any.
-
object.
__exit__
(self, exc_type, exc_value, traceback)¶ 退出关联到此对象的运行时上下文。 各个参数描述了导致上下文退出的异常。 如果上下文是无异常地退出的,三个参数都将为
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__()
。 如果这些方法的隐式查找使用了传统的查找过程,它们会在对类型对象本身发起调用时失败:
>>> 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. 协程¶
3.4.1. 可等待对象¶
awaitable 对象主要实现了 __await__()
方法。 从 async def
函数返回的 Coroutine 对象即属于可等待对象。
注解
从带有 types.coroutine()
或 asyncio.coroutine()
装饰器的生成器返回的 generator iterator 对象也属于可等待对象,但它们并未实现 __await__()
。
-
object.
__await__
(self)¶ 必须返回一个 iterator。 应当被用来实现 awaitable 对象。 例如,
asyncio.Future
实现了此方法以与await
表达式相兼容。
3.5 新版功能.
参见
PEP 492 了解有关可等待对象的详细信息。
3.4.2. 协程对象¶
Coroutine 对象属于 awaitable 对象。 协程的执行可通过调用 __await__()
并迭代其结果来进行控制。 当协程结束执行并返回时,迭代器会引发 StopIteration
,该异常的 value
属性将指向返回值。 如果协程引发了异常,它会被迭代器所传播。 协程不应该直接引发未处理的 StopIteration
异常。
协程也具有下面列出的方法,它们类似于生成器的对应方法 (参见 生成器-迭代器的方法)。 但是,与生成器不同,协程并不直接支持迭代。
在 3.5.2 版更改: 等待一个协程超过一次将引发 RuntimeError
。
-
coroutine.
send
(value)¶ 开始或恢复协程的执行。 如果 value 为
None
,则这相当于前往__await__()
所返回迭代器的下一项。 如果 value 不为None
,此方法将委托给导致协程挂起的迭代器的send()
方法。 其结果(返回值,StopIteration
或是其他异常)将与上述对__await__()
返回值进行迭代的结果相同。
-
coroutine.
throw
(type[, value[, traceback]])¶ 在协程内引发指定的异常。 此方法将委托给导致协程挂起的迭代器的
throw()
方法,如果存在该方法。 否则的话,异常会在挂起点被引发。 其结果(返回值,StopIteration
或是其他异常)将与上述对__await__()
返回值进行迭代的结果相同。 如果异常未在协程内被捕获,则将回传给调用者。
-
coroutine.
close
()¶ 此方法会使得协程清理自身并退出。 如果协程被挂起,此方法会先委托给导致协程挂起的迭代器的
close()
方法,如果存在该方法。 然后它会在挂起点引发GeneratorExit
,使得协程立即清理自身。 最后,协程会被标记为已结束执行,即使它根本未被启动。当协程对象将要被销毁时,会使用以上处理过程来自动关闭。
3.4.3. 异步迭代器¶
An asynchronous iterable is able to call asynchronous code in its
__aiter__
implementation, and an asynchronous iterator can call
asynchronous code in its __anext__
method.
异步迭代器可在 async for
语句中使用。
-
object.
__aiter__
(self)¶ 必须返回一个 异步迭代器 对象。
-
object.
__anext__
(self)¶ 必须返回一个 可迭代对象 输出迭代器的下一结果值。 当迭代结束时应该引发
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.5 新版功能.
注解
在 3.5.2 版更改: Starting with CPython 3.5.2, __aiter__
can directly return
asynchronous iterators. Returning
an awaitable object will result in a
PendingDeprecationWarning
.
The recommended way of writing backwards compatible code in
CPython 3.5.x is to continue returning awaitables from
__aiter__
. If you want to avoid the PendingDeprecationWarning
and keep the code backwards compatible, the following decorator
can be used:
import functools
import sys
if sys.version_info < (3, 5, 2):
def aiter_compat(func):
@functools.wraps(func)
async def wrapper(self):
return func(self)
return wrapper
else:
def aiter_compat(func):
return func
Example:
class AsyncIterator:
@aiter_compat
def __aiter__(self):
return self
async def __anext__(self):
...
Starting with CPython 3.6, the PendingDeprecationWarning
will be replaced with the DeprecationWarning
.
In CPython 3.7, returning an awaitable from __aiter__
will
result in a RuntimeError
.
3.4.4. 异步上下文管理器¶
异步上下文管理器 是 上下文管理器 的一种,它能够在其 __aenter__
和 __aexit__
方法中暂停执行。
异步上下文管理器可在 async with
语句中使用。
-
object.
__aenter__
(self)¶ 此方法在语义上类似于
__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')
3.5 新版功能.
备注
[1] | 在某些情况下 有可能 基于可控的条件改变一个对象的类型。 但这通常不是个好主意,因为如果处理不当会导致一些非常怪异的行为。 |
[2] | 对于相同类型的操作数,如果非反射方法 (例如 __add__() ) 失败则会认为相应运算不被支持,这就是反射方法未被调用的原因。 |