None此类型只有一种取值。是一个具有此值的单独对象。此对象通过内置名称 None 访问。在许多情况下它被用来表示空值,例如未显式指明返回值的函数将返回 None。它的逻辑值为假。
NotImplemented此类型只有一种取值。是一个具有此值的单独对象。此对象通过内置名称 NotImplemented 访问。数值方法和丰富比较方法如未实现指定运算符表示的运算则应返回此值。(解释器会根据指定运算符继续尝试反向运算或其他回退操作)。它的逻辑值为真。
Ellipsis此类型只有一种取值。是一个具有此值的单独对象。此对象通过字面值 ... 或内置名称 Ellipsis 访问。它的逻辑值为真。
此类对象由数字字面值创建,并会被作为算术运算符和算术内置函数的返回结果。数字对象是不可变的;一旦创建其值就不再改变。Python 中的数字当然非常类似数学中的数字,但也受限于计算机中的数字表示方法。
Python 区分整型数、浮点型数和复数:
此类对象表示数学中整数集合的成员 (包括正数和负数)。
整型数可细分为两种类型:
整型 (int)
此类对象表示任意大小的数字,仅受限于可用的内存 (包括虚拟内存)。在变换和掩码运算中会以二进制表示,负数会以 2 的补码表示,看起来像是符号位向左延伸补满空位。
布尔型 (bool)此类对象表示逻辑值 False 和 True。代表 False 和 True 值的两个对象是唯二的布尔对象。布尔类型是整型的子类型,两个布尔值在各种场合的行为分别类似于数值 0 和 1,例外情况只有在转换为字符串时分别返回字符串 "False" 或 "True"。
整型数表示规则的目的是在涉及负整型数的变换和掩码运算时提供最为合理的解释。
此类对象表示机器级的双精度浮点数。其所接受的取值范围和溢出处理将受制于底层的机器架构 (以及 C 或 Java 实现)。Python 不支持单精度浮点数;支持后者通常的理由是节省处理器和内存消耗,但这点节省相对于在 Python 中使用对象的开销来说太过微不足道,因此没有理由包含两种浮点数而令该语言变得复杂。
此类对象以一对机器级的双精度浮点数来表示复数值。有关浮点数的附带规则对其同样有效。一个复数值 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。
序列可根据其可变性来加以区分:
不可变序列不可变序列类型的对象一旦创建就不能再改变。(如果对象包含对其他对象的引用,其中的可变对象就是可以改变的;但是,一个不可变对象所直接引用的对象集是不能改变的。)
以下类型属于不可变对象:
字串 (String)字符串是由 Unicode 码位值组成的序列。范围在 U+0000 - U+10FFFF 之内的所有码位值都可在字符串中使用。Python 没有 char 类型;而是将字符串中的每个码位表示为一个长度为 1 的字符串对象。内置函数 ord() 可将一个码位由字符串形式转换成一个范围在 0 - 10FFFF 之内的整型数;chr() 可将一个范围在 0 - 10FFFF 之内的整型数转换为长度为 1 的对应字符串对象。str.encode() 可以使用指定的文本编码将 str 转换为 bytes,而 bytes.decode() 则可以实现反向的解码。
元组一个元组中的条目可以是任意 Python 对象。包含两个或以上条目的元组由逗号分隔的表达式构成。只有一个条目的元组 (『单项元组』) 可通过在表达式后加一个逗号来构成 (一个表达式本身不能创建为元组,因为圆括号要用来设置表达式分组)。一个空元组可通过一对内容为空的圆括号创建。
字节串字节串对象是不可变的数组。其中每个条目都是一个 8 位字节,以取值范围 0 <= x < 256 的整型数表示。字节串字面值 (例如 b'abc') 和内置的 bytes() 构造器可被用来创建字节串对象。字节串对象还可以通过 decode() 方法解码为字符串。
可变序列可变序列在被创建后仍可被改变。下标和切片标注可被用作赋值和 del (删除) 语句的目标。
目前有两种内生可变序列类型:
List(串列)列表中的条目可以是任意 Python 对象。列表由用方括号括起并由逗号分隔的多个表达式构成。(注意创建长度为 0 或 1 的列表无需使用特殊规则。)
字节数组字节数组对象属于可变数组。可以通过内置的 bytearray() 构造器来创建。除了是可变的 (因而也是不可哈希的),在其他方面字节数组提供的接口和功能都于不可变的 bytes 对象一致。
扩展模块 array 提供了一个额外的可变序列类型示例,collections 模块也是如此。
集合类型此类对象表示由不重复且不可变对象组成的无序且有限的集合。因此它们不能通过下标来索引。但是它们可被迭代,也可用内置函数 len() 返回集合中的条目数。集合常见的用处是快速成员检测,去除序列中的重复项,以及进行交、并、差和对称差等数学运算。
对于集合元素所采用的不可变规则与字典的键相同。注意数字类型遵循正常的数字比较规则: 如果两个数字相等 (例如 1 和 1.0),则同一集合中只能包含其中一个。
目前有两种内生集合类型:
集合此类对象表示可变集合。它们可通过内置的 set() 构造器创建,并且创建之后可以通过方法进行修改,例如 add()。
冻结集合此类对象表示不可变集合。它们可通过内置的 frozenset() 构造器创建。由于 frozenset 对象不可变且 hashable,它可以被用作另一个集合的元素或是字典的键。
映射此类对象表示由任意索引集合所索引的对象的集合。通过下标 a[k] 可在映射 a 中选择索引为 k 的条目;这可以在表达式中使用,也可作为赋值或 del 语句的目标。内置函数 len() 可返回一个映射中的条目数。
目前只有一种内生映射类型:
字典此类对象表示由几乎任意值作为索引的有限个对象的集合。不可作为键的值类型只有包含列表或字典或其他可变类型,通过值而非对象编号进行比较的值,其原因在于高效的字典实现需要使用键的哈希值以保持一致性。用作键的数字类型遵循正常的数字比较规则: 如果两个数字相等 (例如 1 和 1.0) 则它们均可来用来索引同一个字典条目。
字典是可变的;它们可通过 {...} 标注来创建 (参见 字典显示 小节)。
可调用类型此类型可以被应用于函数调用操作 (参见 调用 小节):
用户定义函数用户定义函数对象可通过函数定义来创建 (参见 函数定义 小节)。它被调用时应附带一个参数列表,其中包含的条目应与函数所定义的形参列表一致。
特殊属性:
属性
含义
__doc__
The function’s documentation
string, or None if
unavailable; not inherited by
subclasses
可写
The function’s name
可写
__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__
对存放该函数中全局变量的字典的引用 — 函数所属模块的全局命名空间。
只读
命名空间支持的函数属性。
可写
__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’s iterator.__next__()
method will cause the function to execute until it provides a value
using the yield statement. When the function executes a
return statement or falls off the end, a StopIteration
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 语句。详情可参见 协程对象 一节。
异步生成器函数使用 async def 来定义并包含 yield 语句的函数或方法就被称为 异步生成器函数。这样的函数在被调用时会返回一个异步迭代器对象,该对象可在 async for 语句中用来执行函数体。
调用异步迭代器的 aiterator.__anext__() 方法将会返回一个 awaitable,此对象会在被等待时执行直到使用 yield 表达式输出一个值。当函数执行时到空的 return 语句或是最后一条语句时,将会引发 StopAsyncIteration 异常,异步迭代器也会到达要输出的值集合的末尾。
内置函数内置函数对象是对于 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 (see import), or by calling
functions such as importlib.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 to
m.__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。
预定义的 (可写) 属性: __name__ 为模块的名称; __doc__ 为模块的文档字符串,如果没有则为 None; __annotations__ (可选) 为一个包含 变量标注 的字典,它是在模块体执行时获取的; __file__ 是模块对应的被加载文件的路径名,如果它是加载自一个文件的话。某些类型的模块可能没有 __file__ 属性,例如 C 模块是静态链接到解释器内部的; 对于从一个共享库动态加载的扩展模块来说该属性为该共享库文件的路径名。
特殊的只读属性: __dict__ 为以字典对象表示的模块命名空间。
CPython implementation detail: 由于 CPython 清理模块字典的设定,当模块离开作用域时模块字典将会被清理,即使该字典还有活动的引用。想避免此问题,可复制该字典或保持模块状态以直接使用其字典。
自定义类自定义类这种类型一般通过类定义来创建 (参见 类定义 一节)。每个类都有通过一个字典对象实现的独立命名空间。类属性引用会被转化为在此字典中查找,例如 C.x 会被转化为 C.__dict__["x"] (不过也存在一些钩子对象以允许其他定位属性的方式)。当未在其中发现某个属性名称时,会继续在基类中查找。这种基类查找使用 C3 方法解析顺序,即使存在 『钻石形』 继承结构即有多条继承路径连到一个共同祖先也能保持正确的行为。有关 Python 使用的 C3 MRO 的详情可查看配合 2.3 版发布的文档 https://www.python.org/download/releases/2.3/mro/.
当一个类属性引用 (假设类名为 C) 会产生一个类方法对象时,它将转化为一个 __self__ 属性为 C 的实例方法对象。当其会产生一个静态方法对象时,它将转化为该静态方法对象所封装的对象。从类的 __dict__ 所包含内容以外获取属性的其他方式请参看 实现描述器 一节。
类属性赋值会更新类的字典,但不会更新基类的字典。
类对象可被调用 (见上文) 以产生一个类实例 (见下文)。
特殊属性: __name__ 为类的名称; __module__ 为类所在模块的名称; __dict__ 为包含类命名空间的字典; __bases__ 为包含基类的元组,按其在基类列表中的出现顺序排列; __doc__ 为类的文档字符串,如果没有则为 None; __annotations__ (可选) 为一个包含 变量标注 的字典,它是在类体执行时获取的。
类实例类实例可通过调用类对象来创建 (见上文)。每个类实例都有通过一个字典对象实现的独立命名空间,属性引用会首先在此字典中查找。当未在其中发现某个属性,而实例对应的类中有该属性时,会继续在类属性中查找。如果找到的类属性为一个用户定义函数对象,它会被转化为实例方法对象,其 __self__ 属性即该实例。静态方法和类方法对象也会被转化;参见上文 「Classes」 一节。要了解其他通过类实例来获取相应类属性的方式可参见 实现描述器 一节,这样得到的属性可能与实际存放于类的 __dict__ 中的对象不同。如果未找到类属性,而对象对应的类具有 __getattr__() 方法,则会调用该方法来满足查找要求。
属性赋值和删除会更新实例的字典,但不会更新对应类的字典。如果类具有 __setattr__() 或 __delattr__() 方法,则将调用方法而不再直接更新实例的字典。
如果类实例具有某些特殊名称的方法,就可以伪装为数字、序列或映射。参见 特殊方法名称 一节。
特殊属性: __dict__ 为属性字典; __class__ 为实例对应的类。
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 not None, 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
as sys.last_traceback.
Special read-only attributes: tb_next is the next level in the stack
trace (towards the frame where the exception occurred), or None 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 a try 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() 构造器来创建。