Python 标准库非常庞大，所提供的组件涉及范围十分广泛，正如以下内容目录所显示的。这个库包含了多个内置模块 (以 C 编写)，Python 程序员必须依靠它们来实现系统级功能，例如文件 I/O，此外还有大量以 Python 编写的模块，提供了日常编程中许多问题的标准解决方案。其中有些模块经过专门设计，通过将特定平台功能抽象化为平台中立的 API 来鼓励和加强 Python 程序的可移植性。

Windows 版本的 Python 安装程序通常包含整个标准库，往往还包含许多额外组件。对于类 Unix 操作系统，Python 通常会分成一系列的软件包，因此可能需要使用操作系统所提供的包管理工具来获取部分或全部可选组件。

在这个标准库以外还存在成千上万并且不断增加的其他组件 (从单独的程序、模块、软件包直到完整的应用开发框架)，访问?Python 包索引?即可获取这些第三方包。

abs(x)

返回一个数的绝对值。参数可以是整数、浮点数或任何实现了?__abs__()?的对象。如果参数是一个复数，则返回它的模。

aiter(async_iterable)

返回?asynchronous iterable?的?asynchronous iterator?。相当于调用?x.__aiter__()。

注意：与?iter()?不同，aiter()?没有两个参数的版本。

3.10 新版功能.

all(iterable)

如果?iterable?的所有元素均为真值（或可迭代对象为空）则返回?True?。等价于：
def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

awaitable?anext(async_iterator[,?default])

当进入 await 状态时，从给定?asynchronous iterator?返回下一数据项，迭代完毕则返回?default。

这是内置函数?next()?的异步版本，类似于：

调用?async_iterator?的?__anext__()?方法，返回一个?awaitable。等待返回迭代器的下一个值。若有给出?default，则在迭代完毕后会返回给出的值，否则会触发?StopAsyncIteration。

3.10 新版功能.

any(iterable)

如果?iterable?的任一元素为真值则返回?True。如果可迭代对象为空，返回?False。等价于:
def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

ascii(object)

与?repr()?类似，返回一个字符串，表示对象的可打印形式，但在?repr()?返回的字符串中，非 ASCII 字符会用?\x、\u?和?\U?进行转义。生成的字符串类似于 Python 2 中?repr()?的返回结果。

bin(x)

将整数转变为以“0b”前缀的二进制字符串。结果是一个合法的 Python 表达式。如果?x?不是 Python 的?int?对象，它必须定义?__index__()?方法，以便返回整数值。下面是一些例子：

>>>
>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'
若要控制是否显示前缀“0b”，可以采用以下两种方案：

>>>
>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')
另见?format()?获取更多信息。

class?bool([x])

返回布尔值，True?或?False。x?用标准的?真值测试过程?进行转换。如果?x?为 False 或省略，则返回?False；否则返回?True。?bool?类是?int?的子类（见?数字类型 --- int, float, complex?）。它不能再被继承。它唯一的实例就是?False?和?True?（参阅?布尔值?）。

在 3.7 版更改:?x?现在只能作为位置参数。

breakpoint(*args,?**kws)

此函数会在调用时将你陷入调试器中。具体来说，它调用?sys.breakpointhook()?，直接传递?args?和?kws?。默认情况下，?sys.breakpointhook()?调用?pdb.set_trace()?且没有参数。在这种情况下，它纯粹是一个便利函数，因此您不必显式导入?pdb?且键入尽可能少的代码即可进入调试器。但是，?sys.breakpointhook()?可以设置为其他一些函数并被?breakpoint()?自动调用，以允许进入你想用的调试器。

引发一个?审计事件?builtins.breakpoint?并附带参数?breakpointhook。

3.7 新版功能.

class?bytearray([source[,?encoding[,?errors]]])

返回一个新的 bytes 数组。?bytearray?类是一个可变序列，包含范围为 0 <= x < 256 的整数。它有可变序列大部分常见的方法，见?可变序列类型?的描述；同时有?bytes?类型的大部分方法，参见?bytes 和 bytearray 操作。

可选形参?source?可以用不同的方式来初始化数组：

如果是一个?string，您必须提供?encoding?参数（errors?参数仍是可选的）；bytearray()?会使用?str.encode()?方法来将 string 转变成 bytes。

如果是一个?integer，会初始化大小为该数字的数组，并使用 null 字节填充。

如果是一个遵循?缓冲区接口?的对象，该对象的只读缓冲区将被用来初始化字节数组。

如果是一个?iterable?可迭代对象，它的元素的范围必须是?0?<=?x?<?256?的整数，它会被用作数组的初始内容。

如果没有实参，则创建大小为 0 的数组。

另见?二进制序列类型 --- bytes, bytearray, memoryview?和?bytearray 对象。

class?bytes([source[,?encoding[,?errors]]])

返回一个新的“bytes”对象，这是一个不可变序列，包含范围为?0?<=?x?<?256?的整数。bytes?是?bytearray?的不可变版本——带有同样不改变序列的方法，支持同样的索引、切片操作。

因此，构造函数的实参和?bytearray()?相同。

字节对象还可以用字面值创建，参见?字符串与字节串字面值。

另见?二进制序列类型 --- bytes, bytearray, memoryview，bytes 对象?和?bytes 和 bytearray 操作。

callable(object)

如果参数?object?是可调用的就返回?True，否则返回?False。如果返回?True，调用仍可能失败，但如果返回?False，则调用?object?将肯定不会成功。请注意类是可调用的（调用类将返回一个新的实例）；如果实例所属的类有?__call__()?则它就是可调用的。

3.2 新版功能:?这个函数一开始在 Python 3.0 被移除了，但在 Python 3.2 被重新加入。

chr(i)

返回 Unicode 码位为整数?i?的字符的字符串格式。例如，chr(97)?返回字符串?'a'，chr(8364)?返回字符串?'€'。这是?ord()?的逆函数。

实参的合法范围是 0 到 1,114,111（16 进制表示是 0x10FFFF）。如果?i?超过这个范围，会触发?ValueError?异常。

@classmethod

把一个方法封装成类方法。

类方法隐含的第一个参数就是类，就像实例方法接收实例作为参数一样。要声明一个类方法，按惯例请使用以下方案：
class C:
    @classmethod
    def f(cls, arg1, arg2): ...
@classmethod?这样的形式称为函数的?decorator?-- 详情参阅?函数定义。

类方法的调用可以在类上进行 (例如?C.f()) 也可以在实例上进行 (例如?C().f())。其所属类以外的类实例会被忽略。如果类方法在其所属类的派生类上调用，则该派生类对象会被作为隐含的第一个参数被传入。

类方法与 C++ 或 Java 中的静态方法不同。如果你需要后者，请参阅本节中的?staticmethod()。有关类方法的更多信息，请参阅?标准类型层级结构。

在 3.9 版更改:?类方法现在可以包装其他?描述器?例如?property()。

在 3.10 版更改:?类方法现在继承了方法的属性（__module__、__name__、__qualname__、__doc__?和?__annotations__），并拥有一个新的``__wrapped__`` 属性。

在 3.11 版更改:?Class methods can no longer wrap other?descriptors?such as?property().

compile(source,?filename,?mode,?flags=0,?dont_inherit=False,?optimize=-?1)

将?source?编译成代码或 AST 对象。代码对象可以被?exec()?或?eval()?执行。source?可以是常规的字符串、字节字符串，或者 AST 对象。参见?ast?模块的文档了解如何使用 AST 对象。

filename?实参需要是代码读取的文件名；如果代码不需要从文件中读取，可以传入一些可辨识的值（经常会使用?'<string>'）。

mode?实参指定了编译代码必须用的模式。如果?source?是语句序列，可以是?'exec'；如果是单一表达式，可以是?'eval'；如果是单个交互式语句，可以是?'single'。（在最后一种情况下，如果表达式执行结果不是?None?将会被打印出来。）

可选参数?flags?和?dont_inherit?控制应当激活哪个?编译器选项?以及应当允许哪个?future 特性。如果两者都未提供 (或都为零) 则代码会应用与调用?compile()?的代码相同的旗标来编译。如果给出了?flags?参数而未给出?dont_inherit?(或者为零) 则会在无论如何都将被使用的旗标之外还会额外使用?flags?参数所指定的编译器选项和 future 语句。如果?dont_inherit?为非零整数，则只使用?flags?参数 -- 外围代码中的旗标 (future 特性和编译器选项) 会被忽略。

编译器选项和 future 语句是由比特位来指明的。比特位可以通过一起按位 OR 来指明多个选项。指明特定 future 特性所需的比特位可以在?__future__?模块的?_Feature?实例的?compiler_flag?属性中找到。?编译器旗标?可以在?ast?模块中查找带有?PyCF_?前缀的名称。

optimize?实参指定编译器的优化级别；默认值?-1?选择与解释器的?-O?选项相同的优化级别。显式级别为?0?（没有优化；__debug__?为真）、1?（断言被删除，?__debug__?为假）或?2?（文档字符串也被删除）。

如果编译的源码不合法，此函数会触发?SyntaxError?异常；如果源码包含 null 字节，则会触发?ValueError?异常。

如果您想分析 Python 代码的 AST 表示，请参阅?ast.parse()。

引发一个?审计事件?compile?附带参数?source,?filename。

备注

在?'single'?或?'eval'?模式编译多行代码字符串时，输入必须以至少一个换行符结尾。这使?code?模块更容易检测语句的完整性。

警告

在将足够大或者足够复杂的字符串编译成 AST 对象时，Python 解释器有可能因为 Python AST 编译器的栈深度限制而崩溃。

在 3.2 版更改:?Windows 和 Mac 的换行符均可使用。而且在?'exec'?模式下的输入不必再以换行符结尾了。另增加了?optimize?参数。

在 3.5 版更改:?之前?source?中包含 null 字节的话会触发?TypeError?异常。

3.8 新版功能:?ast.PyCF_ALLOW_TOP_LEVEL_AWAIT?现在可在旗标中传入以启用对最高层级?await,?async?for?和?async?with?的支持。

class?complex([real[,?imag]])

返回值为?real?+?imag*1j 的复数，或将字符串或数字转换为复数。如果第一个形参是字符串，则它被解释为一个复数，并且函数调用时必须没有第二个形参。第二个形参不能是字符串。每个实参都可以是任意的数值类型（包括复数）。如果省略了?imag，则默认值为零，构造函数会像?int?和?float?一样进行数值转换。如果两个实参都省略，则返回?0j。

对于一个普通 Python 对象?x，complex(x)?会委托给?x.__complex__()。如果?__complex__()?未定义则将回退至?__float__()。如果?__float__()?未定义则将回退至?__index__()。

备注

当从字符串转换时，字符串在?+?或?-?的周围必须不能有空格。例如?complex('1+2j')?是合法的，但?complex('1?+?2j')?会触发?ValueError?异常。

数字类型 --- int, float, complex?描述了复数类型。

在 3.6 版更改:?您可以使用下划线将代码文字中的数字进行分组。

在 3.8 版更改:?如果?__complex__()?和?__float__()?未定义则回退至?__index__()。

delattr(object,?name)

setattr()?相关的函数。实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。例如?delattr(x,?'foobar')?等价于?del?x.foobar?。

class?dict(**kwarg)

class?dict(mapping,?**kwarg)

class?dict(iterable,?**kwarg)

创建一个新的字典。dict?对象是一个字典类。参见?dict?和?映射类型 --- dict?了解这个类。

其他容器类型，请参见内置的?list、set?和?tuple?类，以及?collections?模块。

dir([object])

如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。

如果对象有一个名为?__dir__()?的方法，那么该方法将被调用，并且必须返回一个属性列表。这允许实现自定义?__getattr__()?或?__getattribute__()?函数的对象能够自定义?dir()?来报告它们的属性。

如果对象未提供?__dir__()?方法，该函数会尽量从对象的?__dict__?属性和其类型对象中收集信息。得到的列表不一定是完整，如果对象带有自定义?__getattr__()?方法时，结果可能不准确。

默认的?dir()?机制对不同类型的对象行为不同，它会试图返回最相关而不是最全的信息：

如果对象是模块对象，则列表包含模块的属性名称。

如果对象是类型或类对象，则列表包含它们的属性名称，并且递归查找所有基类的属性。

否则，列表包含对象的属性名称，它的类属性名称，并且递归查找它的类的所有基类的属性。

返回的列表按字母表排序。例如：

>>>
>>> import struct
>>> dir()   # show the names in the module namespace  
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module 
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']
备注

因为?dir()?主要是为了便于在交互式时使用，所以它会试图返回人们感兴趣的名字集合，而不是试图保证结果的严格性或一致性，它具体的行为也可能在不同版本之间改变。例如，当实参是一个类时，metaclass 的属性不包含在结果列表中。

divmod(a,?b)

以两个（非复数）数字为参数，在作整数除法时，返回商和余数。若操作数为混合类型，则适用二进制算术运算符的规则。对于整数而言，结果与?(a?//?b,?a?%?b)?相同。对于浮点数则结果为``(q, a % b)``，其中?q?通常为?math.floor(a?/?b)，但可能比它小 1。在任何情况下，q?*?b?+?a?%?b?都非常接近?a，如果?a?%?b?非零，则结果符号与?b?相同，并且?0?<=?abs(a?%?b)?<?abs(b)。

enumerate(iterable,?start=0)

返回一个枚举对象。iterable?必须是一个序列，或?iterator，或其他支持迭代的对象。?enumerate()?返回的迭代器的?__next__()?方法返回一个元组，里面包含一个计数值（从?start?开始，默认为 0）和通过迭代?iterable?获得的值。

>>>
>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
等价于:
def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

eval(expression[,?globals[,?locals]])

实参是一个字符串，以及可选的 globals 和 locals。globals?实参必须是一个字典。locals?可以是任何映射对象。

表达式解析参数?expression?并作为 Python 表达式进行求值（从技术上说是一个条件列表），采用?globals?和?locals?字典作为全局和局部命名空间。如果存在?globals?字典，并且不包含?__builtins__?键的值，则在解析?expression?之前会插入以该字符串为键以对内置模块?builtins?的字典的引用为值的项。这样就可以在将?globals?传给?eval()?之前通过向其传入你自己的?__builtins__?字典来控制可供被执行代码可以使用哪些内置模块。如果?locals?字典被省略则它默认为?globals?字典。如果两个字典都被省略，则将使用调用?eval()?的环境中的?globals?和?locals?来执行该表达式。注意，eval()?无法访问闭包环境中的?嵌套作用域?(非局部变量)。

返回值就是表达式的求值结果。语法错误将作为异常被报告。例如：

>>>
>>> x = 1
>>> eval('x+1')
2
该函数还可用于执行任意代码对象（比如由?compile()?创建的对象）。这时传入的是代码对象，而非一个字符串了。如果代码对象已用参数为?mode?的?'exec'?进行了编译，那么?eval()?的返回值将为?None。

提示：?exec()?函数支持语句的动态执行。?globals()?和?locals()?函数分别返回当前的全局和本地字典，可供传给?eval()?或?exec()?使用。

如果给出的源数据是个字符串，那么其前后的空格和制表符将被剔除。

另外可以参阅?ast.literal_eval()，该函数可以安全执行仅包含文字的表达式字符串。

引发一个?审计事件?exec?附带参数?code_object。

exec(object,?[globals,?[locals,?]]*,?closure=None)

这个函数支持动态执行 Python 代码。?object?必须是字符串或者代码对象。如果是字符串，那么该字符串将被解析为一系列 Python 语句并执行（除非发生语法错误）。?1?如果是代码对象，它将被直接执行。在任何情况下，被执行的代码都应当是有效的文件输入（见参考手册中的?文件输入?一节）。请注意即使在传递给?exec()?函数的代码的上下文中，nonlocal,?yield?和?return?语句也不能在函数定义以外使用。该函数的返回值是?None。

无论在什么情况下，如果省略了可选部分，代码将运行于当前作用域中。如果只提供了?globals，则必须为字典对象（而不能是字典的子类），同时用于存放全局变量和局部变量。如果提供了?globals?和?locals，则将分别用于全局变量和局部变量。locals?可以是任意字典映射对象。请记住，在模块级别，globals 和 locals 是同一个字典。如果 exec 获得两个独立的对象作为?globals?和?locals，代码执行起来就像嵌入到某个类定义中一样。

如果?globals?字典不包含?__builtins__?键值，则将为该键插入对内建?builtins?模块字典的引用。因此，在将执行的代码传递给?exec()?之前，可以通过将自己的?__builtins__?字典插入到?globals?中来控制可以使用哪些内置代码。

The?closure?argument specifies a closure--a tuple of cellvars. It's only valid when the?object?is a code object containing free variables. The length of the tuple must exactly match the number of free variables referenced by the code object.

引发一个?审计事件?exec?附带参数?code_object。

备注

内置?globals()?和?locals()?函数各自返回当前的全局和本地字典，因此可以将它们传递给?exec()?的第二个和第三个实参。

备注

默认情况下，locals?的行为如下面?locals()?函数描述的一样：不要试图改变默认的?locals?字典。如果您需要在?exec()?函数返回时查看代码对?locals?的影响，请明确地传递?locals?字典。

在 3.11 版更改:?Added the?closure?parameter.

filter(function,?iterable)

用?iterable?中函数?function?返回真的那些元素，构建一个新的迭代器。iterable?可以是一个序列，一个支持迭代的容器，或一个迭代器。如果?function?是?None?，则会假设它是一个身份函数，即?iterable?中所有返回假的元素会被移除。

请注意，?filter(function,?iterable)?相当于一个生成器表达式，当 function 不是?None?的时候为?(item?for?item?in?iterable?if?function(item))；function 是?None?的时候为?(item?for?item?in?iterable?if?item)?。

请参阅?itertools.filterfalse()?了解，只有?function?返回 false 时才选取?iterable?中元素的补充函数。

class?float([x])

返回从数字或字符串?x?生成的浮点数。

如果参数是个字符串，则应包含一个十进制数字，前面可选带上符号，也可选前后带有空白符。符号可以是``'+'`` 或?'-'；'+'?符号对值没有影响。参数也可以是一个代表 NaN（非数字）或正负无穷大的字符串。更确切地说，在去除前导和尾部的空白符后，输入参数必须符合以下语法：
sign           ::=  "+" | "-"
infinity       ::=  "Infinity" | "inf"
nan            ::=  "nan"
numeric_value  ::=
floatnumber
 | infinity | nan
numeric_string ::=  [sign] numeric_value
这里的?floatnumber?是指 Python 的浮点数格式，在?浮点数字面值?中有介绍。大小写没有关系，所以“inf”、“Inf”、“INFINITY”、“iNfINity”都可接受为正无穷的拼写形式。

另一方面，如果实参是整数或浮点数，则返回具有相同值（在 Python 浮点精度范围内）的浮点数。如果实参在 Python 浮点精度范围外，则会触发?OverflowError。

对于一个普通 Python 对象?x，float(x)?会委托给?x.__float__()。如果?__float__()?未定义则将回退至?__index__()。

如果没有实参，则返回?0.0?。

示例:

>>>
>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf
数字类型 --- int, float, complex?描述了浮点类型。

在 3.6 版更改:?您可以使用下划线将代码文字中的数字进行分组。

在 3.7 版更改:?x?现在只能作为位置参数。

在 3.8 版更改:?如果?__float__()?未定义则回退至?__index__()。

format(value[,?format_spec])

将?value?转换为“格式化后”的形式，格式由?format_spec?进行控制。format_spec?的解释方式取决于?value?参数的类型；但大多数内置类型使用一种标准的格式化语法：?格式规格迷你语言。

默认的?format_spec?是一个空字符串，它通常给出与调用?str(value)?相同的结果。

调用?format(value,?format_spec)?会转换成?type(value).__format__(value,?format_spec)?，所以实例字典中的?__format__()?方法将不会调用。如果方法搜索回退到?object?类但?format_spec?不为空，或者如果?format_spec?或返回值不是字符串，则会触发?TypeError?异常。

在 3.4 版更改:?当?format_spec?不是空字符串时，?object().__format__(format_spec)?会触发?TypeError。

class?frozenset([iterable])

返回一个新的?frozenset?对象，它包含可选参数?iterable?中的元素。?frozenset?是一个内置的类。有关此类的文档，请参阅?frozenset?和?集合类型 --- set, frozenset。

请参阅内建的?set、list、tuple?和?dict?类，以及?collections?模块来了解其它的容器。

getattr(object,?name[,?default])

返回对象命名属性的值。name?必须是字符串。如果该字符串是对象的属性之一，则返回该属性的值。例如，?getattr(x,?'foobar')?等同于?x.foobar。如果指定的属性不存在，且提供了?default?值，则返回它，否则触发?AttributeError。

备注

由于?私有名称混合?发生在编译时，因此必须手动混合私有属性（以两个下划线打头的属性）名称以使使用?getattr()?来提取它。

globals()

返回实现当前模块命名空间的字典。对于函数内的代码，这是在定义函数时设置的，无论函数在哪里被调用都保持不变。

hasattr(object,?name)

该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称，则返回?True，否则返回?False。（此功能是通过调用?getattr(object,?name)?看是否有?AttributeError?异常来实现的。）

hash(object)

返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0）。

备注

如果对象实现了自己的?__hash__()?方法，请注意，hash()?根据机器的字长来截断返回值。另请参阅?__hash__()。

help([object])

启动内置的帮助系统（此函数主要在交互式中使用）。如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。

请注意，如果在调用?help()?时，目标函数的形参列表中存在斜杠（/），则意味着斜杠之前的参数只能是位置参数。详情请参阅?有关仅限位置形参的 FAQ 条目。

该函数通过?site?模块加入到内置命名空间。

在 3.4 版更改:?pydoc?和?inspect?的变更使得可调用对象的签名信息更加全面和一致。

hex(x)

将整数转换为以“0x”为前缀的小写十六进制字符串。如果?x?不是 Python?int?对象，则必须定义返回整数的?__index__()?方法。一些例子：

>>>
>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
如果要将整数转换为大写或小写的十六进制字符串，并可选择有无“0x”前缀，则可以使用如下方法：

>>>
>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')
另见?format()?获取更多信息。

另请参阅?int()?将十六进制字符串转换为以 16 为基数的整数。

备注

如果要获取浮点数的十六进制字符串形式，请使用?float.hex()?方法。

id(object)

返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的?id()?值。

CPython implementation detail:?This is the address of the object in memory.

引发一个?审计事件?builtins.id，附带参数?id。

input([prompt])

如果存在?prompt?实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。当读取到 EOF 时，则触发?EOFError。例如:

>>>
>>> s = input('--> ')  
--> Monty Python's Flying Circus
>>> s  
"Monty Python's Flying Circus"
如果加载了?readline?模块，input()?将使用它来提供复杂的行编辑和历史记录功能。

引发一个?审计事件?builtins.input?附带参数?prompt。

在成功读取输入之后引发一个?审计事件?builtins.input/result?附带结果。

class?int([x])

class?int(x,?base=10)

返回一个基于数字或字符串?x?构造的整数对象，或者在未给出参数时返回?0。如果?x?定义了?__int__()，int(x)?将返回?x.__int__()。如果?x?定义了?__index__()，它将返回?x.__index__()。如果?x?定义了?__trunc__()，它将返回?x.__trunc__()。对于浮点数，它将向零舍入。

如果?x?不是数字，或者有?base?参数，x?必须是字符串、bytes、表示进制为?base?的?整数字面值?的?bytearray?实例。该文字前可以有?+?或?-?（中间不能有空格），前后可以有空格。一个进制为 n 的数字包含 0 到 n-1 的数，其中?a?到?z?（或?A?到?Z?）表示 10 到 35。默认的?base?为 10 ，允许的进制有 0、2-36。2、8、16 进制的数字可以在代码中用?0b/0B?、?0o/0O?、?0x/0X?前缀来表示。进制为 0 将安照代码的字面量来精确解释，最后的结果会是 2、8、10、16 进制中的一个。所以?int('010',?0)?是非法的，但?int('010')?和?int('010',?8)?是合法的。

整数类型定义请参阅?数字类型 --- int, float, complex?。

在 3.4 版更改:?如果?base?不是?int?的实例，但?base?对象有?base.__index__?方法，则会调用该方法来获取进制数。以前的版本使用?base.__int__?而不是?base.__index__。

在 3.6 版更改:?您可以使用下划线将代码文字中的数字进行分组。

在 3.7 版更改:?x?现在只能作为位置参数。

在 3.8 版更改:?如果?__int__()?未定义则回退至?__index__()。

在 3.11 版更改:?The delegation to?__trunc__()?is deprecated.

isinstance(object,?classinfo)

Return?True?if the?object?argument is an instance of the?classinfo?argument, or of a (direct, indirect, or?virtual) subclass thereof. If?object?is not an object of the given type, the function always returns?False. If?classinfo?is a tuple of type objects (or recursively, other such tuples) or a?union 类型?of multiple types, return?True?if?object?is an instance of any of the types. If?classinfo?is not a type or tuple of types and such tuples, a?TypeError?exception is raised.?TypeError?may not be raised for an invalid type if an earlier check succeeds.

在 3.10 版更改:?classinfo?可以是一个?union 类型。

issubclass(class,?classinfo)

如果?class?是?classinfo?的子类（直接、间接或?虚的?），则返回?True。类将视为自己的子类。classinfo?可为类对象的元组（或递归地，其他这样的元组）或?union 类型，这时如果?class?是?classinfo?中任何条目的子类，则返回?True?。任何其他情况都会触发?TypeError?异常。

在 3.10 版更改:?classinfo?可以是一个?union 类型。

iter(object[,?sentinel])

返回一个?iterator?对象。根据是否存在第二个实参，第一个实参的解释是非常不同的。如果没有第二个实参，object?必须是支持?iterable?协议（有?__iter__()?方法）的集合对象，或必须支持序列协议（有?__getitem__()?方法，且数字参数从?0?开始）。如果它不支持这些协议，会触发?TypeError。如果有第二个实参?sentinel，那么?object?必须是可调用的对象。这种情况下生成的迭代器，每次迭代调用它的?__next__()?方法时都会不带实参地调用?object；如果返回的结果是?sentinel?则触发?StopIteration，否则返回调用结果。

另请参阅?迭代器类型。

适合?iter()?的第二种形式的应用之一是构建块读取器。例如，从二进制数据库文件中读取固定宽度的块，直至到达文件的末尾:
from functools import partial
with open('mydata.db', 'rb') as f:
    for block in iter(partial(f.read, 64), b''):
        process_block(block)

len(s)

返回对象的长度（元素个数）。实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）。

CPython implementation detail:?len?对于大于?sys.maxsize?的长度如?range(2?**?100)?会引发?OverflowError。

class?list([iterable])

虽然被称为函数，list?实际上是一种可变序列类型，详情请参阅?列表?和?序列类型 --- list, tuple, range。

locals()

更新并返回表示当前本地符号表的字典。在函数代码块但不是类代码块中调用?locals()?时将返回自由变量。请注意在模块层级上，locals()?和?globals()?是同一个字典。

备注

不要更改此字典的内容；更改不会影响解释器使用的局部变量或自由变量的值。

map(function,?iterable,?...)

返回一个将?function?应用于?iterable?中每一项并输出其结果的迭代器。如果传入了额外的?iterable?参数，function?必须接受相同个数的实参并被应用于从所有可迭代对象中并行获取的项。当有多个可迭代对象时，最短的可迭代对象耗尽则整个迭代就将结束。对于函数的输入已经是参数元组的情况，请参阅?itertools.starmap()。

max(iterable,?*[,?key,?default])

max(arg1,?arg2,?*args[,?key])

返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。

如果只提供了一个位置参数，它必须是非空?iterable，返回可迭代对象中最大的元素；如果提供了两个及以上的位置参数，则返回最大的位置参数。

有两个可选只能用关键字的实参。key?实参指定排序函数用的参数，如传给?list.sort()?的。default?实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给?default?，则会触发?ValueError。

如果有多个最大元素，则此函数将返回第一个找到的。这和其他稳定排序工具如?sorted(iterable,?key=keyfunc,?reverse=True)[0]?和?heapq.nlargest(1,?iterable,?key=keyfunc)?保持一致。

3.4 新版功能:?keyword-only 实参?default?。

在 3.8 版更改:?key?可以为?None。

class?memoryview(object)

返回由给定实参创建的“内存视图”对象。有关详细信息，请参阅?内存视图。

min(iterable,?*[,?key,?default])

min(arg1,?arg2,?*args[,?key])

返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。

如果只提供了一个位置参数，它必须是?iterable，返回可迭代对象中最小的元素；如果提供了两个及以上的位置参数，则返回最小的位置参数。

有两个可选只能用关键字的实参。key?实参指定排序函数用的参数，如传给?list.sort()?的。default?实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给?default?，则会触发?ValueError。

如果有多个最小元素，则此函数将返回第一个找到的。这和其他稳定排序工具如?sorted(iterable,?key=keyfunc)[0]?和?heapq.nsmallest(1,?iterable,?key=keyfunc)?保持一致。

3.4 新版功能:?keyword-only 实参?default?。

在 3.8 版更改:?key?可以为?None。

next(iterator[,?default])

通过调用?iterator?的?__next__()?方法获取下一个元素。如果迭代器耗尽，则返回给定的?default，如果没有默认值则触发?StopIteration。

class?object

返回一个不带特征的新对象。object?是所有类的基类。它带有所有 Python 类实例均通用的方法。本函数不接受任何参数。

备注

由于?object?没有?__dict__，因此无法将任意属性赋给?object?的实例。

oct(x)

将一个整数转变为一个前缀为“0o”的八进制字符串。结果是一个合法的 Python 表达式。如果?x?不是 Python 的?int?对象，那它需要定义?__index__()?方法返回一个整数。一些例子：

>>>
>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'
若要将整数转换为八进制字符串，并可选择是否带有“0o”前缀，可采用如下方法：

>>>
>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')
另见?format()?获取更多信息。

open(file,?mode='r',?buffering=-?1,?encoding=None,?errors=None,?newline=None,?closefd=True,?opener=None)

打开?file?并返回对应的?file object。如果该文件不能被打开，则引发?OSError。请参阅?读写文件?获取此函数的更多用法示例。

file?是一个?path-like object，表示将要打开的文件的路径（绝对路径或者相对当前工作目录的路径），也可以是要封装文件对应的整数类型文件描述符。（如果给出的是文件描述符，则当返回的 I/O 对象关闭时它也会关闭，除非将?closefd?设为?False?。）

mode?is an optional string that specifies the mode in which the file is opened. It defaults to?'r'?which means open for reading in text mode. Other common values are?'w'?for writing (truncating the file if it already exists),?'x'?for exclusive creation, and?'a'?for appending (which on?some?Unix systems, means that?all?writes append to the end of the file regardless of the current seek position). In text mode, if?encoding?is not specified the encoding used is platform-dependent:?locale.getencoding()?is called to get the current locale encoding. (For reading and writing raw bytes use binary mode and leave?encoding?unspecified.) The available modes are:

字符

含意

'r'

读取（默认）

'w'

写入，并先截断文件

'x'

排它性创建，如果文件已存在则失败

'a'

打开文件用于写入，如果文件存在则在末尾追加

'b'

二进制模式

't'

文本模式（默认）

'+'

打开用于更新（读取与写入）

默认模式为?'r'?（打开文件用于读取文本，与?'rt'?同义）。'w+'?和?'w+b'?模式将打开文件并清空内容。而?'r+'?和?'r+b'?模式将打开文件但不清空内容。

正如在?概述?中提到的，Python区分二进制和文本I/O。以二进制模式打开的文件（包括?mode?参数中的?'b'?）返回的内容为?bytes?对象，不进行任何解码。在文本模式下（默认情况下，或者在?mode?参数中包含?'t'?）时，文件内容返回为?str?，首先使用指定的?encoding?（如果给定）或者使用平台默认的的字节编码解码。

备注

Python不依赖于底层操作系统的文本文件概念;所有处理都由Python本身完成，因此与平台无关。

buffering?是一个可选的整数，用于设置缓冲策略。传入 0 来关闭缓冲（只允许在二进制模式下），传入 1 来选择行缓冲（只在文本模式下可用），传入一个整数 > 1 来表示固定大小的块缓冲区的字节大小。注意，这样指定缓冲区的大小适用于二进制缓冲的 I/O ，但?TextIOWrapper?（即用?mode='r+'?打开的文件）会有另一种缓冲。要禁用在?TextIOWrapper?缓冲，考虑使用?io.TextIOWrapper.reconfigure()?的?write_through?标志来。当没有给出?buffering?参数时，默认的缓冲策略工作如下。

二进制文件以固定大小的块进行缓冲；使用启发式方法选择缓冲区的大小，尝试确定底层设备的“块大小”或使用?io.DEFAULT_BUFFER_SIZE。在许多系统上，缓冲区的长度通常为4096或8192字节。

“交互式”文本文件（?isatty()?返回?True?的文件）使用行缓冲。其他文本文件使用上述策略用于二进制文件。

encoding?is the name of the encoding used to decode or encode the file. This should only be used in text mode. The default encoding is platform dependent (whatever?locale.getencoding()?returns), but any?text encoding?supported by Python can be used. See the?codecs?module for the list of supported encodings.

errors?是一个可选的字符串参数，用于指定如何处理编码和解码错误 - 这不能在二进制模式下使用。可以使用各种标准错误处理程序（列在?错误处理方案?），但是使用?codecs.register_error()?注册的任何错误处理名称也是有效的。标准名称包括:

如果存在编码错误，'strict'?会引发?ValueError?异常。默认值?None?具有相同的效果。

'ignore'?忽略错误。请注意，忽略编码错误可能会导致数据丢失。

'replace'?会将替换标记（例如?'?'?）插入有错误数据的地方。

'surrogateescape'?将把任何不正确的字节表示为 U+DC80 至 U+DCFF 范围内的下方替代码位。当在写入数据时使用?surrogateescape?错误处理句柄时这些替代码位会被转回到相同的字节。这适用于处理具有未知编码格式的文件。

只有在写入文件时才支持?'xmlcharrefreplace'。编码不支持的字符将替换为相应的XML字符引用?&#nnn;。

'backslashreplace'?用Python的反向转义序列替换格式错误的数据。

'namereplace'?（也只在编写时支持）用?\N{...}?转义序列替换不支持的字符。

newline?控制?universal newlines?模式如何生效（它仅适用于文本模式）。它可以是?None，''，'\n'，'\r'?和?'\r\n'。它的工作原理:

从流中读取输入时，如果?newline?为?None，则启用通用换行模式。输入中的行可以以?'\n'，'\r'?或?'\r\n'?结尾，这些行被翻译成?'\n'?在返回呼叫者之前。如果它是?''，则启用通用换行模式，但行结尾将返回给调用者未翻译。如果它具有任何其他合法值，则输入行仅由给定字符串终止，并且行结尾将返回给未调用的调用者。

将输出写入流时，如果?newline?为?None，则写入的任何?'\n'?字符都将转换为系统默认行分隔符?os.linesep。如果?newline?是?''?或?'\n'，则不进行翻译。如果?newline?是任何其他合法值，则写入的任何?'\n'?字符将被转换为给定的字符串。

如果?closefd?为?False?且给出的不是文件名而是文件描述符，那么当文件关闭时，底层文件描述符将保持打开状态。如果给出的是文件名，则?closefd?必须为?True?（默认值），否则将触发错误。

可以通过传递可调用的?opener?来使用自定义开启器。然后通过使用参数（?file，flags?）调用?opener?获得文件对象的基础文件描述符。?opener?必须返回一个打开的文件描述符（使用?os.open?as?opener?时与传递?None?的效果相同）。

新创建的文件是?不可继承的。

下面的示例使用?os.open()?函数的?dir_fd?的形参，从给定的目录中用相对路径打开文件:

>>>
>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor
open()?函数所返回的?file object?类型取决于所用模式。当使用?open()?以文本模式 ('w',?'r',?'wt',?'rt'?等) 打开文件时，它将返回?io.TextIOBase?(具体为?io.TextIOWrapper) 的一个子类。当使用缓冲以二进制模式打开文件时，返回的类是?io.BufferedIOBase?的一个子类。具体的类会有多种：在只读的二进制模式下，它将返回?io.BufferedReader；在写入二进制和追加二进制模式下，它将返回?io.BufferedWriter，而在读/写模式下，它将返回?io.BufferedRandom。当禁用缓冲时，则会返回原始流，即?io.RawIOBase?的一个子类?io.FileIO。

另请参阅文件操作模块，如?fileinput、io?（声明了?open()）、os、os.path、tempfile?和?shutil。

引发一个?审计事件?open?附带参数?file,?mode,?flags。

mode?与?flags?参数可以在原始调用的基础上被修改或传递。

在 3.3 版更改:

增加了?opener?形参。

增加了?'x'?模式。

过去触发的?IOError，现在是?OSError?的别名。

如果文件已存在但使用了排它性创建模式（?'x'?），现在会触发?FileExistsError。

在 3.4 版更改:

文件现在禁止继承。

在 3.5 版更改:

如果系统调用被中断，但信号处理程序没有触发异常，此函数现在会重试系统调用，而不是触发?InterruptedError?异常 (原因详见?PEP 475)。

增加了?'namereplace'?错误处理接口。

在 3.6 版更改:

增加对实现了?os.PathLike?对象的支持。

在 Windows 上，打开一个控制台缓冲区将返回?io.RawIOBase?的子类，而不是?io.FileIO。

在 3.11 版更改:?The?'U'?mode has been removed.

ord(c)

对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。例如?ord('a')?返回整数?97，?ord('€')?（欧元符号）返回?8364?。这是?chr()?的逆函数。

pow(base,?exp[,?mod])

返回?base?的?exp?次幂；如果?mod?存在，则返回?base?的?exp?次幂对?mod?取余（比?pow(base,?exp)?%?mod?更高效）。两参数形式?pow(base,?exp)?等价于乘方运算符:?base**exp。

参数必须为数值类型。对于混用的操作数类型，则适用二元算术运算符的类型强制转换规则。对于?int?操作数，结果具有与操作数相同的类型（转换后），除非第二个参数为负值；在这种情况下，所有参数将被转换为浮点数并输出浮点数结果。例如，pow(10,?2)?返回?100，但?pow(10,?-2)?返回?0.01。对于?int?或?float?类型的负基和一个非整数的指数，会产生一个复杂的结果。例如，?pow(-9,?0.5)?返回一个接近于?3j?的值。

对于?int?操作数?base?和?exp，如果给出?mod，则?mod?必须为整数类型并且?mod?必须不为零。如果给出?mod?并且?exp?为负值，则?base?必须相对于?mod?不可整除。在这种情况下，将会返回?pow(inv_base,?-exp,?mod)，其中?inv_base?为?base?的倒数对?mod?取余。

下面的例子是?38?的倒数对?97?取余:

>>>
>>> pow(38, -1, mod=97)
23
>>> 23 * 38 % 97 == 1
True
在 3.8 版更改:?对于?int?操作数，三参数形式的?pow?现在允许第二个参数为负值，即可以计算倒数的余数。

在 3.8 版更改:?允许关键字参数。之前只支持位置参数。

print(*objects,?sep='?',?end='\n',?file=sys.stdout,?flush=False)

将?objects?打印输出至?file?指定的文本流，以?sep?分隔并在末尾加上?end。?sep?、?end?、?file?和?flush?必须以关键字参数的形式给出。

所有非关键字参数都会被转换为字符串，就像是执行了?str()?一样，并会被写入到流，以?sep?且在末尾加上?end。?sep?和?end?都必须为字符串；它们也可以为?None，这意味着使用默认值。如果没有给出?objects，则?print()?将只写入?end。

file?参数必须是一个具有?write(string)?方法的对象；如果参数不存在或为?None，则将使用?sys.stdout。由于要打印的参数会被转换为文本字符串，因此?print()?不能用于二进制模式的文件对象。对于这些对象，应改用?file.write(...)。

输出是否缓存通常取决于?file，但如果?flush?关键字参数为 True，输出流会被强制刷新。

在 3.3 版更改:?增加了?flush?关键字参数。

class?property(fget=None,?fset=None,?fdel=None,?doc=None)

返回 property 属性。

fget?是获取属性值的函数。?fset?是用于设置属性值的函数。?fdel?是用于删除属性值的函数。并且?doc?为属性对象创建文档字符串。

一个典型的用法是定义一个托管属性?x:
class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")
如果?c?为?C?的实例，c.x?将调用 getter，c.x?=?value?将调用 setter，?del?c.x?将调用 deleter。

如果给出，doc?将成为该 property 属性的文档字符串。否则该 property 将拷贝?fget?的文档字符串（如果存在）。这令使用?property()?作为?decorator?来创建只读的特征属性可以很容易地实现:
class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage
以上?@property?装饰器会将?voltage()?方法转化为一个具有相同名称的只读属性的 "getter"，并将?voltage?的文档字符串设置为 "Get the current voltage."

特征属性对象具有?getter,?setter?以及?deleter?方法，它们可用作装饰器来创建该特征属性的副本，并将相应的访问函数设为所装饰的函数。这最好是用一个例子来解释:
class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x
上述代码与第一个例子完全等价。注意一定要给附加函数与原始的特征属性相同的名称 (在本例中为?x。)

返回的特征属性对象同样具有与构造器参数相对应的属性?fget,?fset?和?fdel。

在 3.5 版更改:?特征属性对象的文档字符串现在是可写的。

class?range(stop)

class?range(start,?stop[,?step])

虽然被称为函数，但?range?实际上是一个不可变的序列类型，参见在?range 对象?与?序列类型 --- list, tuple, range?中的文档说明。

repr(object)

返回对象的可打印形式字符串。对于很多类型而言，本函数试图返回的字符串，会与将对象传给?eval()?所生成的结果相同；不然，结果就是一个尖括号包裹的字符串，包含了对象类型名称及其附加信息，附加信息通常包括对象的名称和内存地址。通过定义?__repr__()?方法，类可以控制本函数将为实例返回的内容。

reversed(seq)

返回一个反向的?iterator。?seq?必须是一个具有?__reversed__()?方法的对象或者是支持该序列协议（具有从?0?开始的整数类型参数的?__len__()?方法和?__getitem__()?方法）。

round(number[,?ndigits])

返回?number?舍入到小数点后?ndigits?位精度的值。如果?ndigits?被省略或为?None，则返回最接近输入值的整数。

对于支持?round()?方法的内置类型，结果值会舍入至最接近的 10 的负?ndigits?次幂的倍数；如果与两个倍数同样接近，则选用偶数。因此，round(0.5)?和?round(-0.5)?均得出?0?而?round(1.5)?则为?2。ndigits?可为任意整数值（正数、零或负数）。如果省略了?ndigits?或为?None?，则返回值将为整数。否则返回值与?number?的类型相同。

对于一般的 Python 对象?number,?round?将委托给?number.__round__。

备注

对浮点数执行?round()?的行为可能会令人惊讶：例如，round(2.675,?2)?将给出?2.67?而不是期望的?2.68。这不算是程序错误：这一结果是由于大多数十进制小数实际上都不能以浮点数精确地表示。请参阅?浮点算术：争议和限制?了解更多信息。

class?set([iterable])

返回一个新的?set?对象，可以选择带有从?iterable?获取的元素。?set?是一个内置类型。请查看?set?和?集合类型 --- set, frozenset?获取关于这个类的文档。

有关其他容器请参看内置的?frozenset,?list,?tuple?和?dict?类，以及?collections?模块。

setattr(object,?name,?value)

本函数与?getattr()?相对应。其参数为一个对象、一个字符串和一个任意值。字符串可以为某现有属性的名称，或为新属性。只要对象允许，函数会将值赋给属性。如?setattr(x,?'foobar',?123)?等价于?x.foobar?=?123。

备注

由于?私有名称混合?发生在编译时，因此必须手动混合私有属性（以两个下划线打头的属性）名称以便使用?setattr()?来设置它。

class?slice(stop)

class?slice(start,?stop[,?step])

返回一个?slice?对象，代表由?range(start,?stop,?step)?指定索引集的切片。其中参数?start?和?step?的默认值为?None。切片对象具有只读数据属性?start?、stop?和?step，只是返回对应的参数值（或默认值）。这几个属性没有其他明确的功能；不过 NumPy 和其他第三方扩展会用到。在使用扩展索引语法时，也会生成切片对象。例如：?a[start:stop:step]?或?a[start:stop,?i]。另一种方案是返回迭代器对象，可参阅?itertools.islice()?。

sorted(iterable,?/,?*,?key=None,?reverse=False)

根据?iterable?中的项返回一个新的已排序列表。

具有两个可选参数，它们都必须指定为关键字参数。

key?指定带有单个参数的函数，用于从?iterable?的每个元素中提取用于比较的键 (例如?key=str.lower)。默认值为?None?(直接比较元素)。

reverse?为一个布尔值。如果设为?True，则每个列表元素将按反向顺序比较进行排序。

使用?functools.cmp_to_key()?可将老式的?cmp?函数转换为?key?函数。

内置的?sorted()?确保是稳定的。如果一个排序确保不会改变比较结果相等的元素的相对顺序就称其为稳定的 --- 这有利于进行多重排序（例如先按部门、再按薪级排序）。

排序算法只使用?<?在项目之间比较。虽然定义一个?__lt__()?方法就足以进行排序，但?PEP 8?建议实现所有六个?富比较?。这将有助于避免在与其他排序工具（如?max()?）使用相同的数据时出现错误，这些工具依赖于不同的底层方法。实现所有六个比较也有助于避免混合类型比较的混乱，因为混合类型比较可以调用反射到?__gt__()?的方法。

有关排序示例和简要排序教程，请参阅?排序指南?。

@staticmethod

将方法转换为静态方法。

静态方法不会接收隐式的第一个参数。要声明一个静态方法，请使用此语法
class C:
    @staticmethod
    def f(arg1, arg2, ...): ...
@staticmethod?这样的形式称为函数的?decorator?-- 详情参阅?函数定义。

静态方法既可以由类中调用（如?C.f()），也可以由实例中调用（如```C().f()``）。此外，还可以作为普通的函数进行调用（如``f()``）。

Python 的静态方法与 Java 或 C++ 类似。另请参阅?classmethod()?，可用于创建另一种类构造函数。

像所有装饰器一样，也可以像常规函数一样调用?staticmethod?，并对其结果执行某些操作。比如某些情况下需要从类主体引用函数并且您希望避免自动转换为实例方法。对于这些情况，请使用此语法:
def regular_function():
    ...

class C:
    method = staticmethod(regular_function)
想了解更多有关静态方法的信息，请参阅?标准类型层级结构?。

在 3.10 版更改:?静态方法继承了方法的多个属性（__module__、__name__、__qualname__、__doc__?和?__annotations__），还拥有一个新的``__wrapped__`` 属性，并且现在还可以作为普通函数进行调用。

class?str(object='')

class?str(object=b'',?encoding='utf-8',?errors='strict')

返回一个?str?版本的?object?。有关详细信息，请参阅?str()?。

str?是内置字符串?class?。更多关于字符串的信息查看?文本序列类型 --- str。

sum(iterable,?/,?start=0)

从?start?开始自左向右对?iterable?的项求和并返回总计值。?iterable?的项通常为数字，而 start 值则不允许为字符串。

对某些用例来说，存在?sum()?的更好替代。拼接字符串序列的更好更快方式是调用?''.join(sequence)。要以扩展精度对浮点值求和，请参阅?math.fsum()。要拼接一系列可迭代对象，请考虑使用?itertools.chain()。

在 3.8 版更改:?start?形参可用关键字参数形式来指定。

class?super([type[,?object-or-type]])

返回一个代理对象，它会将方法调用委托给?type?的父类或兄弟类。这对于访问已在类中被重载的继承方法很有用。

object-or-type?确定用于搜索的?method resolution order。搜索会从?type?之后的类开始。

举例来说，如果?object-or-type?的?__mro__?为?D?->?B?->?C?->?A?->?object?并且?type?的值为?B，则?super()?将会搜索?C?->?A?->?object。

object-or-type?的?__mro__?属性列出了?getattr()?和?super()?所共同使用的方法解析搜索顺序。该属性是动态的，可以在任何继承层级结构发生更新的时候被改变。

如果省略第二个参数，则返回的超类对象是未绑定的。如果第二个参数为一个对象，则?isinstance(obj,?type)?必须为真值。如果第二个参数为一个类型，则?issubclass(type2,?type)?必须为真值（这适用于类方法）。

super?有两个典型用例。在具有单继承的类层级结构中，super?可用来引用父类而不必显式地指定它们的名称，从而令代码更易维护。这种用法与其他编程语言中?super?的用法非常相似。

第二个用例是在动态执行环境中支持协作多重继承。此用例为 Python 所独有而不存在于静态编码语言或仅支持单继承的语言当中。这使用实现“菱形图”成为可能，即有多个基类实现相同的方法。好的设计强制要求这样的方法在每个情况下都具有相同的调用签名（因为调用顺序是在运行时确定的，也因为这个顺序要适应类层级结构的更改，还因为这个顺序可能包括在运行时之前未知的兄弟类）。

对于以上两个用例，典型的超类调用看起来是这样的:
class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)
除了方法查找之外，super()?也可用于属性查找。一个可能的应用场合是在上级或同级类中调用?描述器。

请注意?super()?是作为显式加点属性查找的绑定过程的一部分来实现的，例如?super().__getitem__(name)。它做到这一点是通过实现自己的?__getattribute__()?方法，这样就能以可预测的顺序搜索类，并且支持协作多重继承。对应地，super()?在像?super()[name]?这样使用语句或操作符进行隐式查找时则未被定义。

还要注意的是，除了零个参数的形式以外，super()?并不限于在方法内部使用。两个参数的形式明确指定参数并进行相应的引用。零个参数的形式仅适用于类定义内部，因为编译器需要填入必要的细节以正确地检索到被定义的类，还需要让普通方法访问当前实例。

对于有关如何使用?super()?来如何设计协作类的实用建议，请参阅?使用 super() 的指南。

class?tuple([iterable])

虽然被称为函数，但?tuple?实际上是一个不可变的序列类型，参见在?元组?与?序列类型 --- list, tuple, range?中的文档说明。

class?type(object)

class?type(name,?bases,?dict,?**kwds)

传入一个参数时，返回?object?的类型。返回值是一个 type 对象，通常与?object.__class__?所返回的对象相同。

推荐使用?isinstance()?内置函数来检测对象的类型，因为它会考虑子类的情况。

传入三个参数时，返回一个新的 type 对象。这在本质上是?class?语句的一种动态形式，name?字符串即类名并会成为?__name__?属性；bases?元组包含基类并会成为?__bases__?属性；如果为空则会添加所有类的终极基类?object。?dict?字典包含类主体的属性和方法定义；它在成为?__dict__?属性之前可能会被拷贝或包装。下面两条语句会创建相同的?type?对象:
>>>

>>> class X:
...     a = 1
...
>>> X = type('X', (), dict(a=1))
另请参阅?类型对象。

提供给三参数形式的关键字参数会被传递给适当的元类机制 (通常为?__init_subclass__())，相当于类定义中关键字 (除了?metaclass) 的行为方式。

另请参阅?自定义类创建。

在 3.6 版更改:?type?的子类如果未重载?type.__new__，将不再能使用一个参数的形式来获取对象的类型。

vars([object])

返回模块、类、实例或任何其它具有?__dict__?属性的对象的?__dict__?属性。

模块和实例这样的对象具有可更新的?__dict__?属性；但是，其它对象的?__dict__?属性可能会设为限制写入（例如，类会使用?types.MappingProxyType?来防止直接更新字典）。

不带参数时，vars()?的行为类似?locals()。请注意，locals 字典仅对于读取起作用，因为对 locals 字典的更新会被忽略。

如果指定了一个对象但它没有?__dict__?属性（例如，当它所属的类定义了?__slots__?属性时）则会引发?TypeError?异常。

zip(*iterables,?strict=False)

在多个迭代器上并行迭代，从每个迭代器返回一个数据项组成元组。

示例:

>>>
>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
...     print(item)
...
(1, 'sugar')
(2, 'spice')
(3, 'everything nice')
更正式的说法：?zip()?返回元组的迭代器，其中第?i?个元组包含的是每个参数迭代器的第?i?个元素。

不妨换一种方式认识?zip()?：它会把行变成列，把列变成行。这类似于?矩阵转置?。

zip()?是延迟执行的：直至迭代时才会对元素进行处理，比如?for?循环或放入?list?中。

值得考虑的是，传给?zip()?的可迭代对象可能长度不同；有时是有意为之，有时是因为准备这些对象的代码存在错误。Python 提供了三种不同的处理方案：
默认情况下，zip()?在最短的迭代完成后停止。较长可迭代对象中的剩余项将被忽略，结果会裁切至最短可迭代对象的长度：
>>>
>>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
[(0, 'fee'), (1, 'fi'), (2, 'fo')]
通常?zip()?用于可迭代对象等长的情况下。这时建议用?strict=True?的选项。输出与普通的?zip()?相同：。
>>>
>>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
[('a', 1), ('b', 2), ('c', 3)]
与默认行为不同的是，它会检查可迭代对象的长度是否相同，如果不相同则触发?ValueError?。
>>>
>>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True))
Traceback (most recent call last):
  ...
ValueError: zip() argument 2 is longer than argument 1
如果未指定?strict=True?参数，所有导致可迭代对象长度不同的错误都会被抑制，这可能会在程序的其他地方表现为难以发现的错误。
为了让所有的可迭代对象具有相同的长度，长度较短的可用常量进行填充。这可由?itertools.zip_longest()?来完成。
极端例子是只有一个可迭代对象参数，zip()?会返回一个一元组的迭代器。如果未给出参数，则返回一个空的迭代器。

小技巧：
可确保迭代器的求值顺序是从左到右的。这样就能用?zip(*[iter(s)]*n,?strict=True)?将数据列表按长度 n 进行分组。这将重复?相同?的迭代器?n?次，输出的每个元组都包含?n?次调用迭代器的结果。这样做的效果是把输入拆分为长度为 n 的块。
zip()?与?*?运算符相结合可以用来拆解一个列表:
>>>
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> list(zip(x, y))
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True
在 3.10 版更改:?增加了?strict?参数。

__import__(name,?globals=None,?locals=None,?fromlist=(),?level=0)

备注

与?importlib.import_module()?不同，这是一个日常 Python 编程中不需要用到的高级函数。

此函数会由?import?语句发起调用。它可以被替换 (通过导入?builtins?模块并赋值给?builtins.__import__) 以便修改?import?语句的语义，但是?强烈?不建议这样做，因为使用导入钩子 (参见?PEP 302) 通常更容易实现同样的目标，并且不会导致代码问题，因为许多代码都会假定所用的是默认实现。同样也不建议直接使用?__import__()?而应该用?importlib.import_module()。

本函数会导入模块?name，利用?globals?和?locals?来决定如何在包的上下文中解释该名称。fromlist?给出了应从?name?模块中导入的对象或子模块的名称。标准的实现代码完全不会用到?locals?参数，只用到了?globals?用于确定?import?语句所在的包上下文。

level?指定是使用绝对还是相对导入。?0?(默认值) 意味着仅执行绝对导入。?level?为正数值表示相对于模块调用?__import__()?的目录，将要搜索的父目录层数 (详情参见?PEP 328)。

当?name?变量的形式为?package.module?时，通常将会返回最高层级的包（第一个点号之前的名称），而?不是?以?name?命名的模块。但是，当给出了非空的?fromlist?参数时，则将返回以?name?命名的模块。

例如，语句?import?spam?的结果将为与以下代码作用相同的字节码:
spam = __import__('spam', globals(), locals(), [], 0)
语句?import?spam.ham?的结果将为以下调用:
spam = __import__('spam.ham', globals(), locals(), [], 0)
请注意在这里?__import__()?是如何返回顶层模块的，因为这是通过?import?语句被绑定到特定名称的对象。

另一方面，语句?from?spam.ham?import?eggs,?sausage?as?saus?的结果将为
_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage
在这里，?spam.ham?模块会由?__import__()?返回。要导入的对象将从此对象中提取并赋值给它们对应的名称。

如果您只想按名称导入模块（可能在包中），请使用?importlib.import_module()

在 3.3 版更改:?level?的值不再支持负数（默认值也修改为0）。

在 3.9 版更改:?当使用了命令行参数?-E?或?-I?时，环境变量?PYTHONCASEOK?现在将被忽略。

3.?Python 速览

下面的例子以是否显示提示符（>>>?与?...）区分输入与输出：输入例子中的代码时，要键入以提示符开头的行中提示符后的所有内容；未以提示符开头的行是解释器的输出。注意，例子中的某行出现的第二个提示符是用来结束多行命令的，此时，要键入一个空白行。

你可以通过在示例方块右上角的?>>>?上点击来切换显示提示符和输出。如果你隐藏了一个示例的提示符和输出，那么你可以方便地将输入行复制并粘贴到你的解释器中。

本手册中的许多例子，甚至交互式命令都包含注释。Python 注释以?#?开头，直到该物理行结束。注释可以在行开头，或空白符与代码之后，但不能在字符串里面。字符串中的 # 号就是 # 号。注释用于阐明代码，Python 不解释注释，键入例子时，可以不输入注释。

示例如下：

# this is the first comment
spam = 1  # and this is the second comment
          # ... and now a third!
text = "# This is not a comment because it's inside quotes."

3.1.?Python 用作计算器

现在，尝试一些简单的 Python 命令。启动解释器，等待主提示符（>>>?）出现。

3.1.1.?数字

解释器像一个简单的计算器：输入表达式，就会给出答案。表达式的语法很直接：运算符?+、-、*、/?的用法和其他大部分语言一样（比如，Pascal 或 C）；括号 (()) 用来分组。例如：

>>>

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # division always returns a floating point number
1.6

整数（如，2、4、20?）的类型是?int，带小数（如，5.0、1.6?）的类型是?float。本教程后半部分将介绍更多数字类型。

除法运算（/）返回浮点数。用?//?运算符执行?floor division?的结果是整数（忽略小数）；计算余数用?%：

>>>

>>> 17 / 3  # classic division returns a float
5.666666666666667
>>>
>>> 17 // 3  # floor division discards the fractional part
5
>>> 17 % 3  # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2  # floored quotient * divisor + remainder
17

Python 用?**?运算符计算乘方?1：

>>>

>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128

等号（=）用于给变量赋值。赋值后，下一个交互提示符的位置不显示任何结果：

>>>

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

如果变量未定义（即，未赋值），使用该变量会提示错误：

>>>

>>> n  # try to access an undefined variable
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

Python 全面支持浮点数；混合类型运算数的运算会把整数转换为浮点数：

>>>

>>> 4 * 3.75 - 1
14.0

交互模式下，上次输出的表达式会赋给变量?_。把 Python 当作计算器时，用该变量实现下一步计算更简单，例如：

>>>

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

最好把该变量当作只读类型。不要为它显式赋值，否则会创建一个同名独立局部变量，该变量会用它的魔法行为屏蔽内置变量。

除了?int?和?float，Python 还支持其他数字类型，例如?Decimal?或?Fraction。Python 还内置支持?复数，后缀?j?或?J?用于表示虚数（例如?3+5j?）。

3.1.2.?字符串

除了数字，Python 还可以操作字符串。字符串有多种表现形式，用单引号（'……'）或双引号（"……"）标注的结果相同?2。反斜杠?\?用于转义：

>>>

>>> 'spam eggs'  # single quotes
'spam eggs'
>>> 'doesn\'t'  # use \' to escape the single quote...
"doesn't"
>>> "doesn't"  # ...or use double quotes instead
"doesn't"
>>> '"Yes," they said.'
'"Yes," they said.'
>>> "\"Yes,\" they said."
'"Yes," they said.'
>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'

交互式解释器会为输出的字符串加注引号，特殊字符使用反斜杠转义。虽然，有时输出的字符串看起来与输入的字符串不一样（外加的引号可能会改变），但两个字符串是相同的。如果字符串中有单引号而没有双引号，该字符串外将加注双引号，反之，则加注单引号。print()?函数输出的内容更简洁易读，它会省略两边的引号，并输出转义后的特殊字符：

>>>

>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'
>>> print('"Isn\'t," they said.')
"Isn't," they said.
>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print(), \n is included in the output
'First line.\nSecond line.'
>>> print(s)  # with print(), \n produces a new line
First line.
Second line.

如果不希望前置?\?的字符转义成特殊字符，可以使用?原始字符串，在引号前添加?r?即可：

>>>

>>> print('C:\some\name')  # here \n means newline!
C:\some
ame
>>> print(r'C:\some\name')  # note the r before the quote
C:\some\name

字符串字面值可以包含多行。一种实现方式是使用三重引号："""..."""?或?'''...'''。字符串中将自动包括行结束符，但也可以在换行的地方添加一个?\?来避免此情况。参见以下示例：

print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

输出如下（请注意开始的换行符没有被包括在内）：

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

字符串可以用?+?合并（粘到一起），也可以用?*?重复：

>>>

>>> # 3 times 'un', followed by 'ium'
>>> 3 * 'un' + 'ium'
'unununium'

相邻的两个或多个?字符串字面值?（引号标注的字符）会自动合并：

>>>

>>> 'Py' 'thon'
'Python'

拆分长字符串时，这个功能特别实用：

>>>

>>> text = ('Put several strings within parentheses '
...         'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

这项功能只能用于两个字面值，不能用于变量或表达式：

>>>

>>> prefix = 'Py'
>>> prefix 'thon'  # can't concatenate a variable and a string literal
  File "<stdin>", line 1
    prefix 'thon'
                ^
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  File "<stdin>", line 1
    ('un' * 3) 'ium'
                   ^
SyntaxError: invalid syntax

合并多个变量，或合并变量与字面值，要用?+：

>>>

>>> prefix + 'thon'
'Python'

字符串支持?索引?（下标访问），第一个字符的索引是 0。单字符没有专用的类型，就是长度为一的字符串：

>>>

>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'

索引还支持负数，用负数索引时，从右边开始计数：

>>>

>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[-6]
'P'

注意，-0 和 0 一样，因此，负数索引从 -1 开始。

除了索引，字符串还支持?切片。索引可以提取单个字符，切片?则提取子字符串：

>>>

>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'

切片索引的默认值很有用；省略开始索引时，默认值为 0，省略结束索引时，默认为到字符串的结尾：

>>>

>>> word[:2]   # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:]   # characters from position 4 (included) to the end
'on'
>>> word[-2:]  # characters from the second-last (included) to the end
'on'

注意，输出结果包含切片开始，但不包含切片结束。因此，s[:i]?+?s[i:]?总是等于?s：

>>>

>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

还可以这样理解切片，索引指向的是字符?之间?，第一个字符的左侧标为 0，最后一个字符的右侧标为?n?，n?是字符串长度。例如：

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

第一行数字是字符串中索引 0...6 的位置，第二行数字是对应的负数索引位置。i?到?j?的切片由?i?和?j?之间所有对应的字符组成。

对于使用非负索引的切片，如果两个索引都不越界，切片长度就是起止索引之差。例如，?word[1:3]?的长度是 2。

索引越界会报错：

>>>

>>> word[42]  # the word only has 6 characters
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

但是，切片会自动处理越界索引：

>>>

>>> word[4:42]
'on'
>>> word[42:]
''

Python 字符串不能修改，是?immutable?的。因此，为字符串中某个索引位置赋值会报错：

>>>

>>> word[0] = 'J'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

要生成不同的字符串，应新建一个字符串：

>>>

>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

内置函数?len()?返回字符串的长度：

>>>

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

参见

文本序列类型 --- str

字符串是?序列类型?，支持序列类型的各种操作。

字符串的方法

字符串支持很多变形与查找方法。

格式字符串字面值

内嵌表达式的字符串字面值。

格式字符串语法

使用?str.format()?格式化字符串。

printf 风格的字符串格式化

这里详述了用?%?运算符格式化字符串的操作。

3.1.3.?列表

Python 支持多种?复合?数据类型，可将不同值组合在一起。最常用的?列表?，是用方括号标注，逗号分隔的一组值。列表?可以包含不同类型的元素，但一般情况下，各个元素的类型相同：

>>>

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

和字符串（及其他内置?sequence?类型）一样，列表也支持索引和切片：

>>>

>>> squares[0]  # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:]  # slicing returns a new list
[9, 16, 25]

切片操作返回包含请求元素的新列表。以下切片操作会返回列表的?浅拷贝：

>>>

>>> squares[:]
[1, 4, 9, 16, 25]

列表还支持合并操作：

>>>

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

与?immutable?字符串不同, 列表是?mutable?类型，其内容可以改变：

>>>

>>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
>>> 4 ** 3  # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64  # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]

append()?方法?可以在列表结尾添加新元素（详见后文）:

>>>

>>> cubes.append(216)  # add the cube of 6
>>> cubes.append(7 ** 3)  # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

为切片赋值可以改变列表大小，甚至清空整个列表：

>>>

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]

内置函数?len()?也支持列表：

>>>

>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

还可以嵌套列表（创建包含其他列表的列表），例如：

>>>

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

3.2.?走向编程的第一步

当然，Python 还可以完成比二加二更复杂的任务。例如，可以编写?斐波那契数列?的初始子序列，如下所示：

>>>

>>> # Fibonacci series:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while a < 10:
...     print(a)
...     a, b = b, a+b
...
0
1
1
2
3
5
8

本例引入了几个新功能。

第一行中的?多重赋值：变量?a?和?b?同时获得新值 0 和 1。最后一行又用了一次多重赋值，这体现在右表达式在赋值前就已经求值了。右表达式求值顺序为从左到右。
while?循环只要条件（这里指：a?<?10）保持为真就会一直执行。Python 和 C 一样，任何非零整数都为真，零为假。这个条件也可以是字符串或列表的值，事实上，任何序列都可以；长度非零就为真，空序列则为假。示例中的判断只是最简单的比较。比较操作符的标准写法和 C 语言一样：?<?（小于）、?>?（大于）、?==?（等于）、?<=?（小于等于)、?>=?（大于等于）及?!=?（不等于）。
循环体?是?缩进的?：缩进是 Python 组织语句的方式。在交互式命令行里，得为每个缩输入制表符或空格。使用文本编辑器可以实现更复杂的输入方式；所有像样的文本编辑器都支持自动缩进。交互式输入复合语句时, 要在最后输入空白行表示结束（因为解析器不知道哪一行代码是最后一行）。注意，同一块语句的每一行的缩进相同。
print()?函数输出给定参数的值。与表达式不同（比如，之前计算器的例子），它能处理多个参数，包括浮点数与字符串。它输出的字符串不带引号，且各参数项之间会插入一个空格，这样可以实现更好的格式化操作：
>>>
```
>>> i = 256*256
>>> print('The value of i is', i)
The value of i is 65536
```
关键字参数?end?可以取消输出后面的换行, 或用另一个字符串结尾：
>>>
```
>>> a, b = 0, 1
>>> while a < 1000:
...     print(a, end=',')
...     a, b = b, a+b
...
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,
```

备注

**?比?-?的优先级更高, 所以?-3**2?会被解释成?-(3**2)?，因此，结果是?-9。要避免这个问题，并且得到?9, 可以用?(-3)**2。

和其他语言不一样，特殊字符如?\n?在单引号（'...'）和双引号（"..."）里的意义一样。这两种引号唯一的区别是，不需要在单引号里转义双引号?"，但必须把单引号转义成?\'，反之亦然。

4.?其他流程控制工具

除了上一章介绍的?while?语句，Python 还支持其他语言中常见的流程控制语句，只是稍有不同。

4.1.?`if`?语句

最让人耳熟能详的应该是?if?语句。例如：

>>>

>>> x = int(input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
...     x = 0
...     print('Negative changed to zero')
... elif x == 0:
...     print('Zero')
... elif x == 1:
...     print('Single')
... else:
...     print('More')
...
More

if 语句包含零个或多个?elif?子句及可选的?else?子句。关键字 'elif' 是 'else if' 的缩写，适用于避免过多的缩进。if?...?elif?...?elif?... 序列可以当作其他语言中?switch?或?case?语句的替代品。

如果要把一个值与多个常量进行比较，或者检查特定类型或属性，match?语句更实用。详见?match 语句。

4.2.?`for`?语句

Python 的?for?语句与 C 或 Pascal 中的不同。Python 的?for?语句不迭代算术递增数值（如 Pascal），或是给予用户定义迭代步骤和暂停条件的能力（如 C），而是迭代列表或字符串等任意序列，元素的迭代顺序与在序列中出现的顺序一致。例如：

>>>

>>> # Measure some strings:
... words = ['cat', 'window', 'defenestrate']
>>> for w in words:
...     print(w, len(w))
...
cat 3
window 6
defenestrate 12

遍历集合时修改集合的内容，会很容易生成错误的结果。因此不能直接进行循环，而是应遍历该集合的副本或创建新的集合：

# Create a sample collection
users = {'Hans': 'active', 'éléonore': 'inactive', '景太郎': 'active'}

# Strategy:  Iterate over a copy
for user, status in users.copy().items():
    if status == 'inactive':
        del users[user]

# Strategy:  Create a new collection
active_users = {}
for user, status in users.items():
    if status == 'active':
        active_users[user] = status

4.3.?range()?函数

内置函数?range()?常用于遍历数字序列，该函数可以生成算术级数：

>>>

>>> for i in range(5):
...     print(i)
...
0
1
2
3
4

生成的序列不包含给定的终止数值；range(10)?生成 10 个值，这是一个长度为 10 的序列，其中的元素索引都是合法的。range 可以不从 0 开始，还可以按指定幅度递增（递增幅度称为 '步进'，支持负数）：

>>>

>>> list(range(5, 10))
[5, 6, 7, 8, 9]

>>> list(range(0, 10, 3))
[0, 3, 6, 9]

>>> list(range(-10, -100, -30))
[-10, -40, -70]

range()?和?len()?组合在一起，可以按索引迭代序列：

>>>

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
...     print(i, a[i])
...
0 Mary
1 had
2 a
3 little
4 lamb

不过，大多数情况下，enumerate()?函数更便捷，详见?循环的技巧?。

如果只输出 range，会出现意想不到的结果：

>>>

>>> range(10)
range(0, 10)

range()?返回对象的操作和列表很像，但其实这两种对象不是一回事。迭代时，该对象基于所需序列返回连续项，并没有生成真正的列表，从而节省了空间。

这种对象称为可迭代对象?iterable，函数或程序结构可通过该对象获取连续项，直到所有元素全部迭代完毕。for?语句就是这样的架构，sum()?是一种把可迭代对象作为参数的函数：

>>>

>>> sum(range(4))  # 0 + 1 + 2 + 3
6

下文将介绍更多返回可迭代对象或把可迭代对象当作参数的函数。在?数据结构?这一章节中，我们将讨论有关?list()?的更多细节。

4.4.?循环中的?`break`、`continue`?语句及?`else`?子句

break?语句和 C 中的类似，用于跳出最近的?for?或?while?循环。

循环语句支持?else?子句；for?循环中，可迭代对象中的元素全部循环完毕，或?while?循环的条件为假时，执行该子句；break?语句终止循环时，不执行该子句。请看下面这个查找素数的循环示例：

>>>

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print(n, 'equals', x, '*', n//x)
...             break
...     else:
...         # loop fell through without finding a factor
...         print(n, 'is a prime number')
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

（没错，这段代码就是这么写。仔细看：else?子句属于?for?循环，不属于?if?语句。）

与?if?语句相比，循环的?else?子句更像?try?的?else?子句：?try?的?else?子句在未触发异常时执行，循环的?else?子句则在未运行?break?时执行。try?语句和异常详见?异常的处理。

continue?语句也借鉴自 C 语言，表示继续执行循环的下一次迭代：

>>>

>>> for num in range(2, 10):
...     if num % 2 == 0:
...         print("Found an even number", num)
...         continue
...     print("Found an odd number", num)
...
Found an even number 2
Found an odd number 3
Found an even number 4
Found an odd number 5
Found an even number 6
Found an odd number 7
Found an even number 8
Found an odd number 9

4.5.?`pass`?语句

pass?语句不执行任何操作。语法上需要一个语句，但程序不实际执行任何动作时，可以使用该语句。例如：

>>>

>>> while True:
...     pass  # Busy-wait for keyboard interrupt (Ctrl+C)
...

下面这段代码创建了一个最小的类：

>>>

>>> class MyEmptyClass:
...     pass
...

pass?还可以用作函数或条件子句的占位符，让开发者聚焦更抽象的层次。此时，程序直接忽略?pass：

>>>

>>> def initlog(*args):
...     pass   # Remember to implement this!
...

4.6.?`match`?语句

A?match?statement takes an expression and compares its value to successive patterns given as one or more case blocks. This is superficially similar to a switch statement in C, Java or JavaScript (and many other languages), but it's more similar to pattern matching in languages like Rust or Haskell. Only the first pattern that matches gets executed and it can also extract components (sequence elements or object attributes) from the value into variables.

最简单的形式是将一个目标值与一个或多个字面值进行比较：

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the internet"

注意最后一个代码块：“变量名”?_?被作为?通配符?并必定会匹配成功。如果没有 case 语句匹配成功，则不会执行任何分支。

使用?|?（“ or ”）在一个模式中可以组合多个字面值：

case 401 | 403 | 404:
    return "Not allowed"

模式的形式类似解包赋值，并可被用于绑定变量：

# point is an (x, y) tuple
match point:
    case (0, 0):
        print("Origin")
    case (0, y):
        print(f"Y={y}")
    case (x, 0):
        print(f"X={x}")
    case (x, y):
        print(f"X={x}, Y={y}")
    case _:
        raise ValueError("Not a point")

请仔细研究此代码！第一个模式有两个字面值，可以看作是上面所示字面值模式的扩展。但接下来的两个模式结合了一个字面值和一个变量，而变量?绑定?了一个来自目标的值（point）。第四个模式捕获了两个值，这使得它在概念上类似于解包赋值?(x,?y)?=?point。

如果使用类实现数据结构，可在类名后加一个类似于构造器的参数列表，这样做可以把属性放到变量里：

class Point:
    x: int
    y: int

def where_is(point):
    match point:
        case Point(x=0, y=0):
            print("Origin")
        case Point(x=0, y=y):
            print(f"Y={y}")
        case Point(x=x, y=0):
            print(f"X={x}")
        case Point():
            print("Somewhere else")
        case _:
            print("Not a point")

可在 dataclass 等支持属性排序的内置类中使用位置参数。还可在类中设置?__match_args__?特殊属性为模式的属性定义指定位置。如果它被设为 ("x", "y")，则以下模式均为等价的，并且都把?y?属性绑定到?var?变量：

Point(1, var)
Point(1, y=var)
Point(x=1, y=var)
Point(y=var, x=1)

读取模式的推荐方式是将它们看做是你会在赋值操作左侧放置的内容的扩展形式，以便理解各个变量将会被设置的值。只有单独的名称（例如上面的?var）会被 match 语句所赋值。带点号的名称 (例如?foo.bar)、属性名称（例如上面的?x=?和?y=）或类名称（通过其后的 "(...)" 来识别，例如上面的?Point）都绝不会被赋值。

模式可以任意地嵌套。例如，如果有一个由点组成的短列表，则可使用如下方式进行匹配：

match points:
    case []:
        print("No points")
    case [Point(0, 0)]:
        print("The origin")
    case [Point(x, y)]:
        print(f"Single point {x}, {y}")
    case [Point(0, y1), Point(0, y2)]:
        print(f"Two on the Y axis at {y1}, {y2}")
    case _:
        print("Something else")

为模式添加成为守护项的?if?子句。如果守护项的值为假，则?match?继续匹配下一个 case 语句块。注意，值的捕获发生在守护项被求值之前：

match point:
    case Point(x, y) if x == y:
        print(f"Y=X at {x}")
    case Point(x, y):
        print(f"Not on the diagonal")

match 语句的其他特性：

与解包赋值类似，元组和列表模式具有完全相同的含义，并且实际上能匹配任意序列。但它们不能匹配迭代器或字符串。
序列模式支持扩展解包操作：[x,?y,?*rest]?和?(x,?y,?*rest)?的作用类似于解包赋值。在?*?之后的名称也可以为?_，因此，(x,?y,?*_)?可以匹配包含至少两个条目的序列，而不必绑定其余的条目。
映射模式：{"bandwidth":?b,?"latency":?l}?从字典中捕获?"bandwidth"?和?"latency"?的值。与序列模式不同，额外的键会被忽略。**rest?等解包操作也支持。但?**_?是冗余的，不允许使用。
使用?as?关键字可以捕获子模式：
```
case (Point(x1, y1), Point(x2, y2) as p2): ...
```
将把输入的第二个元素捕获为?p2?(只要输入是包含两个点的序列)
大多数字面值是按相等性比较的，但是单例对象?True,?False?和?None?则是按标识号比较的。

模式可以使用命名常量。这些命名常量必须为带点号的名称以防止它们被解读为捕获变量:

from enum import Enum
class Color(Enum):
    RED = 'red'
    GREEN = 'green'
    BLUE = 'blue'

color = Color(input("Enter your choice of 'red', 'blue' or 'green': "))

match color:
    case Color.RED:
        print("I see red!")
    case Color.GREEN:
        print("Grass is green")
    case Color.BLUE:
        print("I'm feeling the blues :(")

要获取更详细的说明和额外的示例，你可以参阅以教程格式撰写的?PEP 636。

4.7.?定义函数

下列代码创建一个可以输出限定数值内的斐波那契数列函数：

>>>

>>> def fib(n):    # write Fibonacci series up to n
...     """Print a Fibonacci series up to n."""
...     a, b = 0, 1
...     while a < n:
...         print(a, end=' ')
...         a, b = b, a+b
...     print()
...
>>> # Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

定义?函数使用关键字?def，后跟函数名与括号内的形参列表。函数语句从下一行开始，并且必须缩进。

函数内的第一条语句是字符串时，该字符串就是文档字符串，也称为?docstring，详见?文档字符串。利用文档字符串可以自动生成在线文档或打印版文档，还可以让开发者在浏览代码时直接查阅文档；Python 开发者最好养成在代码中加入文档字符串的好习惯。

函数在?执行?时使用函数局部变量符号表，所有函数变量赋值都存在局部符号表中；引用变量时，首先，在局部符号表里查找变量，然后，是外层函数局部符号表，再是全局符号表，最后是内置名称符号表。因此，尽管可以引用全局变量和外层函数的变量，但最好不要在函数内直接赋值（除非是?global?语句定义的全局变量，或?nonlocal?语句定义的外层函数变量）。

在调用函数时会将实际参数（实参）引入到被调用函数的局部符号表中；因此，实参是使用?按值调用?来传递的（其中的?值?始终是对象的?引用?而不是对象的值）。?1?当一个函数调用另外一个函数时，会为该调用创建一个新的局部符号表。

函数定义在当前符号表中把函数名与函数对象关联在一起。解释器把函数名指向的对象作为用户自定义函数。还可以使用其他名称指向同一个函数对象，并访问访该函数：

>>>

>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89

fib?不返回值，因此，其他语言不把它当作函数，而是当作过程。事实上，没有?return?语句的函数也返回值，只不过这个值比较是?None?（是一个内置名称）。一般来说，解释器不会输出单独的返回值?None?，如需查看该值，可以使用?print()：

>>>

>>> fib(0)
>>> print(fib(0))
None

编写不直接输出斐波那契数列运算结果，而是返回运算结果列表的函数也非常简单：

>>>

>>> def fib2(n):  # return Fibonacci series up to n
...     """Return a list containing the Fibonacci series up to n."""
...     result = []
...     a, b = 0, 1
...     while a < n:
...         result.append(a)    # see below
...         a, b = b, a+b
...     return result
...
>>> f100 = fib2(100)    # call it
>>> f100                # write the result
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

本例也新引入了一些 Python 功能：

return?语句返回函数的值。return?语句不带表达式参数时，返回?None。函数执行完毕退出也返回?None。
result.append(a)?语句调用了列表对象?result?的?方法?。方法是“从属于”对象的函数，命名为?obj.methodname，obj?是对象（也可以是表达式），methodname?是对象类型定义的方法名。不同类型定义不同的方法，不同类型的方法名可以相同，且不会引起歧义。（用?类?可以自定义对象类型和方法，详见?类?）示例中的方法?append()?是为列表对象定义的，用于在列表末尾添加新元素。本例中，该方法相当于?result?=?result?+?[a]?，但更有效。

4.8.?函数定义详解

函数定义支持可变数量的参数。这里列出三种可以组合使用的形式。

4.8.1.?默认值参数

为参数指定默认值是非常有用的方式。调用函数时，可以使用比定义时更少的参数，例如：

def ask_ok(prompt, retries=4, reminder='Please try again!'):
    while True:
        ok = input(prompt)
        if ok in ('y', 'ye', 'yes'):
            return True
        if ok in ('n', 'no', 'nop', 'nope'):
            return False
        retries = retries - 1
        if retries < 0:
            raise ValueError('invalid user response')
        print(reminder)

该函数可以用以下方式调用：

只给出必选实参：ask_ok('Do?you?really?want?to?quit?')
给出一个可选实参：ask_ok('OK?to?overwrite?the?file?',?2)
给出所有实参：ask_ok('OK?to?overwrite?the?file?',?2,?'Come?on,?only?yes?or?no!')

本例还使用了关键字?in?，用于确认序列中是否包含某个值。

默认值在?定义?作用域里的函数定义中求值，所以：

i = 5

def f(arg=i):
    print(arg)

i = 6
f()

上例输出的是?5。

重要警告：?默认值只计算一次。默认值为列表、字典或类实例等可变对象时，会产生与该规则不同的结果。例如，下面的函数会累积后续调用时传递的参数：

def f(a, L=[]):
    L.append(a)
    return L

print(f(1))
print(f(2))
print(f(3))

输出结果如下：

[1]
[1, 2]
[1, 2, 3]

不想在后续调用之间共享默认值时，应以如下方式编写函数：

def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

4.8.2.?关键字参数

kwarg=value?形式的?关键字参数?也可以用于调用函数。函数示例如下：

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print("-- This parrot wouldn't", action, end=' ')
    print("if you put", voltage, "volts through it.")
    print("-- Lovely plumage, the", type)
    print("-- It's", state, "!")

该函数接受一个必选参数（voltage）和三个可选参数（state,?action?和?type）。该函数可用下列方式调用：

parrot(1000)                                          # 1 positional argument
parrot(voltage=1000)                                  # 1 keyword argument
parrot(voltage=1000000, action='VOOOOOM')             # 2 keyword arguments
parrot(action='VOOOOOM', voltage=1000000)             # 2 keyword arguments
parrot('a million', 'bereft of life', 'jump')         # 3 positional arguments
parrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 keyword

以下调用函数的方式都无效：

parrot()                     # required argument missing
parrot(voltage=5.0, 'dead')  # non-keyword argument after a keyword argument
parrot(110, voltage=220)     # duplicate value for the same argument
parrot(actor='John Cleese')  # unknown keyword argument

函数调用时，关键字参数必须跟在位置参数后面。所有传递的关键字参数都必须匹配一个函数接受的参数（比如，actor?不是函数?parrot?的有效参数），关键字参数的顺序并不重要。这也包括必选参数，（比如，parrot(voltage=1000)?也有效）。不能对同一个参数多次赋值，下面就是一个因此限制而失败的例子：

>>>

>>> def function(a):
...     pass
...
>>> function(0, a=0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: function() got multiple values for argument 'a'

最后一个形参为?**name?形式时，接收一个字典（详见?映射类型 --- dict），该字典包含与函数中已定义形参对应之外的所有关键字参数。**name?形参可以与?*name?形参（下一小节介绍）组合使用（*name?必须在?**name?前面），?*name?形参接收一个?元组，该元组包含形参列表之外的位置参数。例如，可以定义下面这样的函数：

def cheeseshop(kind, *arguments, **keywords):
    print("-- Do you have any", kind, "?")
    print("-- I'm sorry, we're all out of", kind)
    for arg in arguments:
        print(arg)
    print("-" * 40)
    for kw in keywords:
        print(kw, ":", keywords[kw])

该函数可以用如下方式调用：

cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper="Michael Palin",
           client="John Cleese",
           sketch="Cheese Shop Sketch")

输出结果如下：

-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
shopkeeper : Michael Palin
client : John Cleese
sketch : Cheese Shop Sketch

注意，关键字参数在输出结果中的顺序与调用函数时的顺序一致。

4.8.3.?特殊参数

默认情况下，参数可以按位置或显式关键字传递给 Python 函数。为了让代码易读、高效，最好限制参数的传递方式，这样，开发者只需查看函数定义，即可确定参数项是仅按位置、按位置或关键字，还是仅按关键字传递。

函数定义如下：

def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
      -----------    ----------     ----------
        |             |                  |
        |        Positional or keyword   |
        |                                - Keyword only
         -- Positional only

/?和?*?是可选的。这些符号表明形参如何把参数值传递给函数：位置、位置或关键字、关键字。关键字形参也叫作命名形参。

4.8.3.1.?位置或关键字参数

函数定义中未使用?/?和?*?时，参数可以按位置或关键字传递给函数。

4.8.3.2.?仅位置参数

此处再介绍一些细节，特定形参可以标记为?仅限位置。仅限位置?时，形参的顺序很重要，且这些形参不能用关键字传递。仅限位置形参应放在?/?（正斜杠）前。/?用于在逻辑上分割仅限位置形参与其它形参。如果函数定义中没有?/，则表示没有仅限位置形参。

/?后可以是?位置或关键字?或?仅限关键字?形参。

4.8.3.3.?仅限关键字参数

把形参标记为?仅限关键字，表明必须以关键字参数形式传递该形参，应在参数列表中第一个?仅限关键字?形参前添加?*。

4.8.3.4.?函数示例

请看下面的函数定义示例，注意?/?和?*?标记：

>>>

>>> def standard_arg(arg):
...     print(arg)
...
>>> def pos_only_arg(arg, /):
...     print(arg)
...
>>> def kwd_only_arg(*, arg):
...     print(arg)
...
>>> def combined_example(pos_only, /, standard, *, kwd_only):
...     print(pos_only, standard, kwd_only)

第一个函数定义?standard_arg?是最常见的形式，对调用方式没有任何限制，可以按位置也可以按关键字传递参数：

>>>

>>> standard_arg(2)
2

>>> standard_arg(arg=2)
2

第二个函数?pos_only_arg?的函数定义中有?/，仅限使用位置形参：

>>>

>>> pos_only_arg(1)
1

>>> pos_only_arg(arg=1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pos_only_arg() got some positional-only arguments passed as keyword arguments: 'arg'

第三个函数?kwd_only_args?的函数定义通过?*?表明仅限关键字参数：

>>>

>>> kwd_only_arg(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: kwd_only_arg() takes 0 positional arguments but 1 was given

>>> kwd_only_arg(arg=3)
3

最后一个函数在同一个函数定义中，使用了全部三种调用惯例：

>>>

>>> combined_example(1, 2, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: combined_example() takes 2 positional arguments but 3 were given

>>> combined_example(1, 2, kwd_only=3)
1 2 3

>>> combined_example(1, standard=2, kwd_only=3)
1 2 3

>>> combined_example(pos_only=1, standard=2, kwd_only=3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: combined_example() got some positional-only arguments passed as keyword arguments: 'pos_only'

下面的函数定义中，kwds?把?name?当作键，因此，可能与位置参数?name?产生潜在冲突：

def foo(name, **kwds):
    return 'name' in kwds

调用该函数不可能返回?True，因为关键字?'name'?总与第一个形参绑定。例如：

>>>

>>> foo(1, **{'name': 2})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() got multiple values for argument 'name'
>>>

加上?/?（仅限位置参数）后，就可以了。此时，函数定义把?name?当作位置参数，'name'?也可以作为关键字参数的键：

def foo(name, /, **kwds):
    return 'name' in kwds
>>> foo(1, **{'name': 2})
True

换句话说，仅限位置形参的名称可以在?**kwds?中使用，而不产生歧义。

4.8.3.5.?小结

以下用例决定哪些形参可以用于函数定义：

def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):

说明：

使用仅限位置形参，可以让用户无法使用形参名。形参名没有实际意义时，强制调用函数的实参顺序时，或同时接收位置形参和关键字时，这种方式很有用。
当形参名有实际意义，且显式名称可以让函数定义更易理解时，阻止用户依赖传递实参的位置时，才使用关键字。
对于 API，使用仅限位置形参，可以防止未来修改形参名时造成破坏性的 API 变动。

4.8.4.?任意实参列表

调用函数时，使用任意数量的实参是最少见的选项。这些实参包含在元组中（详见?元组和序列?）。在可变数量的实参之前，可能有若干个普通参数：

def write_multiple_items(file, separator, *args):
    file.write(separator.join(args))

variadic?参数用于采集传递给函数的所有剩余参数，因此，它们通常在形参列表的末尾。*args?形参后的任何形式参数只能是仅限关键字参数，即只能用作关键字参数，不能用作位置参数：

>>>

>>> def concat(*args, sep="/"):
...     return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'

4.8.5.?解包实参列表

函数调用要求独立的位置参数，但实参在列表或元组里时，要执行相反的操作。例如，内置的?range()?函数要求独立的?start?和?stop?实参。如果这些参数不是独立的，则要在调用函数时，用?*?操作符把实参从列表或元组解包出来：

>>>

>>> list(range(3, 6))            # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args))            # call with arguments unpacked from a list
[3, 4, 5]

同样，字典可以用?**?操作符传递关键字参数：

>>>

>>> def parrot(voltage, state='a stiff', action='voom'):
...     print("-- This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

4.8.6.?Lambda 表达式

lambda?关键字用于创建小巧的匿名函数。lambda?a,?b:?a+b?函数返回两个参数的和。Lambda 函数可用于任何需要函数对象的地方。在语法上，匿名函数只能是单个表达式。在语义上，它只是常规函数定义的语法糖。与嵌套函数定义一样，lambda 函数可以引用包含作用域中的变量：

>>>

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43

上例用 lambda 表达式返回函数。还可以把匿名函数用作传递的实参：

>>>

>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

4.8.7.?文档字符串

以下是文档字符串内容和格式的约定。

第一行应为对象用途的简短摘要。为保持简洁，不要在这里显式说明对象名或类型，因为可通过其他方式获取这些信息（除非该名称碰巧是描述函数操作的动词）。这一行应以大写字母开头，以句点结尾。

文档字符串为多行时，第二行应为空白行，在视觉上将摘要与其余描述分开。后面的行可包含若干段落，描述对象的调用约定、副作用等。

Python 解析器不会删除 Python 中多行字符串字面值的缩进，因此，文档处理工具应在必要时删除缩进。这项操作遵循以下约定：文档字符串第一行?之后?的第一个非空行决定了整个文档字符串的缩进量（第一行通常与字符串开头的引号相邻，其缩进在字符串中并不明显，因此，不能用第一行的缩进），然后，删除字符串中所有行开头处与此缩进“等价”的空白符。不能有比此缩进更少的行，但如果出现了缩进更少的行，应删除这些行的所有前导空白符。转化制表符后（通常为 8 个空格），应测试空白符的等效性。

下面是多行文档字符串的一个例子：

>>>

>>> def my_function():
...     """Do nothing, but document it.
...
...     No, really, it doesn't do anything.
...     """
...     pass
...
>>> print(my_function.__doc__)
Do nothing, but document it.

    No, really, it doesn't do anything.

4.8.8.?函数注解

函数注解?是可选的用户自定义函数类型的元数据完整信息（详见?PEP 3107?和?PEP 484?）。

标注?以字典的形式存放在函数的?__annotations__?属性中，并且不会影响函数的任何其他部分。形参标注的定义方式是在形参名后加冒号，后面跟一个表达式，该表达式会被求值为标注的值。返回值标注的定义方式是加组合符号?->，后面跟一个表达式，该标注位于形参列表和表示?def?语句结束的冒号之间。下面的示例有一个必须的参数，一个可选的关键字参数以及返回值都带有相应的标注:

>>>

>>> def f(ham: str, eggs: str = 'eggs') -> str:
...     print("Annotations:", f.__annotations__)
...     print("Arguments:", ham, eggs)
...     return ham + ' and ' + eggs
...
>>> f('spam')
Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
Arguments: spam eggs
'spam and eggs'

5.?数据结构

本章深入讲解之前学过的一些内容，同时，还增加了新的知识点。

5.1.?列表详解

列表数据类型支持很多方法，列表对象的所有方法所示如下：

list.append(x)

在列表末尾添加一个元素，相当于?a[len(a):]?=?[x]?。

list.extend(iterable)

用可迭代对象的元素扩展列表。相当于?a[len(a):]?=?iterable?。

list.insert(i,?x)

在指定位置插入元素。第一个参数是插入元素的索引，因此，a.insert(0,?x)?在列表开头插入元素，?a.insert(len(a),?x)?等同于?a.append(x)?。

list.remove(x)

从列表中删除第一个值为?x?的元素。未找到指定元素时，触发?ValueError?异常。

list.pop([i])

删除列表中指定位置的元素，并返回被删除的元素。未指定位置时，a.pop()?删除并返回列表的最后一个元素。（方法签名中?i?两边的方括号表示该参数是可选的，不是要求输入方括号。这种表示法常见于 Python 参考库）。

list.clear()

删除列表里的所有元素，相当于?del?a[:]?。

list.index(x[,?start[,?end]])

返回列表中第一个值为?x?的元素的零基索引。未找到指定元素时，触发?ValueError?异常。

可选参数?start?和?end?是切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于整个序列的开始计算的，而不是?start?参数。

list.count(x)

返回列表中元素?x?出现的次数。

list.sort(*,?key=None,?reverse=False)

就地排序列表中的元素（要了解自定义排序参数，详见?sorted()）。

list.reverse()

翻转列表中的元素。

list.copy()

返回列表的浅拷贝。相当于?a[:]?。

多数列表方法示例：

>>>

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting a position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'

insert、remove、sort?等方法只修改列表，不输出返回值——返回的默认值为?None?。1?这是所有 Python 可变数据结构的设计原则。

还有，不是所有数据都可以排序或比较。例如，[None,?'hello',?10]?就不可排序，因为整数不能与字符串对比，而?None?不能与其他类型对比。有些类型根本就没有定义顺序关系，例如，3+4j?<?5+7j?这种对比操作就是无效的。

5.1.1.?用列表实现堆栈

使用列表方法实现堆栈非常容易，最后插入的最先取出（“后进先出”）。把元素添加到堆栈的顶端，使用?append()?。从堆栈顶部取出元素，使用?pop()?，不用指定索引。例如：

>>>

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

5.1.2.?用列表实现队列

列表也可以用作队列，最先加入的元素，最先取出（“先进先出”）；然而，列表作为队列的效率很低。因为，在列表末尾添加和删除元素非常快，但在列表开头插入或移除元素却很慢（因为所有其他元素都必须移动一位）。

实现队列最好用?collections.deque，可以快速从两端添加或删除元素。例如：

>>>

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

5.1.3.?列表推导式

列表推导式创建列表的方式更简洁。常见的用法为，对序列或可迭代对象中的每个元素应用某种操作，用生成的结果创建新的列表；或用满足特定条件的元素创建子序列。

例如，创建平方值的列表：

>>>

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

注意，这段代码创建（或覆盖）变量?x，该变量在循环结束后仍然存在。下述方法可以无副作用地计算平方列表：

squares = list(map(lambda x: x**2, range(10)))

或等价于：

squares = [x**2 for x in range(10)]

上面这种写法更简洁、易读。

列表推导式的方括号内包含以下内容：一个表达式，后面为一个?for?子句，然后，是零个或多个?for?或?if?子句。结果是由表达式依据?for?和?if?子句求值计算而得出一个新列表。举例来说，以下列表推导式将两个列表中不相等的元素组合起来：

>>>

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

等价于：

>>>

>>> combs = []
>>> for x in [1,2,3]:
...     for y in [3,1,4]:
...         if x != y:
...             combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

注意，上面两段代码中，for?和?if?的顺序相同。

表达式是元组（例如上例的?(x,?y)）时，必须加上括号：

>>>

>>> vec = [-4, -2, 0, 2, 4]
>>> # create a new list with the values doubled
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> # filter the list to exclude negative numbers
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> # apply a function to all the elements
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> # call a method on each element
>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> # create a list of 2-tuples like (number, square)
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> # the tuple must be parenthesized, otherwise an error is raised
>>> [x, x**2 for x in range(6)]
  File "<stdin>", line 1, in <module>
    [x, x**2 for x in range(6)]
               ^
SyntaxError: invalid syntax
>>> # flatten a list using a listcomp with two 'for'
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

列表推导式可以使用复杂的表达式和嵌套函数：

>>>

>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

5.1.4.?嵌套的列表推导式

列表推导式中的初始表达式可以是任何表达式，甚至可以是另一个列表推导式。

下面这个 3x4 矩阵，由 3 个长度为 4 的列表组成：

>>>

>>> matrix = [
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12],
... ]

下面的列表推导式可以转置行列：

>>>

>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

As we saw in the previous section, the inner list comprehension is evaluated in the context of the?for?that follows it, so this example is equivalent to:

>>>

>>> transposed = []
>>> for i in range(4):
...     transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

反过来说，也等价于：

>>>

>>> transposed = []
>>> for i in range(4):
...     # the following 3 lines implement the nested listcomp
...     transposed_row = []
...     for row in matrix:
...         transposed_row.append(row[i])
...     transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

实际应用中，最好用内置函数替代复杂的流程语句。此时，zip()?函数更好用：

>>>

>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

关于本行中星号的详细说明，参见?解包实参列表。

5.2.?`del`?语句

del?语句按索引，而不是值从列表中移除元素。与返回值的?pop()?方法不同，?del?语句也可以从列表中移除切片，或清空整个列表（之前是将空列表赋值给切片）。例如：

>>>

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

del?也可以用来删除整个变量：

>>>

>>> del a

此后，再引用?a?就会报错（直到为它赋与另一个值）。后文会介绍?del?的其他用法。

5.3.?元组和序列

列表和字符串有很多共性，例如，索引和切片操作。这两种数据类型是?序列?（参见?序列类型 --- list, tuple, range）。随着 Python 语言的发展，其他的序列类型也被加入其中。本节介绍另一种标准序列类型：元组。

元组由多个用逗号隔开的值组成，例如：

>>>

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> # Tuples are immutable:
... t[0] = 88888
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # but they can contain mutable objects:
... v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])

输出时，元组都要由圆括号标注，这样才能正确地解释嵌套元组。输入时，圆括号可有可无，不过经常是必须的（如果元组是更大的表达式的一部分）。不允许为元组中的单个元素赋值，当然，可以创建含列表等可变对象的元组。

虽然，元组与列表很像，但使用场景不同，用途也不同。元组是?immutable?（不可变的），一般可包含异质元素序列，通过解包（见本节下文）或索引访问（如果是?namedtuples，可以属性访问）。列表是?mutable?（可变的），列表元素一般为同质类型，可迭代访问。

构造 0 个或 1 个元素的元组比较特殊：为了适应这种情况，对句法有一些额外的改变。用一对空圆括号就可以创建空元组；只有一个元素的元组可以通过在这个元素后添加逗号来构建（圆括号里只有一个值的话不够明确）。丑陋，但是有效。例如：

>>>

>>> empty = ()
>>> singleton = 'hello',    # <-- note trailing comma
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)

语句?t?=?12345,?54321,?'hello!'?是?元组打包?的例子：值?12345,?54321?和?'hello!'?一起被打包进元组。逆操作也可以：

>>>

>>> x, y, z = t

称之为?序列解包?也是妥妥的，适用于右侧的任何序列。序列解包时，左侧变量与右侧序列元素的数量应相等。注意，多重赋值其实只是元组打包和序列解包的组合。

5.4.?集合

Python 还支持?集合?这种数据类型。集合是由不重复元素组成的无序容器。基本用法包括成员检测、消除重复元素。集合对象支持合集、交集、差集、对称差分等数学运算。

创建集合用花括号或?set()?函数。注意，创建空集合只能用?set()，不能用?{}，{}?创建的是空字典，下一小节介绍数据结构：字典。

以下是一些简单的示例

>>>

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # fast membership testing
True
>>> 'crabgrass' in basket
False

>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b                              # letters in a or b or both
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # letters in both a and b
{'a', 'c'}
>>> a ^ b                              # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}

与?列表推导式?类似，集合也支持推导式：

>>>

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

5.5.?字典

字典?（参见?映射类型 --- dict）也是一种常用的 Python 內置数据类型。其他语言可能把字典称为?联合内存?或?联合数组。与以连续整数为索引的序列不同，字典以?关键字?为索引，关键字通常是字符串或数字，也可以是其他任意不可变类型。只包含字符串、数字、元组的元组，也可以用作关键字。但如果元组直接或间接地包含了可变对象，就不能用作关键字。列表不能当关键字，因为列表可以用索引、切片、append()?、extend()?等方法修改。

可以把字典理解为?键值对?的集合，但字典的键必须是唯一的。花括号?{}?用于创建空字典。另一种初始化字典的方式是，在花括号里输入逗号分隔的键值对，这也是字典的输出方式。

字典的主要用途是通过关键字存储、提取值。用?del?可以删除键值对。用已存在的关键字存储值，与该关键字关联的旧值会被取代。通过不存在的键提取值，则会报错。

对字典执行?list(d)?操作，返回该字典中所有键的列表，按插入次序排列（如需排序，请使用?sorted(d)）。检查字典里是否存在某个键，使用关键字?in。

以下是一些字典的简单示例：

>>>

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)
['jack', 'guido', 'irv']
>>> sorted(tel)
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

dict()?构造函数可以直接用键值对序列创建字典：

>>>

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}

字典推导式可以用任意键值表达式创建字典：

>>>

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

关键字是比较简单的字符串时，直接用关键字参数指定键值对更便捷：

>>>

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}

5.6.?循环的技巧

在字典中循环时，用?items()?方法可同时取出键和对应的值：

>>>

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

在序列中循环时，用?enumerate()?函数可以同时取出位置索引和对应的值：

>>>

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

同时循环两个或多个序列时，用?zip()?函数可以将其内的元素一一匹配：

>>>

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

逆向循环序列时，先正向定位序列，然后调用?reversed()?函数：

>>>

>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1

按指定顺序循环序列，可以用?sorted()?函数，在不改动原序列的基础上，返回一个重新的序列：

>>>

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for i in sorted(basket):
...     print(i)
...
apple
apple
banana
orange
orange
pear

使用?set()?去除序列中的重复元素。使用?sorted()?加?set()?则按排序后的顺序，循环遍历序列中的唯一元素：

>>>

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear

一般来说，在循环中修改列表的内容时，创建新列表比较简单，且安全：

>>>

>>> import math
>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
>>> filtered_data = []
>>> for value in raw_data:
...     if not math.isnan(value):
...         filtered_data.append(value)
...
>>> filtered_data
[56.2, 51.7, 55.3, 52.5, 47.8]

5.7.?深入条件控制

while?和?if?条件句不只可以进行比较，还可以使用任意运算符。

比较运算符?in?和?not?in?用于执行确定一个值是否存在（或不存在）于某个容器中的成员检测。运算符?is?和?is?not?用于比较两个对象是否是同一个对象。所有比较运算符的优先级都一样，且低于任何数值运算符。

比较操作支持链式操作。例如，a?<?b?==?c?校验?a?是否小于?b，且?b?是否等于?c。

比较操作可以用布尔运算符?and?和?or?组合，并且，比较操作（或其他布尔运算）的结果都可以用?not?取反。这些操作符的优先级低于比较操作符；not?的优先级最高，?or?的优先级最低，因此，A?and?not?B?or?C?等价于?(A?and?(not?B))?or?C。与其他运算符操作一样，此处也可以用圆括号表示想要的组合。

布尔运算符?and?和?or?也称为?短路?运算符：其参数从左至右解析，一旦可以确定结果，解析就会停止。例如，如果?A?和?C?为真，B?为假，那么?A?and?B?and?C?不会解析?C。用作普通值而不是布尔值时，短路操作符返回的值通常是最后一个变量。

还可以把比较操作或逻辑表达式的结果赋值给变量，例如：

>>>

>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'

注意，Python 与 C 不同，在表达式内部赋值必须显式使用?海象运算符?:=。这避免了 C 程序中常见的问题：要在表达式中写?==?时，却写成了?=。

5.8.?序列和其他类型的比较

序列对象可以与相同序列类型的其他对象比较。这种比较使用?字典式?顺序：首先，比较前两个对应元素，如果不相等，则可确定比较结果；如果相等，则比较之后的两个元素，以此类推，直到其中一个序列结束。如果要比较的两个元素本身是相同类型的序列，则递归地执行字典式顺序比较。如果两个序列中所有的对应元素都相等，则两个序列相等。如果一个序列是另一个的初始子序列，则较短的序列可被视为较小（较少）的序列。对于字符串来说，字典式顺序使用 Unicode 码位序号排序单个字符。下面列出了一些比较相同类型序列的例子：

(1, 2, 3)              < (1, 2, 4)
[1, 2, 3]              < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4)           < (1, 2, 4)
(1, 2)                 < (1, 2, -1)
(1, 2, 3)             == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)

注意，对不同类型的对象来说，只要待比较的对象提供了合适的比较方法，就可以使用?<?和?>?进行比较。例如，混合数值类型通过数值进行比较，所以，0 等于 0.0，等等。否则，解释器不会随便给出一个对比结果，而是触发?TypeError?异常。

7.?输入与输出

程序输出有几种显示方式；数据既可以输出供人阅读的形式，也可以写入文件备用。本章探讨一些可用的方式。

7.1.?更复杂的输出格式

至此，我们已学习了两种写入值的方法：表达式语句?和?print()?函数。第三种方法是使用文件对象的?write()?方法；标准输出文件称为?sys.stdout。详见标准库参考。

对输出格式的控制不只是打印空格分隔的值，还需要更多方式。格式化输出包括以下几种方法。

使用?格式化字符串字面值?，要在字符串开头的引号/三引号前添加?f?或?F?。在这种字符串中，可以在?{?和?}?字符之间输入引用的变量，或字面值的 Python 表达式。
>>>
```
>>> year = 2016
>>> event = 'Referendum'
>>> f'Results of the {year} {event}'
'Results of the 2016 Referendum'
```
字符串的?str.format()?方法需要更多手动操作。该方法也用?{?和?}?标记替换变量的位置，虽然这种方法支持详细的格式化指令，但需要提供格式化信息。
>>>
```
>>> yes_votes = 42_572_654
>>> no_votes = 43_132_495
>>> percentage = yes_votes / (yes_votes + no_votes)
>>> '{:-9} YES votes  {:2.2%}'.format(yes_votes, percentage)
' 42572654 YES votes  49.67%'
```
最后，还可以用字符串切片和合并操作完成字符串处理操作，创建任何排版布局。字符串类型还支持将字符串按给定列宽进行填充，这些方法也很有用。

如果不需要花哨的输出，只想快速显示变量进行调试，可以用?repr()?或?str()?函数把值转化为字符串。

str()?函数返回供人阅读的值，repr()?则生成适于解释器读取的值（如果没有等效的语法，则强制执行?SyntaxError）。对于没有支持供人阅读展示结果的对象，?str()?返回与?repr()?相同的值。一般情况下，数字、列表或字典等结构的值，使用这两个函数输出的表现形式是一样的。字符串有两种不同的表现形式。

示例如下：

>>>

>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
>>> print(s)
The value of x is 32.5, and y is 40000...
>>> # The repr() of a string adds string quotes and backslashes:
... hello = 'hello, world\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, world\n'
>>> # The argument to repr() may be any Python object:
... repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"

string?模块包含?Template?类，提供了将值替换为字符串的另一种方法。该类使用?$x?占位符，并用字典的值进行替换，但对格式控制的支持比较有限。

7.1.1.?格式化字符串字面值

格式化字符串字面值?（简称为 f-字符串）在字符串前加前缀?f?或?F，通过?{expression}?表达式，把 Python 表达式的值添加到字符串内。

格式说明符是可选的，写在表达式后面，可以更好地控制格式化值的方式。下例将 pi 舍入到小数点后三位：

>>>

>>> import math
>>> print(f'The value of pi is approximately {math.pi:.3f}.')
The value of pi is approximately 3.142.

在?':'?后传递整数，为该字段设置最小字符宽度，常用于列对齐：

>>>

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
...     print(f'{name:10} ==> {phone:10d}')
...
Sjoerd     ==>       4127
Jack       ==>       4098
Dcab       ==>       7678

还有一些修饰符可以在格式化前转换值。?'!a'?应用?ascii()?，'!s'?应用?str()，'!r'?应用?repr()：

>>>

>>> animals = 'eels'
>>> print(f'My hovercraft is full of {animals}.')
My hovercraft is full of eels.
>>> print(f'My hovercraft is full of {animals!r}.')
My hovercraft is full of 'eels'.

格式规范参考详见参考指南?格式规格迷你语言。

7.1.2.?字符串 format() 方法

str.format()?方法的基本用法如下所示：

>>>

>>> print('We are the {} who say "{}!"'.format('knights', 'Ni'))
We are the knights who say "Ni!"

花括号及之内的字符（称为格式字段）被替换为传递给?str.format()?方法的对象。花括号中的数字表示传递给?str.format()?方法的对象所在的位置。

>>>

>>> print('{0} and {1}'.format('spam', 'eggs'))
spam and eggs
>>> print('{1} and {0}'.format('spam', 'eggs'))
eggs and spam

str.format()?方法中使用关键字参数名引用值。

>>>

>>> print('This {food} is {adjective}.'.format(
...       food='spam', adjective='absolutely horrible'))
This spam is absolutely horrible.

位置参数和关键字参数可以任意组合：

>>>

>>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',
                                                       other='Georg'))
The story of Bill, Manfred, and Georg.

如果不想分拆较长的格式字符串，最好按名称引用变量进行格式化，不要按位置。这项操作可以通过传递字典，并用方括号?'[]'?访问键来完成。

>>>

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
...       'Dcab: {0[Dcab]:d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

This could also be done by passing the?table?dictionary as keyword arguments with the?**?notation.

>>>

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

与内置函数?vars()?结合使用时，这种方式非常实用，可以返回包含所有局部变量的字典。

例如，下面的代码生成一组整齐的列，包含给定整数及其平方与立方：

>>>

>>> for x in range(1, 11):
...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

str.format()?进行字符串格式化的完整概述详见?格式字符串语法?。

7.1.3.?手动格式化字符串

下面是使用手动格式化方式实现的同一个平方和立方的表：

>>>

>>> for x in range(1, 11):
...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
...     # Note use of 'end' on previous line
...     print(repr(x*x*x).rjust(4))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

（注意，每列之间的空格是通过使用?print()?添加的：它总在其参数间添加空格。）

字符串对象的?str.rjust()?方法通过在左侧填充空格，对给定宽度字段中的字符串进行右对齐。同类方法还有?str.ljust()?和?str.center()?。这些方法不写入任何内容，只返回一个新字符串，如果输入的字符串太长，它们不会截断字符串，而是原样返回；虽然这种方式会弄乱列布局，但也比另一种方法好，后者在显示值时可能不准确（如果真的想截断字符串，可以使用?x.ljust(n)[:n]?这样的切片操作。）

另一种方法是?str.zfill()?，该方法在数字字符串左边填充零，且能识别正负号：

>>>

>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'

7.1.4.?旧式字符串格式化方法

% 运算符（求余符）也可用于字符串格式化。给定?'string'?%?values，则?string?中的?%?实例会以零个或多个?values?元素替换。此操作被称为字符串插值。例如：

>>>

>>> import math
>>> print('The value of pi is approximately %5.3f.' % math.pi)
The value of pi is approximately 3.142.

printf 风格的字符串格式化?小节介绍更多相关内容。

7.2.?读写文件

open()?返回一个?file object?，最常使用的是两个位置参数和一个关键字参数：open(filename,?mode,?encoding=None)

>>>

>>> f = open('workfile', 'w', encoding="utf-8")

第一个实参是文件名字符串。第二个实参是包含描述文件使用方式字符的字符串。mode?的值包括?'r'?，表示文件只能读取；'w'?表示只能写入（现有同名文件会被覆盖）；'a'?表示打开文件并追加内容，任何写入的数据会自动添加到文件末尾。'r+'?表示打开文件进行读写。mode?实参是可选的，省略时的默认值为?'r'。

通常情况下，文件是以?text mode?打开的，也就是说，你从文件中读写字符串，这些字符串是以特定的?encoding?编码的。如果没有指定?encoding?，默认的是与平台有关的（见?open()?）。因为 UTF-8 是现代事实上的标准，除非你知道你需要使用一个不同的编码，否则建议使用?encoding="utf-8"?。在模式后面加上一个?'b'?，可以用?binary mode?打开文件。二进制模式的数据是以?bytes?对象的形式读写的。在二进制模式下打开文件时，你不能指定?encoding?。

在文本模式下读取文件时，默认把平台特定的行结束符（Unix 上为?\n, Windows 上为?\r\n）转换为?\n。在文本模式下写入数据时，默认把?\n?转换回平台特定结束符。这种操作方式在后台修改文件数据对文本文件来说没有问题，但会破坏?JPEG?或?EXE?等二进制文件中的数据。注意，在读写此类文件时，一定要使用二进制模式。

在处理文件对象时，最好使用?with?关键字。优点是，子句体结束后，文件会正确关闭，即便触发异常也可以。而且，使用?with?相比等效的?try-finally?代码块要简短得多：

>>>

>>> with open('workfile', encoding="utf-8") as f:
...     read_data = f.read()

>>> # We can check that the file has been automatically closed.
>>> f.closed
True

如果没有使用?with?关键字，则应调用?f.close()?关闭文件，即可释放文件占用的系统资源。

警告

调用?f.write()?时，未使用?with?关键字，或未调用?f.close()，即使程序正常退出，也**可能** 导致?f.write()?的参数没有完全写入磁盘。

通过?with?语句，或调用?f.close()?关闭文件对象后，再次使用该文件对象将会失败。

>>>

>>> f.close()
>>> f.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file.

7.2.1.?文件对象的方法

本节下文中的例子假定已创建?f?文件对象。

f.read(size)?可用于读取文件内容，它会读取一些数据，并返回字符串（文本模式），或字节串对象（在二进制模式下）。?size?是可选的数值参数。省略?size?或?size?为负数时，读取并返回整个文件的内容；文件大小是内存的两倍时，会出现问题。size?取其他值时，读取并返回最多?size?个字符（文本模式）或?size?个字节（二进制模式）。如已到达文件末尾，f.read()?返回空字符串（''）。

>>>

>>> f.read()
'This is the entire file.\n'
>>> f.read()
''

f.readline()?从文件中读取单行数据；字符串末尾保留换行符（\n），只有在文件不以换行符结尾时，文件的最后一行才会省略换行符。这种方式让返回值清晰明确；只要?f.readline()?返回空字符串，就表示已经到达了文件末尾，空行使用?'\n'?表示，该字符串只包含一个换行符。

>>>

>>> f.readline()
'This is the first line of the file.\n'
>>> f.readline()
'Second line of the file\n'
>>> f.readline()
''

从文件中读取多行时，可以用循环遍历整个文件对象。这种操作能高效利用内存，快速，且代码简单：

>>>

>>> for line in f:
...     print(line, end='')
...
This is the first line of the file.
Second line of the file

如需以列表形式读取文件中的所有行，可以用?list(f)?或?f.readlines()。

f.write(string)?把?string?的内容写入文件，并返回写入的字符数。

>>>

>>> f.write('This is a test\n')
15

写入其他类型的对象前，要先把它们转化为字符串（文本模式）或字节对象（二进制模式）：

>>>

>>> value = ('the answer', 42)
>>> s = str(value)  # convert the tuple to string
>>> f.write(s)
18

f.tell()?返回整数，给出文件对象在文件中的当前位置，表示为二进制模式下时从文件开始的字节数，以及文本模式下的意义不明的数字。

f.seek(offset,?whence)?可以改变文件对象的位置。通过向参考点添加?offset?计算位置；参考点由?whence?参数指定。?whence?值为 0 时，表示从文件开头计算，1 表示使用当前文件位置，2 表示使用文件末尾作为参考点。省略?whence?时，其默认值为 0，即使用文件开头作为参考点。

>>>

>>> f = open('workfile', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)      # Go to the 6th byte in the file
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2)  # Go to the 3rd byte before the end
13
>>> f.read(1)
b'd'

在文本文件（模式字符串未使用?b?时打开的文件）中，只允许相对于文件开头搜索（使用?seek(0,?2)?搜索到文件末尾是个例外），唯一有效的?offset?值是能从?f.tell()?中返回的，或 0。其他?offset?值都会产生未定义的行为。

文件对象还支持?isatty()?和?truncate()?等方法，但不常用；文件对象的完整指南详见库参考。

7.2.2.?使用?json?保存结构化数据

从文件写入或读取字符串很简单，数字则稍显麻烦，因为?read()?方法只返回字符串，这些字符串必须传递给?int()?这样的函数，接受?'123'?这样的字符串，并返回数字值 123。保存嵌套列表、字典等复杂数据类型时，手动解析和序列化的操作非常复杂。

Python 支持?JSON (JavaScript Object Notation)?这种流行数据交换格式，用户无需没完没了地编写、调试代码，才能把复杂的数据类型保存到文件。json?标准模块采用 Python 数据层次结构，并将之转换为字符串表示形式；这个过程称为?serializing?（序列化）。从字符串表示中重建数据称为?deserializing?（解序化）。在序列化和解序化之间，表示对象的字符串可能已经存储在文件或数据中，或通过网络连接发送到远方的机器。

备注

JSON 格式通常用于现代应用程序的数据交换。程序员早已对它耳熟能详，可谓是交互操作的不二之选。

只需一行简单的代码即可查看某个对象的 JSON 字符串表现形式：

>>>

>>> import json
>>> x = [1, 'simple', 'list']
>>> json.dumps(x)
'[1, "simple", "list"]'

dumps()?函数还有一个变体，?dump()?，它只将对象序列化为?text file?。因此，如果?f?是?text file?对象，可以这样做：

json.dump(x, f)

要再次解码对象，如果?f?是已打开、供读取的?binary file?或?text file?对象：

x = json.load(f)

备注

JSON文件必须以UTF-8编码。当打开JSON文件作为一个?text file?用于读写时，使用?encoding="utf-8"?。

这种简单的序列化技术可以处理列表和字典，但在 JSON 中序列化任意类的实例，则需要付出额外努力。json?模块的参考包含对此的解释。

参见

pickle?- 封存模块

与?JSON?不同，pickle?是一种允许对复杂 Python 对象进行序列化的协议。因此，它为 Python 所特有，不能用于与其他语言编写的应用程序通信。默认情况下它也是不安全的：如果解序化的数据是由手段高明的攻击者精心设计的，这种不受信任来源的 pickle 数据可以执行任意代码。

8.?错误和异常

至此，本教程还未深入介绍错误信息，但如果您输入过本教程前文中的例子，应该已经看到过一些错误信息。目前，（至少）有两种不同错误：句法错误?和?异常。

8.1.?句法错误

句法错误又称解析错误，是学习 Python 时最常见的错误：

>>>

>>> while True print('Hello world')
  File "<stdin>", line 1
    while True print('Hello world')
                   ^
SyntaxError: invalid syntax

解析器会复现出现句法错误的代码行，并用小“箭头”指向行里检测到的第一个错误。错误是由箭头?上方?的 token 触发的（至少是在这里检测出的）：本例中，在?print()?函数中检测到错误，因为，在它前面缺少冒号（':'）。错误信息还输出文件名与行号，在使用脚本文件时，就可以知道去哪里查错。

8.2.?异常

即使语句或表达式使用了正确的语法，执行时仍可能触发错误。执行时检测到的错误称为?异常，异常不一定导致严重的后果：很快我们就能学会如何处理 Python 的异常。大多数异常不会被程序处理，而是显示下列错误信息：

>>>

>>> 10 * (1/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

错误信息的最后一行说明程序遇到了什么类型的错误。异常有不同的类型，而类型名称会作为错误信息的一部分中打印出来：上述示例中的异常类型依次是：ZeroDivisionError，?NameError?和?TypeError。作为异常类型打印的字符串是发生的内置异常的名称。对于所有内置异常都是如此，但对于用户定义的异常则不一定如此（虽然这种规范很有用）。标准的异常类型是内置的标识符（不是保留关键字）。

此行其余部分根据异常类型，结合出错原因，说明错误细节。

错误信息开头用堆栈回溯形式展示发生异常的语境。一般会列出源代码行的堆栈回溯；但不会显示从标准输入读取的行。

内置异常?列出了内置异常及其含义。

8.3.?异常的处理

可以编写程序处理选定的异常。下例会要求用户一直输入内容，直到输入有效的整数，但允许用户中断程序（使用?Control-C?或操作系统支持的其他操作）；注意，用户中断程序会触发?KeyboardInterrupt?异常。

>>>

>>> while True:
...     try:
...         x = int(input("Please enter a number: "))
...         break
...     except ValueError:
...         print("Oops!  That was no valid number.  Try again...")
...

try?语句的工作原理如下：

首先，执行?try 子句?（try?和?except?关键字之间的（多行）语句）。
如果没有触发异常，则跳过?except 子句，try?语句执行完毕。
如果在执行?try?子句时发生了异常，则跳过该子句中剩下的部分。如果异常的类型与?except?关键字后指定的异常相匹配，则会执行?except 子句，然后跳到 try/except 代码块之后继续执行。
如果发生的异常与?except 子句?中指定的异常不匹配，则它会被传递到外部的?try?语句中；如果没有找到处理程序，则它是一个?未处理异常?且执行将终止并输出如上所示的消息。

try?语句可以有多个?except 子句?来为不同的异常指定处理程序。但最多只有一个处理程序会被执行。处理程序只处理对应的?try 子句?中发生的异常，而不处理同一?try?语句内其他处理程序中的异常。?except 子句?可以用带圆括号的元组来指定多个异常，例如:

... except (RuntimeError, TypeError, NameError):
...     pass

如果发生的异常与?except?子句中的类是同一个类或是它的基类时，则该类与该异常相兼容（反之则不成立 --- 列出派生类的?except 子句?与基类不兼容）。例如，下面的代码将依次打印 B, C, D:

class B(Exception):
    pass

class C(B):
    pass

class D(C):
    pass

for cls in [B, C, D]:
    try:
        raise cls()
    except D:
        print("D")
    except C:
        print("C")
    except B:
        print("B")

请注意如果颠倒?except 子句?的顺序（把?except?B?放在最前），则会输出 B, B, B --- 即触发了第一个匹配的?except 子句。

When an exception occurs, it may have associated values, also known as the exception's?arguments. The presence and types of the arguments depend on the exception type.

The?except clause?may specify a variable after the exception name. The variable is bound to the exception instance which typically has an?args?attribute that stores the arguments. For convenience, builtin exception types define?__str__()?to print all the arguments without explicitly accessing?.args.

>>>

>>> try:
...     raise Exception('spam', 'eggs')
... except Exception as inst:
...     print(type(inst))    # the exception instance
...     print(inst.args)     # arguments stored in .args
...     print(inst)          # __str__ allows args to be printed directly,
...                          # but may be overridden in exception subclasses
...     x, y = inst.args     # unpack args
...     print('x =', x)
...     print('y =', y)
...
<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
x = spam
y = eggs

The exception's?__str__()?output is printed as the last part ('detail') of the message for unhandled exceptions.

BaseException?is the common base class of all exceptions. One of its subclasses,?Exception, is the base class of all the non-fatal exceptions. Exceptions which are not subclasses of?Exception?are not typically handled, because they are used to indicate that the program should terminate. They include?SystemExit?which is raised by?sys.exit()?and?KeyboardInterrupt?which is raised when a user wishes to interrupt the program.

Exception?can be used as a wildcard that catches (almost) everything. However, it is good practice to be as specific as possible with the types of exceptions that we intend to handle, and to allow any unexpected exceptions to propagate on.

The most common pattern for handling?Exception?is to print or log the exception and then re-raise it (allowing a caller to handle the exception as well):

import sys

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error:", err)
except ValueError:
    print("Could not convert data to an integer.")
except Exception as err:
    print(f"Unexpected {err=}, {type(err)=}")
    raise

try?...?except?语句具有可选的?else 子句，该子句如果存在，它必须放在所有?except 子句?之后。它适用于?try 子句?没有引发异常但又必须要执行的代码。例如:

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except OSError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

使用?else?子句比向?try?子句添加额外的代码要好，可以避免意外捕获非?try?...?except?语句保护的代码触发的异常。

Exception handlers do not handle only exceptions that occur immediately in the?try clause, but also those that occur inside functions that are called (even indirectly) in the?try clause. For example:

>>>

>>> def this_fails():
...     x = 1/0
...
>>> try:
...     this_fails()
... except ZeroDivisionError as err:
...     print('Handling run-time error:', err)
...
Handling run-time error: division by zero

8.4.?触发异常

raise?语句支持强制触发指定的异常。例如：

>>>

>>> raise NameError('HiThere')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: HiThere

The sole argument to?raise?indicates the exception to be raised. This must be either an exception instance or an exception class (a class that derives from?BaseException, such as?Exception?or one of its subclasses). If an exception class is passed, it will be implicitly instantiated by calling its constructor with no arguments:

raise ValueError  # shorthand for 'raise ValueError()'

如果只想判断是否触发了异常，但并不打算处理该异常，则可以使用更简单的?raise?语句重新触发异常：

>>>

>>> try:
...     raise NameError('HiThere')
... except NameError:
...     print('An exception flew by!')
...     raise
...
An exception flew by!
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
NameError: HiThere

8.5.?异常链

raise?语句支持可选的?from?子句，该子句用于启用链式异常。例如：

# exc must be exception instance or None.
raise RuntimeError from exc

转换异常时，这种方式很有用。例如：

>>>

>>> def func():
...     raise ConnectionError
...
>>> try:
...     func()
... except ConnectionError as exc:
...     raise RuntimeError('Failed to open database') from exc
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "<stdin>", line 2, in func
ConnectionError

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError: Failed to open database

异常链会在?except?或?finally?子句内部引发异常时自动生成。这可以通过使用?from?None?这样的写法来禁用:

>>>

>>> try:
...     open('database.sqlite')
... except OSError:
...     raise RuntimeError from None
...
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError

异常链机制详见?内置异常。

8.6.?用户自定义异常

程序可以通过创建新的异常类命名自己的异常（Python 类的内容详见?类）。不论是以直接还是间接的方式，异常都应从?Exception?类派生。

异常类可以被定义成能做其他类所能做的任何事，但通常应当保持简单，它往往只提供一些属性，允许相应的异常处理程序提取有关错误的信息。

大多数异常命名都以 “Error” 结尾，类似标准异常的命名。

Many standard modules define their own exceptions to report errors that may occur in functions they define.

8.7.?定义清理操作

try?语句还有一个可选子句，用于定义在所有情况下都必须要执行的清理操作。例如：

>>>

>>> try:
...     raise KeyboardInterrupt
... finally:
...     print('Goodbye, world!')
...
Goodbye, world!
KeyboardInterrupt
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>

如果存在?finally?子句，则?finally?子句是?try?语句结束前执行的最后一项任务。不论?try?语句是否触发异常，都会执行?finally?子句。以下内容介绍了几种比较复杂的触发异常情景：

如果执行?try?子句期间触发了某个异常，则某个?except?子句应处理该异常。如果该异常没有?except?子句处理，在?finally?子句执行后会被重新触发。
except?或?else?子句执行期间也会触发异常。同样，该异常会在?finally?子句执行之后被重新触发。
如果?finally?子句中包含?break、continue?或?return?等语句，异常将不会被重新引发。
如果执行?try?语句时遇到?break,、continue?或?return?语句，则?finally?子句在执行?break、continue?或?return?语句之前执行。
如果?finally?子句中包含?return?语句，则返回值来自?finally?子句的某个?return?语句的返回值，而不是来自?try?子句的?return?语句的返回值。

例如：

>>>

>>> def bool_return():
...     try:
...         return True
...     finally:
...         return False
...
>>> bool_return()
False

这是一个比较复杂的例子：

>>>

>>> def divide(x, y):
...     try:
...         result = x / y
...     except ZeroDivisionError:
...         print("division by zero!")
...     else:
...         print("result is", result)
...     finally:
...         print("executing finally clause")
...
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

如上所示，任何情况下都会执行?finally?子句。except?子句不处理两个字符串相除触发的?TypeError，因此会在?finally?子句执行后被重新触发。

在实际应用程序中，finally?子句对于释放外部资源（例如文件或者网络连接）非常有用，无论是否成功使用资源。

8.8.?预定义的清理操作

某些对象定义了不需要该对象时要执行的标准清理操作。无论使用该对象的操作是否成功，都会执行清理操作。比如，下例要打开一个文件，并输出文件内容：

for line in open("myfile.txt"):
    print(line, end="")

这个代码的问题在于，执行完代码后，文件在一段不确定的时间内处于打开状态。在简单脚本中这没有问题，但对于较大的应用程序来说可能会出问题。with?语句支持以及时、正确的清理的方式使用文件对象：

with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

语句执行完毕后，即使在处理行时遇到问题，都会关闭文件?f。和文件一样，支持预定义清理操作的对象会在文档中指出这一点。

8.9.?Raising and Handling Multiple Unrelated Exceptions

There are situations where it is necessary to report several exceptions that have occurred. This it often the case in concurrency frameworks, when several tasks may have failed in parallel, but there are also other use cases where it is desirable to continue execution and collect multiple errors rather than raise the first exception.

The builtin?ExceptionGroup?wraps a list of exception instances so that they can be raised together. It is an exception itself, so it can be caught like any other exception.

>>>

>>> def f():
...     excs = [OSError('error 1'), SystemError('error 2')]
...     raise ExceptionGroup('there were problems', excs)
...
>>> f()
  + Exception Group Traceback (most recent call last):
  |   File "<stdin>", line 1, in <module>
  |   File "<stdin>", line 3, in f
  | ExceptionGroup: there were problems
  +-+---------------- 1 ----------------
    | OSError: error 1
    +---------------- 2 ----------------
    | SystemError: error 2
    +------------------------------------
>>> try:
...     f()
... except Exception as e:
...     print(f'caught {type(e)}: e')
...
caught <class 'ExceptionGroup'>: e
>>>

By using?except*?instead of?except, we can selectively handle only the exceptions in the group that match a certain type. In the following example, which shows a nested exception group, each?except*?clause extracts from the group exceptions of a certain type while letting all other exceptions propagate to other clauses and eventually to be reraised.

>>>

>>> def f():
...     raise ExceptionGroup("group1",
...                          [OSError(1),
...                           SystemError(2),
...                           ExceptionGroup("group2",
...                                          [OSError(3), RecursionError(4)])])
...
>>> try:
...     f()
... except* OSError as e:
...     print("There were OSErrors")
... except* SystemError as e:
...     print("There were SystemErrors")
...
There were OSErrors
There were SystemErrors
  + Exception Group Traceback (most recent call last):
  |   File "<stdin>", line 2, in <module>
  |   File "<stdin>", line 2, in f
  | ExceptionGroup: group1
  +-+---------------- 1 ----------------
    | ExceptionGroup: group2
    +-+---------------- 1 ----------------
      | RecursionError: 4
      +------------------------------------
>>>

Note that the exceptions nested in an exception group must be instances, not types. This is because in practice the exceptions would typically be ones that have already been raised and caught by the program, along the following pattern:

>>>

>>> excs = []
... for test in tests:
...     try:
...         test.run()
...     except Exception as e:
...         excs.append(e)
...
>>> if excs:
...    raise ExceptionGroup("Test Failures", excs)
...

8.10.?Enriching Exceptions with Notes

When an exception is created in order to be raised, it is usually initialized with information that describes the error that has occurred. There are cases where it is useful to add information after the exception was caught. For this purpose, exceptions have a method?add_note(note)?that accepts a string and adds it to the exception's notes list. The standard traceback rendering includes all notes, in the order they were added, after the exception.

>>>

>>> try:
...     raise TypeError('bad type')
... except Exception as e:
...     e.add_note('Add some information')
...     e.add_note('Add some more information')
...     raise
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
TypeError: bad type
Add some information
Add some more information
>>>

For example, when collecting exceptions into an exception group, we may want to add context information for the individual errors. In the following each exception in the group has a note indicating when this error has occurred.

>>>

>>> def f():
...     raise OSError('operation failed')
...
>>> excs = []
>>> for i in range(3):
...     try:
...         f()
...     except Exception as e:
...         e.add_note(f'Happened in Iteration {i+1}')
...         excs.append(e)
...
>>> raise ExceptionGroup('We have some problems', excs)
  + Exception Group Traceback (most recent call last):
  |   File "<stdin>", line 1, in <module>
  | ExceptionGroup: We have some problems (3 sub-exceptions)
  +-+---------------- 1 ----------------
    | Traceback (most recent call last):
    |   File "<stdin>", line 3, in <module>
    |   File "<stdin>", line 2, in f
    | OSError: operation failed
    | Happened in Iteration 1
    +---------------- 2 ----------------
    | Traceback (most recent call last):
    |   File "<stdin>", line 3, in <module>
    |   File "<stdin>", line 2, in f
    | OSError: operation failed
    | Happened in Iteration 2
    +---------------- 3 ----------------
    | Traceback (most recent call last):
    |   File "<stdin>", line 3, in <module>
    |   File "<stdin>", line 2, in f
    | OSError: operation failed
    | Happened in Iteration 3
    +------------------------------------
>>>

9.?类

类把数据与功能绑定在一起。创建新类就是创建新的对象?类型，从而创建该类型的新?实例?。类实例支持维持自身状态的属性，还支持（由类定义的）修改自身状态的方法。

和其他编程语言相比，Python 的类只使用了很少的新语法和语义。Python 的类有点类似于 C++ 和 Modula-3 中类的结合体，而且支持面向对象编程（OOP）的所有标准特性：类的继承机制支持多个基类、派生的类能覆盖基类的方法、类的方法能调用基类中的同名方法。对象可包含任意数量和类型的数据。和模块一样，类也支持 Python 动态特性：在运行时创建，创建后还可以修改。

如果用 C++ 术语来描述的话，类成员（包括数据成员）通常为?public?（例外的情况见下文?私有变量），所有成员函数都是?virtual。与在 Modula-3 中一样，没有用于从对象的方法中引用对象成员的简写形式：方法函数在声明时，有一个显式的参数代表本对象，该参数由调用隐式提供。与在 Smalltalk 中一样，Python 的类也是对象，这为导入和重命名提供了语义支持。与 C++ 和 Modula-3 不同，Python 的内置类型可以用作基类，供用户扩展。此外，与 C++ 一样，算术运算符、下标等具有特殊语法的内置运算符都可以为类实例而重新定义。

由于缺乏关于类的公认术语，本章中偶尔会使用 Smalltalk 和 C++ 的术语。本章还会使用 Modula-3 的术语，Modula-3 的面向对象语义比 C++ 更接近 Python，但估计听说过这门语言的读者很少。

9.1.?名称和对象

对象之间相互独立，多个名称（在多个作用域内）可以绑定到同一个对象。其他语言称之为别名。Python 初学者通常不容易理解这个概念，处理数字、字符串、元组等不可变基本类型时，可以不必理会。但是，对涉及可变对象，如列表、字典等大多数其他类型的 Python 代码的语义，别名可能会产生意料之外的效果。这样做，通常是为了让程序受益，因为别名在某些方面就像指针。例如，传递对象的代价很小，因为实现只传递一个指针；如果函数修改了作为参数传递的对象，调用者就可以看到更改 --- 无需 Pascal 用两个不同参数的传递机制。

9.2.?Python 作用域和命名空间

在介绍类前，首先要介绍 Python 的作用域规则。类定义对命名空间有一些巧妙的技巧，了解作用域和命名空间的工作机制有利于加强对类的理解。并且，即便对于高级 Python 程序员，这方面的知识也很有用。

接下来，我们先了解一些定义。

namespace?（命名空间）是映射到对象的名称。现在，大多数命名空间都使用 Python 字典实现，但除非涉及到优化性能，我们一般不会关注这方面的事情，而且将来也可能会改变这种方式。命名空间的几个常见示例：?abs()?函数、内置异常等的内置函数集合；模块中的全局名称；函数调用中的局部名称。对象的属性集合也算是一种命名空间。关于命名空间的一个重要知识点是，不同命名空间中的名称之间绝对没有关系；例如，两个不同的模块都可以定义?maximize?函数，且不会造成混淆。用户使用函数时必须要在函数名前面附加上模块名。

点号之后的名称是?属性。例如，表达式?z.real?中，real?是对象?z?的属性。严格来说，对模块中名称的引用是属性引用：表达式?modname.funcname?中，modname?是模块对象，funcname?是模块的属性。模块属性和模块中定义的全局名称之间存在直接的映射：它们共享相同的命名空间！?1

属性可以是只读或者可写的。如果可写，则可对属性赋值。模块属性是可写时，可以使用?modname.the_answer?=?42?。del?语句可以删除可写属性。例如，?del?modname.the_answer?会删除?modname?对象中的?the_answer?属性。

命名空间是在不同时刻创建的，且拥有不同的生命周期。内置名称的命名空间是在 Python 解释器启动时创建的，永远不会被删除。模块的全局命名空间在读取模块定义时创建；通常，模块的命名空间也会持续到解释器退出。从脚本文件读取或交互式读取的，由解释器顶层调用执行的语句是?__main__?模块调用的一部分，也拥有自己的全局命名空间。内置名称实际上也在模块里，即?builtins?。

函数的本地命名空间在调用该函数时创建，并在函数返回或抛出不在函数内部处理的错误时被删除。（实际上，用“遗忘”来描述实际发生的情况会更好一些。）当然，每次递归调用都会有自己的本地命名空间。

作用域?是命名空间可直接访问的 Python 程序的文本区域。 “可直接访问” 的意思是，对名称的非限定引用会在命名空间中查找名称。

作用域虽然是静态确定的，但会被动态使用。执行期间的任何时刻，都会有 3 或 4 个命名空间可被直接访问的嵌套作用域：

最内层作用域，包含局部名称，并首先在其中进行搜索
封闭函数的作用域，包含非局部名称和非全局名称，从最近的封闭作用域开始搜索
倒数第二个作用域，包含当前模块的全局名称
最外层的作用域，包含内置名称的命名空间，最后搜索

如果把名称声明为全局变量，则所有引用和赋值将直接指向包含该模块的全局名称的中间作用域。重新绑定在最内层作用域以外找到的变量，使用?nonlocal?语句把该变量声明为非局部变量。未声明为非局部变量的变量是只读的，（写入只读变量会在最内层作用域中创建一个?新的?局部变量，而同名的外部变量保持不变。）

通常，当前局部作用域将（按字面文本）引用当前函数的局部名称。在函数之外，局部作用域引用与全局作用域一致的命名空间：模块的命名空间。类定义在局部命名空间内再放置另一个命名空间。

划重点，作用域是按字面文本确定的：模块内定义的函数的全局作用域就是该模块的命名空间，无论该函数从什么地方或以什么别名被调用。另一方面，实际的名称搜索是在运行时动态完成的。但是，Python 正在朝着“编译时静态名称解析”的方向发展，因此不要过于依赖动态名称解析！（局部变量已经是被静态确定了。）

Python 有一个特殊规定。如果不存在生效的?global?或?nonlocal?语句，则对名称的赋值总是会进入最内层作用域。赋值不会复制数据，只是将名称绑定到对象。删除也是如此：语句?del?x?从局部作用域引用的命名空间中移除对?x?的绑定。所有引入新名称的操作都是使用局部作用域：尤其是?import?语句和函数定义会在局部作用域中绑定模块或函数名称。

global?语句用于表明特定变量在全局作用域里，并应在全局作用域中重新绑定；nonlocal?语句表明特定变量在外层作用域中，并应在外层作用域中重新绑定。

9.2.1.?作用域和命名空间示例

下例演示了如何引用不同作用域和名称空间，以及?global?和?nonlocal?对变量绑定的影响：

def scope_test():
    def do_local():
        spam = "local spam"

    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"

    def do_global():
        global spam
        spam = "global spam"

    spam = "test spam"
    do_local()
    print("After local assignment:", spam)
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    do_global()
    print("After global assignment:", spam)

scope_test()
print("In global scope:", spam)

示例代码的输出是：

After local assignment: test spam
After nonlocal assignment: nonlocal spam
After global assignment: nonlocal spam
In global scope: global spam

注意，局部?赋值（这是默认状态）不会改变?scope_test?对?spam?的绑定。?nonlocal?赋值会改变?scope_test?对?spam?的绑定，而?global?赋值会改变模块层级的绑定。

而且，global?赋值前没有?spam?的绑定。

9.3.?初探类

类引入了一点新语法，三种新的对象类型和一些新语义。

9.3.1.?类定义语法

最简单的类定义形式如下：

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

与函数定义 (def?语句) 一样，类定义必须先执行才能生效。把类定义放在?if?语句的分支里或函数内部试试。

在实践中，类定义内的语句通常都是函数定义，但也可以是其他语句。这部分内容稍后再讨论。类里的函数定义一般是特殊的参数列表，这是由方法调用的约定规范所指明的 --- 同样，稍后再解释。

当进入类定义时，将创建一个新的命名空间，并将其用作局部作用域 --- 因此，所有对局部变量的赋值都是在这个新命名空间之内。特别的，函数定义会绑定到这里的新函数名称。

当（从结尾处）正常离开类定义时，将创建一个?类对象。这基本上是一个包围在类定义所创建命名空间内容周围的包装器；我们将在下一节了解有关类对象的更多信息。原始的（在进入类定义之前起作用的）局部作用域将重新生效，类对象将在这里被绑定到类定义头所给出的类名称 (在这个示例中为?ClassName)。

9.3.2.?Class 对象

类对象支持两种操作：属性引用和实例化。

属性引用?使用 Python 中所有属性引用所使用的标准语法:?obj.name。有效的属性名称是类对象被创建时存在于类命名空间中的所有名称。因此，如果类定义是这样的:

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

那么?MyClass.i?和?MyClass.f?就是有效的属性引用，将分别返回一个整数和一个函数对象。类属性也可以被赋值，因此可以通过赋值来更改?MyClass.i?的值。?__doc__?也是一个有效的属性，将返回所属类的文档字符串:?"A?simple?example?class"。

类的?实例化?使用函数表示法。可以把类对象视为是返回该类的一个新实例的不带参数的函数。举例来说（假设使用上述的类）:

x = MyClass()

创建类的新?实例?并将此对象分配给局部变量?x。

实例化操作（“调用”类对象）会创建一个空对象。许多类喜欢创建带有特定初始状态的自定义实例。为此类定义可能包含一个名为?__init__()?的特殊方法，就像这样:

def __init__(self):
    self.data = []

当一个类定义了?__init__()?方法时，类的实例化操作会自动为新创建的类实例发起调用?__init__()。因此在这个示例中，可以通过以下语句获得一个经初始化的新实例:

x = MyClass()

当然，__init__()?方法还可以有额外参数以实现更高灵活性。在这种情况下，提供给类实例化运算符的参数将被传递给?__init__()。例如，:

>>>

>>> class Complex:
...     def __init__(self, realpart, imagpart):
...         self.r = realpart
...         self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)

9.3.3.?实例对象

现在我们能用实例对象做什么？实例对象所能理解的唯一操作是属性引用。有两种有效的属性名称：数据属性和方法。

数据属性?对应于 Smalltalk 中的“实例变量”，以及 C++ 中的“数据成员”。数据属性不需要声明；像局部变量一样，它们将在第一次被赋值时产生。例如，如果?x?是上面创建的?MyClass?的实例，则以下代码段将打印数值?16，且不保留任何追踪信息:

x.counter = 1
while x.counter < 10:
    x.counter = x.counter * 2
print(x.counter)
del x.counter

另一类实例属性引用称为?方法。方法是“从属于”对象的函数。（在 Python 中，方法这个术语并不是类实例所特有的：其他对象也可以有方法。例如，列表对象具有 append, insert, remove, sort 等方法。然而，在以下讨论中，我们使用方法一词将专指类实例对象的方法，除非另外显式地说明。）

实例对象的有效方法名称依赖于其所属的类。根据定义，一个类中所有是函数对象的属性都是定义了其实例的相应方法。因此在我们的示例中，x.f?是有效的方法引用，因为?MyClass.f?是一个函数，而?x.i?不是方法，因为?MyClass.i?不是函数。但是?x.f?与?MyClass.f?并不是一回事 --- 它是一个?方法对象，不是函数对象。

9.3.4.?方法对象

通常，方法在绑定后立即被调用:

x.f()

在?MyClass?示例中，这将返回字符串?'hello?world'。但是，立即调用一个方法并不是必须的:?x.f?是一个方法对象，它可以被保存起来以后再调用。例如:

xf = x.f
while True:
    print(xf())

将持续打印?hello?world，直到结束。

当一个方法被调用时到底发生了什么？你可能已经注意到上面调用?x.f()?时并没有带参数，虽然?f()?的函数定义指定了一个参数。这个参数发生了什么事？当不带参数地调用一个需要参数的函数时 Python 肯定会引发异常 --- 即使参数实际未被使用...

实际上，你可能已经猜到了答案：方法的特殊之处就在于实例对象会作为函数的第一个参数被传入。在我们的示例中，调用?x.f()?其实就相当于?MyClass.f(x)。总之，调用一个具有?n?个参数的方法就相当于调用再多一个参数的对应函数，这个参数值为方法所属实例对象，位置在其他参数之前。

如果你仍然无法理解方法的运作原理，那么查看实现细节可能会弄清楚问题。当一个实例的非数据属性被引用时，将搜索实例所属的类。如果被引用的属性名称表示一个有效的类属性中的函数对象，会通过打包（指向）查找到的实例对象和函数对象到一个抽象对象的方式来创建方法对象：这个抽象对象就是方法对象。当附带参数列表调用方法对象时，将基于实例对象和参数列表构建一个新的参数列表，并使用这个新参数列表调用相应的函数对象。

9.3.5.?类和实例变量

一般来说，实例变量用于每个实例的唯一数据，而类变量用于类的所有实例共享的属性和方法:

class Dog:

    kind = 'canine'         # class variable shared by all instances

    def __init__(self, name):
        self.name = name    # instance variable unique to each instance

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.kind                  # shared by all dogs
'canine'
>>> e.kind                  # shared by all dogs
'canine'
>>> d.name                  # unique to d
'Fido'
>>> e.name                  # unique to e
'Buddy'

正如?名称和对象?中已讨论过的，共享数据可能在涉及?mutable?对象例如列表和字典的时候导致令人惊讶的结果。例如以下代码中的?tricks?列表不应该被用作类变量，因为所有的?Dog?实例将只共享一个单独的列表:

class Dog:

    tricks = []             # mistaken use of a class variable

    def __init__(self, name):
        self.name = name

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks                # unexpectedly shared by all dogs
['roll over', 'play dead']

正确的类设计应该使用实例变量:

class Dog:

    def __init__(self, name):
        self.name = name
        self.tricks = []    # creates a new empty list for each dog

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks
['roll over']
>>> e.tricks
['play dead']

9.4.?补充说明

如果同样的属性名称同时出现在实例和类中，则属性查找会优先选择实例:

>>>

>>> class Warehouse:
...    purpose = 'storage'
...    region = 'west'
...
>>> w1 = Warehouse()
>>> print(w1.purpose, w1.region)
storage west
>>> w2 = Warehouse()
>>> w2.region = 'east'
>>> print(w2.purpose, w2.region)
storage east

数据属性可以被方法以及一个对象的普通用户（“客户端”）所引用。换句话说，类不能用于实现纯抽象数据类型。实际上，在 Python 中没有任何东西能强制隐藏数据 --- 它是完全基于约定的。（而在另一方面，用 C 语言编写的 Python 实现则可以完全隐藏实现细节，并在必要时控制对象的访问；此特性可以通过用 C 编写 Python 扩展来使用。）

客户端应当谨慎地使用数据属性 --- 客户端可能通过直接操作数据属性的方式破坏由方法所维护的固定变量。请注意客户端可以向一个实例对象添加他们自己的数据属性而不会影响方法的可用性，只要保证避免名称冲突 --- 再次提醒，在此使用命名约定可以省去许多令人头痛的麻烦。

在方法内部引用数据属性（或其他方法！）并没有简便方式。我发现这实际上提升了方法的可读性：当浏览一个方法代码时，不会存在混淆局部变量和实例变量的机会。

方法的第一个参数常常被命名为?self。这也不过就是一个约定:?self?这一名称在 Python 中绝对没有特殊含义。但是要注意，不遵循此约定会使得你的代码对其他 Python 程序员来说缺乏可读性，而且也可以想像一个?类浏览器?程序的编写可能会依赖于这样的约定。

任何一个作为类属性的函数都为该类的实例定义了一个相应方法。函数定义的文本并非必须包含于类定义之内：将一个函数对象赋值给一个局部变量也是可以的。例如:

# Function defined outside the class
def f1(self, x, y):
    return min(x, x+y)

class C:
    f = f1

    def g(self):
        return 'hello world'

    h = g

现在?f,?g?和?h?都是?C?类的引用函数对象的属性，因而它们就都是?C?的实例的方法 --- 其中?h?完全等同于?g。但请注意，本示例的做法通常只会令程序的阅读者感到迷惑。

方法可以通过使用?self?参数的方法属性调用其他方法:

class Bag:
    def __init__(self):
        self.data = []

    def add(self, x):
        self.data.append(x)

    def addtwice(self, x):
        self.add(x)
        self.add(x)

方法可以通过与普通函数相同的方式引用全局名称。与方法相关联的全局作用域就是包含其定义的模块。（类永远不会被作为全局作用域。）虽然我们很少会有充分的理由在方法中使用全局作用域，但全局作用域存在许多合理的使用场景：举个例子，导入到全局作用域的函数和模块可以被方法所使用，在其中定义的函数和类也一样。通常，包含该方法的类本身是在全局作用域中定义的，而在下一节中我们将会发现为何方法需要引用其所属类的很好的理由。

每个值都是一个对象，因此具有?类?（也称为?类型），并存储为?object.__class__?。

9.5.?继承

当然，如果不支持继承，语言特性就不值得称为“类”。派生类定义的语法如下所示:

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

名称?BaseClassName?必须定义于包含派生类定义的作用域中。也允许用其他任意表达式代替基类名称所在的位置。这有时也可能会用得上，例如，当基类定义在另一个模块中的时候:

class DerivedClassName(modname.BaseClassName):

派生类定义的执行过程与基类相同。当构造类对象时，基类会被记住。此信息将被用来解析属性引用：如果请求的属性在类中找不到，搜索将转往基类中进行查找。如果基类本身也派生自其他某个类，则此规则将被递归地应用。

派生类的实例化没有任何特殊之处:?DerivedClassName()?会创建该类的一个新实例。方法引用将按以下方式解析：搜索相应的类属性，如有必要将按基类继承链逐步向下查找，如果产生了一个函数对象则方法引用就生效。

派生类可能会重写其基类的方法。因为方法在调用同一对象的其他方法时没有特殊权限，所以调用同一基类中定义的另一方法的基类方法最终可能会调用覆盖它的派生类的方法。（对 C++ 程序员的提示：Python 中所有的方法实际上都是?virtual?方法。）

在派生类中的重载方法实际上可能想要扩展而非简单地替换同名的基类方法。有一种方式可以简单地直接调用基类方法：即调用?BaseClassName.methodname(self,?arguments)。有时这对客户端来说也是有用的。（请注意仅当此基类可在全局作用域中以?BaseClassName?的名称被访问时方可使用此方式。）

Python有两个内置函数可被用于继承机制：

使用?isinstance()?来检查一个实例的类型:?isinstance(obj,?int)?仅会在?obj.__class__?为?int?或某个派生自?int?的类时为?True。
使用?issubclass()?来检查类的继承关系:?issubclass(bool,?int)?为?True，因为?bool?是?int?的子类。但是，issubclass(float,?int)?为?False，因为?float?不是?int?的子类。

9.5.1.?多重继承

Python 也支持一种多重继承。带有多个基类的类定义语句如下所示:

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

对于多数应用来说，在最简单的情况下，你可以认为搜索从父类所继承属性的操作是深度优先、从左至右的，当层次结构中存在重叠时不会在同一个类中搜索两次。因此，如果某一属性在?DerivedClassName?中未找到，则会到?Base1?中搜索它，然后（递归地）到?Base1?的基类中搜索，如果在那里未找到，再到?Base2?中搜索，依此类推。

真实情况比这个更复杂一些；方法解析顺序会动态改变以支持对?super()?的协同调用。这种方式在某些其他多重继承型语言中被称为后续方法调用，它比单继承型语言中的 super 调用更强大。

动态改变顺序是有必要的，因为所有多重继承的情况都会显示出一个或更多的菱形关联（即至少有一个父类可通过多条路径被最底层类所访问）。例如，所有类都是继承自?object，因此任何多重继承的情况都提供了一条以上的路径可以通向?object。为了确保基类不会被访问一次以上，动态算法会用一种特殊方式将搜索顺序线性化，保留每个类所指定的从左至右的顺序，只调用每个父类一次，并且保持单调（即一个类可以被子类化而不影响其父类的优先顺序）。总而言之，这些特性使得设计具有多重继承的可靠且可扩展的类成为可能。要了解更多细节，请参阅?The Python 2.3 Method Resolution Order | Python.org。

9.6.?私有变量

那种仅限从一个对象内部访问的“私有”实例变量在 Python 中并不存在。但是，大多数 Python 代码都遵循这样一个约定：带有一个下划线的名称 (例如?_spam) 应该被当作是 API 的非公有部分 (无论它是函数、方法或是数据成员)。这应当被视为一个实现细节，可能不经通知即加以改变。

由于存在对于类私有成员的有效使用场景（例如避免名称与子类所定义的名称相冲突），因此存在对此种机制的有限支持，称为?名称改写。任何形式为?__spam?的标识符（至少带有两个前缀下划线，至多一个后缀下划线）的文本将被替换为?_classname__spam，其中?classname?为去除了前缀下划线的当前类名称。这种改写不考虑标识符的句法位置，只要它出现在类定义内部就会进行。

名称改写有助于让子类重载方法而不破坏类内方法调用。例如:

class Mapping:
    def __init__(self, iterable):
        self.items_list = []
        self.__update(iterable)

    def update(self, iterable):
        for item in iterable:
            self.items_list.append(item)

    __update = update   # private copy of original update() method

class MappingSubclass(Mapping):

    def update(self, keys, values):
        # provides new signature for update()
        # but does not break __init__()
        for item in zip(keys, values):
            self.items_list.append(item)

上面的示例即使在?MappingSubclass?引入了一个?__update?标识符的情况下也不会出错，因为它会在?Mapping?类中被替换为?_Mapping__update?而在?MappingSubclass?类中被替换为?_MappingSubclass__update。

请注意，改写规则的设计主要是为了避免意外冲突；访问或修改被视为私有的变量仍然是可能的。这在特殊情况下甚至会很有用，例如在调试器中。

请注意传递给?exec()?或?eval()?的代码不会将发起调用类的类名视作当前类；这类似于?global?语句的效果，因此这种效果仅限于同时经过字节码编译的代码。同样的限制也适用于?getattr(),?setattr()?和?delattr()，以及对于?__dict__?的直接引用。

9.7.?杂项说明

有时会需要使用类似于 Pascal 的“record”或 C 的“struct”这样的数据类型，将一些命名数据项捆绑在一起。这种情况适合定义一个空类:

class Employee:
    pass

john = Employee()  # Create an empty employee record

# Fill the fields of the record
john.name = 'John Doe'
john.dept = 'computer lab'
john.salary = 1000

一段需要特定抽象数据类型的 Python 代码往往可以被传入一个模拟了该数据类型的方法的类作为替代。例如，如果你有一个基于文件对象来格式化某些数据的函数，你可以定义一个带有?read()?和?readline()?方法从字符串缓存获取数据的类，并将其作为参数传入。

实例方法对象也具有属性:?m.__self__?就是带有?m()?方法的实例对象，而?m.__func__?则是该方法所对应的函数对象。

9.8.?迭代器

到目前为止，您可能已经注意到大多数容器对象都可以使用?for?语句:

for element in [1, 2, 3]:
    print(element)
for element in (1, 2, 3):
    print(element)
for key in {'one':1, 'two':2}:
    print(key)
for char in "123":
    print(char)
for line in open("myfile.txt"):
    print(line, end='')

这种访问风格清晰、简洁又方便。迭代器的使用非常普遍并使得 Python 成为一个统一的整体。在幕后，for?语句会在容器对象上调用?iter()。该函数返回一个定义了?__next__()?方法的迭代器对象，此方法将逐一访问容器中的元素。当元素用尽时，__next__()?将引发?StopIteration?异常来通知终止?for?循环。你可以使用?next()?内置函数来调用?__next__()?方法；这个例子显示了它的运作方式:

>>>

>>> s = 'abc'
>>> it = iter(s)
>>> it
<str_iterator object at 0x10c90e650>
>>> next(it)
'a'
>>> next(it)
'b'
>>> next(it)
'c'
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    next(it)
StopIteration

看过迭代器协议的幕后机制，给你的类添加迭代器行为就很容易了。定义一个?__iter__()?方法来返回一个带有?__next__()?方法的对象。如果类已定义了?__next__()，则?__iter__()?可以简单地返回?self:

class Reverse:
    """Iterator for looping over a sequence backwards."""
    def __init__(self, data):
        self.data = data
        self.index = len(data)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]

>>>

>>> rev = Reverse('spam')
>>> iter(rev)
<__main__.Reverse object at 0x00A1DB50>
>>> for char in rev:
...     print(char)
...
m
a
p
s

9.9.?生成器

生成器?是一个用于创建迭代器的简单而强大的工具。它们的写法类似于标准的函数，但当它们要返回数据时会使用?yield?语句。每次在生成器上调用?next()?时，它会从上次离开的位置恢复执行（它会记住上次执行语句时的所有数据值）。一个显示如何非常容易地创建生成器的示例如下:

def reverse(data):
    for index in range(len(data)-1, -1, -1):
        yield data[index]

>>>

>>> for char in reverse('golf'):
...     print(char)
...
f
l
o
g

可以用生成器来完成的操作同样可以用前一节所描述的基于类的迭代器来完成。但生成器的写法更为紧凑，因为它会自动创建?__iter__()?和?__next__()?方法。

另一个关键特性在于局部变量和执行状态会在每次调用之间自动保存。这使得该函数相比使用?self.index?和?self.data?这种实例变量的方式更易编写且更为清晰。

除了会自动创建方法和保存程序状态，当生成器终结时，它们还会自动引发?StopIteration。这些特性结合在一起，使得创建迭代器能与编写常规函数一样容易。

9.10.?生成器表达式

某些简单的生成器可以写成简洁的表达式代码，所用语法类似列表推导式，但外层为圆括号而非方括号。这种表达式被设计用于生成器将立即被外层函数所使用的情况。生成器表达式相比完整的生成器更紧凑但较不灵活，相比等效的列表推导式则更为节省内存。

示例:

>>>

>>> sum(i*i for i in range(10))                 # sum of squares
285

>>> xvec = [10, 20, 30]
>>> yvec = [7, 5, 3]
>>> sum(x*y for x,y in zip(xvec, yvec))         # dot product
260

>>> unique_words = set(word for line in page  for word in line.split())

>>> valedictorian = max((student.gpa, student.name) for student in graduates)

>>> data = 'golf'
>>> list(data[i] for i in range(len(data)-1, -1, -1))
['f', 'l', 'o', 'g']

备注

存在一个例外。模块对象有一个秘密的只读属性?__dict__，它返回用于实现模块命名空间的字典；__dict__?是属性但不是全局名称。显然，使用这个将违反命名空间实现的抽象，应当仅被用于事后调试器之类的场合。

10.?标准库简介

10.1.?操作系统接口

os?模块提供了许多与操作系统交互的函数:

>>>

>>> import os
>>> os.getcwd()      # Return the current working directory
'C:\\Python311'
>>> os.chdir('/server/accesslogs')   # Change current working directory
>>> os.system('mkdir today')   # Run the command mkdir in the system shell
0

一定要使用?import?os?而不是?from?os?import?*?。这将避免内建的?open()?函数被?os.open()?隐式替换掉，因为它们的使用方式大不相同。

内置的?dir()?和?help()?函数可用作交互式辅助工具，用于处理大型模块，如?os:

>>>

>>> import os
>>> dir(os)
<returns a list of all module functions>
>>> help(os)
<returns an extensive manual page created from the module's docstrings>

对于日常文件和目录管理任务，?shutil?模块提供了更易于使用的更高级别的接口:

>>>

>>> import shutil
>>> shutil.copyfile('data.db', 'archive.db')
'archive.db'
>>> shutil.move('/build/executables', 'installdir')
'installdir'

10.2.?文件通配符

glob?模块提供了一个在目录中使用通配符搜索创建文件列表的函数:

>>>

>>> import glob
>>> glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']

10.3.?命令行参数

通用实用程序脚本通常需要处理命令行参数。这些参数作为列表存储在?sys?模块的?argv?属性中。例如，以下输出来自在命令行运行?python?demo.py?one?two?three

>>>

>>> import sys
>>> print(sys.argv)
['demo.py', 'one', 'two', 'three']

argparse?模块提供了一种更复杂的机制来处理命令行参数。以下脚本可提取一个或多个文件名，并可选择要显示的行数:

import argparse

parser = argparse.ArgumentParser(
    prog='top',
    description='Show top lines from each file')
parser.add_argument('filenames', nargs='+')
parser.add_argument('-l', '--lines', type=int, default=10)
args = parser.parse_args()
print(args)

当在通过?python?top.py?--lines=5?alpha.txt?beta.txt?在命令行运行时，该脚本会将?args.lines?设为?5?并将?args.filenames?设为?['alpha.txt',?'beta.txt']。

10.4.?错误输出重定向和程序终止

sys?模块还具有?stdin?，?stdout?和?stderr?的属性。后者对于发出警告和错误消息非常有用，即使在?stdout?被重定向后也可以看到它们:

>>>

>>> sys.stderr.write('Warning, log file not found starting a new one\n')
Warning, log file not found starting a new one

终止脚本的最直接方法是使用?sys.exit()?。

10.5.?字符串模式匹配

re?模块为高级字符串处理提供正则表达式工具。对于复杂的匹配和操作，正则表达式提供简洁，优化的解决方案:

>>>

>>> import re
>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'

当只需要简单的功能时，首选字符串方法因为它们更容易阅读和调试:

>>>

>>> 'tea for too'.replace('too', 'two')
'tea for two'

10.6.?数学

math?模块提供对浮点数学的底层C库函数的访问:

>>>

>>> import math
>>> math.cos(math.pi / 4)
0.70710678118654757
>>> math.log(1024, 2)
10.0

random?模块提供了进行随机选择的工具:

>>>

>>> import random
>>> random.choice(['apple', 'pear', 'banana'])
'apple'
>>> random.sample(range(100), 10)   # sampling without replacement
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
>>> random.random()    # random float
0.17970987693706186
>>> random.randrange(6)    # random integer chosen from range(6)
4

statistics?模块计算数值数据的基本统计属性（均值，中位数，方差等）:

>>>

>>> import statistics
>>> data = [2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5]
>>> statistics.mean(data)
1.6071428571428572
>>> statistics.median(data)
1.25
>>> statistics.variance(data)
1.3720238095238095

SciPy项目 <https://scipy.org> 有许多其他模块用于数值计算。

10.7.?互联网访问

有许多模块可用于访问互联网和处理互联网协议。其中两个最简单的?urllib.request?用于从URL检索数据，以及?smtplib?用于发送邮件:

>>>

>>> from urllib.request import urlopen
>>> with urlopen('http://worldtimeapi.org/api/timezone/etc/UTC.txt') as response:
...     for line in response:
...         line = line.decode()             # Convert bytes to a str
...         if line.startswith('datetime'):
...             print(line.rstrip())         # Remove trailing newline
...
datetime: 2022-01-01T01:36:47.689215+00:00

>>> import smtplib
>>> server = smtplib.SMTP('localhost')
>>> server.sendmail('soothsayer@example.org', 'jcaesar@example.org',
... """To: jcaesar@example.org
... From: soothsayer@example.org
...
... Beware the Ides of March.
... """)
>>> server.quit()

（请注意，第二个示例需要在localhost上运行的邮件服务器。）

10.8.?日期和时间

datetime?模块提供了以简单和复杂的方式操作日期和时间的类。虽然支持日期和时间算法，但实现的重点是有效的成员提取以进行输出格式化和操作。该模块还支持可感知时区的对象。

>>>

>>> # dates are easily constructed and formatted
>>> from datetime import date
>>> now = date.today()
>>> now
datetime.date(2003, 12, 2)
>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.'

>>> # dates support calendar arithmetic
>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> age.days
14368

10.9.?数据压缩

常见的数据存档和压缩格式由模块直接支持，包括：zlib,?gzip,?bz2,?lzma,?zipfile?和?tarfile。:

>>>

>>> import zlib
>>> s = b'witch which has which witches wrist watch'
>>> len(s)
41
>>> t = zlib.compress(s)
>>> len(t)
37
>>> zlib.decompress(t)
b'witch which has which witches wrist watch'
>>> zlib.crc32(s)
226805979

10.10.?性能测量

一些Python用户对了解同一问题的不同方法的相对性能产生了浓厚的兴趣。 Python提供了一种可以立即回答这些问题的测量工具。

例如，元组封包和拆包功能相比传统的交换参数可能更具吸引力。timeit?模块可以快速演示在运行效率方面一定的优势:

>>>

>>> from timeit import Timer
>>> Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
0.57535828626024577
>>> Timer('a,b = b,a', 'a=1; b=2').timeit()
0.54962537085770791

与?timeit?的精细粒度级别相反，?profile?和?pstats?模块提供了用于在较大的代码块中识别时间关键部分的工具。

10.11.?质量控制

开发高质量软件的一种方法是在开发过程中为每个函数编写测试，并在开发过程中经常运行这些测试。

doctest?模块提供了一个工具，用于扫描模块并验证程序文档字符串中嵌入的测试。测试构造就像将典型调用及其结果剪切并粘贴到文档字符串一样简单。这通过向用户提供示例来改进文档，并且它允许doctest模块确保代码保持对文档的真实:

def average(values):
    """Computes the arithmetic mean of a list of numbers.

    >>> print(average([20, 30, 70]))
    40.0
    """
    return sum(values) / len(values)

import doctest
doctest.testmod()   # automatically validate the embedded tests

unittest?模块不像?doctest?模块那样易于使用，但它允许在一个单独的文件中维护更全面的测试集:

import unittest

class TestStatisticalFunctions(unittest.TestCase):

    def test_average(self):
        self.assertEqual(average([20, 30, 70]), 40.0)
        self.assertEqual(round(average([1, 5, 7]), 1), 4.3)
        with self.assertRaises(ZeroDivisionError):
            average([])
        with self.assertRaises(TypeError):
            average(20, 30, 70)

unittest.main()  # Calling from the command line invokes all tests

10.12.?自带电池

Python有“自带电池”的理念。通过其包的复杂和强大功能可以最好地看到这一点。例如:

xmlrpc.client?和?xmlrpc.server?模块使得实现远程过程调用变成了小菜一碟。尽管存在于模块名称中，但用户不需要直接了解或处理 XML。
?email?包是一个用于管理电子邮件的库，包括MIME和其他符合?RFC 2822?规范的邮件文档。与?smtplib?和?poplib?不同（它们实际上做的是发送和接收消息），电子邮件包提供完整的工具集，用于构建或解码复杂的消息结构（包括附件）以及实现互联网编码和标头协议。
?json?包为解析这种流行的数据交换格式提供了强大的支持。?csv?模块支持以逗号分隔值格式直接读取和写入文件，这种格式通常为数据库和电子表格所支持。 XML 处理由?xml.etree.ElementTree?，?xml.dom?和?xml.sax?包支持。这些模块和软件包共同大大简化了 Python 应用程序和其他工具之间的数据交换。
?sqlite3?模块是 SQLite 数据库库的包装器，提供了一个可以使用稍微非标准的 SQL 语法更新和访问的持久数据库。
国际化由许多模块支持，包括?gettext?，?locale?，以及?codecs?包。

11.?标准库简介 —— 第二部分

第二部分涵盖了专业编程所需要的更高级的模块。这些模块很少用在小脚本中。

11.1.?格式化输出

reprlib?模块提供了一个定制化版本的?repr()?函数，用于缩略显示大型或深层嵌套的容器对象:

>>>

>>> import reprlib
>>> reprlib.repr(set('supercalifragilisticexpialidocious'))
"{'a', 'c', 'd', 'e', 'f', 'g', ...}"

pprint?模块提供了更加复杂的打印控制，其输出的内置对象和用户自定义对象能够被解释器直接读取。当输出结果过长而需要折行时，“美化输出机制”会添加换行符和缩进，以更清楚地展示数据结构:

>>>

>>> import pprint
>>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',
...     'yellow'], 'blue']]]
...
>>> pprint.pprint(t, width=30)
[[[['black', 'cyan'],
   'white',
   ['green', 'red']],
  [['magenta', 'yellow'],
   'blue']]]

textwrap?模块能够格式化文本段落，以适应给定的屏幕宽度:

>>>

>>> import textwrap
>>> doc = """The wrap() method is just like fill() except that it returns
... a list of strings instead of one big string with newlines to separate
... the wrapped lines."""
...
>>> print(textwrap.fill(doc, width=40))
The wrap() method is just like fill()
except that it returns a list of strings
instead of one big string with newlines
to separate the wrapped lines.

locale?模块处理与特定地域文化相关的数据格式。locale 模块的 format 函数包含一个 grouping 属性，可直接将数字格式化为带有组分隔符的样式:

>>>

>>> import locale
>>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')
'English_United States.1252'
>>> conv = locale.localeconv()          # get a mapping of conventions
>>> x = 1234567.8
>>> locale.format("%d", x, grouping=True)
'1,234,567'
>>> locale.format_string("%s%.*f", (conv['currency_symbol'],
...                      conv['frac_digits'], x), grouping=True)
'$1,234,567.80'

11.2.?模板

string?模块包含一个通用的?Template?类，具有适用于最终用户的简化语法。它允许用户在不更改应用逻辑的情况下定制自己的应用。

上述格式化操作是通过占位符实现的，占位符由?$?加上合法的 Python 标识符（只能包含字母、数字和下划线）构成。一旦使用花括号将占位符括起来，就可以在后面直接跟上更多的字母和数字而无需空格分割。$$?将被转义成单个字符?$:

>>>

>>> from string import Template
>>> t = Template('${village}folk send $$10 to $cause.')
>>> t.substitute(village='Nottingham', cause='the ditch fund')
'Nottinghamfolk send $10 to the ditch fund.'

如果在字典或关键字参数中未提供某个占位符的值，那么?substitute()?方法将抛出?KeyError。对于邮件合并类型的应用，用户提供的数据有可能是不完整的，此时使用?safe_substitute()?方法更加合适 —— 如果数据缺失，它会直接将占位符原样保留。

>>>

>>> t = Template('Return the $item to $owner.')
>>> d = dict(item='unladen swallow')
>>> t.substitute(d)
Traceback (most recent call last):
  ...
KeyError: 'owner'
>>> t.safe_substitute(d)
'Return the unladen swallow to $owner.'

Template 的子类可以自定义分隔符。例如，以下是某个照片浏览器的批量重命名功能，采用了百分号作为日期、照片序号和照片格式的占位符:

>>>

>>> import time, os.path
>>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']
>>> class BatchRename(Template):
...     delimiter = '%'
>>> fmt = input('Enter rename style (%d-date %n-seqnum %f-format):  ')
Enter rename style (%d-date %n-seqnum %f-format):  Ashley_%n%f

>>> t = BatchRename(fmt)
>>> date = time.strftime('%d%b%y')
>>> for i, filename in enumerate(photofiles):
...     base, ext = os.path.splitext(filename)
...     newname = t.substitute(d=date, n=i, f=ext)
...     print('{0} --> {1}'.format(filename, newname))

img_1074.jpg --> Ashley_0.jpg
img_1076.jpg --> Ashley_1.jpg
img_1077.jpg --> Ashley_2.jpg

模板的另一个应用是将程序逻辑与多样的格式化输出细节分离开来。这使得对 XML 文件、纯文本报表和 HTML 网络报表使用自定义模板成为可能。

11.3.?使用二进制数据记录格式

struct?模块提供了?pack()?和?unpack()?函数，用于处理不定长度的二进制记录格式。下面的例子展示了在不使用?zipfile?模块的情况下，如何循环遍历一个 ZIP 文件的所有头信息。Pack 代码?"H"?和?"I"?分别代表两字节和四字节无符号整数。"<"?代表它们是标准尺寸的小端字节序:

import struct

with open('myfile.zip', 'rb') as f:
    data = f.read()

start = 0
for i in range(3):                      # show the first 3 file headers
    start += 14
    fields = struct.unpack('<IIIHH', data[start:start+16])
    crc32, comp_size, uncomp_size, filenamesize, extra_size = fields

    start += 16
    filename = data[start:start+filenamesize]
    start += filenamesize
    extra = data[start:start+extra_size]
    print(filename, hex(crc32), comp_size, uncomp_size)

    start += extra_size + comp_size     # skip to the next header

11.4.?多线程

线程是一种对于非顺序依赖的多个任务进行解耦的技术。多线程可以提高应用的响应效率，当接收用户输入的同时，保持其他任务在后台运行。一个有关的应用场景是，将 I/O 和计算运行在两个并行的线程中。

以下代码展示了高阶的?threading?模块如何在后台运行任务，且不影响主程序的继续运行:

import threading, zipfile

class AsyncZip(threading.Thread):
    def __init__(self, infile, outfile):
        threading.Thread.__init__(self)
        self.infile = infile
        self.outfile = outfile

    def run(self):
        f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)
        f.write(self.infile)
        f.close()
        print('Finished background zip of:', self.infile)

background = AsyncZip('mydata.txt', 'myarchive.zip')
background.start()
print('The main program continues to run in foreground.')

background.join()    # Wait for the background task to finish
print('Main program waited until background was done.')

多线程应用面临的主要挑战是，相互协调的多个线程之间需要共享数据或其他资源。为此，threading 模块提供了多个同步操作原语，包括线程锁、事件、条件变量和信号量。

尽管这些工具非常强大，但微小的设计错误却可以导致一些难以复现的问题。因此，实现多任务协作的首选方法是将所有对资源的请求集中到一个线程中，然后使用?queue?模块向该线程供应来自其他线程的请求。应用程序使用?Queue?对象进行线程间通信和协调，更易于设计，更易读，更可靠。

11.5.?日志记录

logging?模块提供功能齐全且灵活的日志记录系统。在最简单的情况下，日志消息被发送到文件或?sys.stderr

import logging
logging.debug('Debugging information')
logging.info('Informational message')
logging.warning('Warning:config file %s not found', 'server.conf')
logging.error('Error occurred')
logging.critical('Critical error -- shutting down')

这会产生以下输出:

WARNING:root:Warning:config file server.conf not found
ERROR:root:Error occurred
CRITICAL:root:Critical error -- shutting down

默认情况下，informational 和 debugging 消息被压制，输出会发送到标准错误流。其他输出选项包括将消息转发到电子邮件，数据报，套接字或 HTTP 服务器。新的过滤器可以根据消息优先级选择不同的路由方式：DEBUG，INFO，WARNING，ERROR，和?CRITICAL。

日志系统可以直接从 Python 配置，也可以从用户配置文件加载，以便自定义日志记录而无需更改应用程序。

11.6.?弱引用

Python 会自动进行内存管理（对大多数对象进行引用计数并使用?garbage collection?来清除循环引用）。当某个对象的最后一个引用被移除后不久就会释放其所占用的内存。

此方式对大多数应用来说都适用，但偶尔也必须在对象持续被其他对象所使用时跟踪它们。不幸的是，跟踪它们将创建一个会令其永久化的引用。?weakref?模块提供的工具可以不必创建引用就能跟踪对象。当对象不再需要时，它将自动从一个弱引用表中被移除，并为弱引用对象触发一个回调。典型应用包括对创建开销较大的对象进行缓存:

>>>

>>> import weakref, gc
>>> class A:
...     def __init__(self, value):
...         self.value = value
...     def __repr__(self):
...         return str(self.value)
...
>>> a = A(10)                   # create a reference
>>> d = weakref.WeakValueDictionary()
>>> d['primary'] = a            # does not create a reference
>>> d['primary']                # fetch the object if it is still alive
10
>>> del a                       # remove the one reference
>>> gc.collect()                # run garbage collection right away
0
>>> d['primary']                # entry was automatically removed
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    d['primary']                # entry was automatically removed
  File "C:/python311/lib/weakref.py", line 46, in __getitem__
    o = self.data[key]()
KeyError: 'primary'

11.7.?用于操作列表的工具

许多对于数据结构的需求可以通过内置列表类型来满足。但是，有时也会需要具有不同效费比的替代实现。

array?模块提供了一种?array()?对象，它类似于列表，但只能存储类型一致的数据且存储密集更高。下面的例子演示了一个以两个字节为存储单元的无符号二进制数值的数组 (类型码为?"H")，而对于普通列表来说，每个条目存储为标准 Python 的 int 对象通常要占用16 个字节:

>>>

>>> from array import array
>>> a = array('H', [4000, 10, 700, 22222])
>>> sum(a)
26932
>>> a[1:3]
array('H', [10, 700])

collections?模块提供了一种?deque()?对象，它类似于列表，但从左端添加和弹出的速度较快，而在中间查找的速度较慢。此种对象适用于实现队列和广度优先树搜索:

>>>

>>> from collections import deque
>>> d = deque(["task1", "task2", "task3"])
>>> d.append("task4")
>>> print("Handling", d.popleft())
Handling task1

unsearched = deque([starting_node])
def breadth_first_search(unsearched):
    node = unsearched.popleft()
    for m in gen_moves(node):
        if is_goal(m):
            return m
        unsearched.append(m)

在替代的列表实现以外，标准库也提供了其他工具，例如?bisect?模块具有用于操作有序列表的函数:

>>>

>>> import bisect
>>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]
>>> bisect.insort(scores, (300, 'ruby'))
>>> scores
[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]

heapq?模块提供了基于常规列表来实现堆的函数。最小值的条目总是保持在位置零。这对于需要重复访问最小元素而不希望运行完整列表排序的应用来说非常有用:

>>>

>>> from heapq import heapify, heappop, heappush
>>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
>>> heapify(data)                      # rearrange the list into heap order
>>> heappush(data, -5)                 # add a new entry
>>> [heappop(data) for i in range(3)]  # fetch the three smallest entries
[-5, 0, 1]

11.8.?十进制浮点运算

decimal?模块提供了一种?Decimal?数据类型用于十进制浮点运算。相比内置的?float?二进制浮点实现，该类特别适用于

财务应用和其他需要精确十进制表示的用途，
控制精度，
控制四舍五入以满足法律或监管要求，
跟踪有效小数位，或
用户期望结果与手工完成的计算相匹配的应用程序。

例如，使用十进制浮点和二进制浮点数计算70美分手机和5％税的总费用，会产生的不同结果。如果结果四舍五入到最接近的分数差异会更大:

>>>

>>> from decimal import *
>>> round(Decimal('0.70') * Decimal('1.05'), 2)
Decimal('0.74')
>>> round(.70 * 1.05, 2)
0.73

Decimal?表示的结果会保留尾部的零，并根据具有两个有效位的被乘数自动推出四个有效位。 Decimal 可以模拟手工运算来避免当二进制浮点数无法精确表示十进制数时会导致的问题。

精确表示特性使得?Decimal?类能够执行对于二进制浮点数来说不适用的模运算和相等性检测:

>>>

>>> Decimal('1.00') % Decimal('.10')
Decimal('0.00')
>>> 1.00 % 0.10
0.09999999999999995

>>> sum([Decimal('0.1')]*10) == Decimal('1.0')
True
>>> sum([0.1]*10) == 1.0
False

decimal?模块提供了运算所需要的足够精度:

>>>

>>> getcontext().prec = 36
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857')

6.?表达式

本章将解释 Python 中组成表达式的各种元素的的含义。

语法注释:?在本章和后续章节中，会使用扩展 BNF 标注来描述语法而不是词法分析。当（某种替代的）语法规则具有如下形式

name ::=  othername

并且没有给出语义，则这种形式的?name?在语法上与?othername?相同。

6.1.?算术转换

当对下述某个算术运算符的描述中使用了“数值参数被转换为普通类型”这样的说法，这意味着内置类型的运算符实现采用了如下运作方式:

如果任一参数为复数，另一参数会被转换为复数；
否则，如果任一参数为浮点数，另一参数会被转换为浮点数；
否则，两者应该都为整数，不需要进行转换。

某些附加规则会作用于特定运算符（例如，字符串作为 '%' 运算符的左运算参数）。扩展必须定义它们自己的转换行为。

6.2.?原子

“原子”指表达式的最基本构成元素。最简单的原子是标识符和字面值。以圆括号、方括号或花括号包括的形式在语法上也被归类为原子。原子的句法为:

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom

6.2.1.?标识符（名称）

作为原子出现的标识符叫做名称。请参看?标识符和关键字?一节了解其词法定义，以及?命名与绑定?获取有关命名与绑定的文档。

当名称被绑定到一个对象时，对该原子求值将返回相应对象。当名称未被绑定时，尝试对其求值将引发?NameError?异常。

私有名称转换:?当以文本形式出现在类定义中的一个标识符以两个或更多下划线开头并且不以两个或更多下划线结尾，它会被视为该类的?私有名称。私有名称会在为其生成代码之前被转换为一种更长的形式。转换时会插入类名，移除打头的下划线再在名称前增加一个下划线。例如，出现在一个名为?Ham?的类中的标识符?__spam?会被转换为?_Ham__spam。这种转换独立于标识符所使用的相关句法。如果转换后的名称太长（超过 255 个字符），可能发生由具体实现定义的截断。如果类名仅由下划线组成，则不会进行转换。

6.2.2.?字面值

Python 支持字符串和字节串字面值，以及几种数字字面值:

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber

对字面值求值将返回一个该值所对应类型的对象（字符串、字节串、整数、浮点数、复数）。对于浮点数和虚数（复数）的情况，该值可能为近似值。详情参见?字面值。

所有字面值都对应与不可变数据类型，因此对象标识的重要性不如其实际值。多次对具有相同值的字面值求值（不论是发生在程序文本的相同位置还是不同位置）可能得到相同对象或是具有相同值的不同对象。

6.2.3.?带圆括号的形式

带圆括号的形式是包含在圆括号中的可选表达式列表。

parenth_form ::=  "(" [starred_expression] ")"

带圆括号的表达式列表将返回该表达式列表所产生的任何东西：如果该列表包含至少一个逗号，它会产生一个元组；否则，它会产生该表达式列表所对应的单一表达式。

一对内容为空的圆括号将产生一个空的元组对象。由于元组是不可变对象，因此适用与字面值相同的规则（即两次出现的空元组产生的对象可能相同也可能不同）。

请注意元组并不是由圆括号构建，实际起作用的是逗号操作符。例外情况是空元组，这时圆括号?才是?必须的 --- 允许在表达式中使用不带圆括号的 "空" 会导致歧义，并会造成常见输入错误无法被捕获。

6.2.4.?列表、集合与字典的显示

为了构建列表、集合或字典，Python 提供了名为“显示”的特殊句法，每个类型各有两种形式:

第一种是显式地列出容器内容
第二种是通过一组循环和筛选指令计算出来，称为?推导式。

推导式的常用句法元素为:

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]

推导式的结构是一个单独表达式后面加至少一个?for?子句以及零个或更多个?for?或?if?子句。在这种情况下，新容器的元素产生方式是将每个?for?或?if?子句视为一个代码块，按从左至右的顺序嵌套，然后每次到达最内层代码块时就对表达式进行求值以产生一个元素。

不过，除了最左边?for?子句中的可迭代表达式，推导式是在另一个隐式嵌套的作用域内执行的。这能确保赋给目标列表的名称不会“泄露”到外层的作用域。

最左边的?for?子句中的可迭代对象表达式会直接在外层作用域中被求值，然后作为一个参数被传给隐式嵌套的作用域。后续的?for?子句以及最左侧?for?子句中的任何筛选条件不能在外层作用域中被求值，因为它们可能依赖于从最左侧可迭代对象中获得的值。例如:?[x*y?for?x?in?range(10)?for?y?in?range(x,?x+10)]。

为了确保推导式得出的结果总是一个类型正确的容器，在隐式嵌套作用域内禁止使用?yield?和?yield?from?表达式。

Since Python 3.6, in an?async?def?function, an?async?for?clause may be used to iterate over a?asynchronous iterator. A comprehension in an?async?def?function may consist of either a?for?or?async?for?clause following the leading expression, may contain additional?for?or?async?for?clauses, and may also use?await?expressions. If a comprehension contains either?async?for?clauses or?await?expressions or other asynchronous comprehensions it is called an?asynchronous comprehension. An asynchronous comprehension may suspend the execution of the coroutine function in which it appears. See also?PEP 530.

3.6 新版功能:?引入了异步推导式。

在 3.8 版更改:?yield?和?yield?from?在隐式嵌套的作用域中已被禁用。

在 3.11 版更改:?Asynchronous comprehensions are now allowed inside comprehensions in asynchronous functions. Outer comprehensions implicitly become asynchronous.

6.2.5.?列表显示

列表显示是一个用方括号括起来的可能为空的表达式系列:

list_display ::=  "[" [starred_list | comprehension] "]"

列表显示会产生一个新的列表对象，其内容通过一系列表达式或一个推导式来指定。当提供由逗号分隔的一系列表达式时，其元素会从左至右被求值并按此顺序放入列表对象。当提供一个推导式时，列表会根据推导式所产生的结果元素进行构建。

6.2.6.?集合显示

集合显示是用花括号标明的，与字典显示的区别在于没有冒号分隔的键和值:

set_display ::=  "{" (starred_list | comprehension) "}"

集合显示会产生一个新的可变集合对象，其内容通过一系列表达式或一个推导式来指定。当提供由逗号分隔的一系列表达式时，其元素会从左至右被求值并加入到集合对象。当提供一个推导式时，集合会根据推导式所产生的结果元素进行构建。

空集合不能用?{}?来构建；该字面值所构建的是一个空字典。

6.2.7.?字典显示

字典显示是一个用花括号括起来的可能为空的键/数据对系列:

dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for

字典显示会产生一个新的字典对象。

如果给出一个由逗号分隔的键/数据对序列，它们会从左至右被求值以定义字典的条目：每个键对象会被用作在字典中存放相应数据的键。这意味着你可以在键/数据对序列中多次指定相同的键，最终字典的值将由最后一次给出的键决定。

双星号?**?表示?字典拆包。它的操作数必须是一个?mapping。每个映射项被会加入新的字典。后续的值会替代先前的键/数据对和先前的字典拆包所设置的值。

3.5 新版功能:?拆包到字典显示，最初由?PEP 448?提出。

字典推导式与列表和集合推导式有所不同，它需要以冒号分隔的两个表达式，后面带上标准的 "for" 和 "if" 子句。当推导式被执行时，作为结果的键和值元素会按它们的产生顺序被加入新的字典。

对键取值类型的限制已列在之前的?标准类型层级结构?一节中。 (总的说来，键的类型应该为?hashable，这就把所有可变对象都排除在外。) 重复键之间的冲突不会被检测；指定键所保存的最后一个数据 (即在显示中排最右边的文本) 为最终有效数据。

在 3.8 版更改:?在 Python 3.8 之前的字典推导式中，并没有定义好键和值的求值顺序。在 CPython 中，值会先于键被求值。根据?PEP 572?的提议，从 3.8 开始，键会先于值被求值。

6.2.8.?生成器表达式

生成器表达式是用圆括号括起来的紧凑形式生成器标注。

generator_expression ::=  "(" expression comp_for ")"

生成器表达式会产生一个新的生成器对象。其句法与推导式相同，区别在于它是用圆括号而不是用方括号或花括号括起来的。

在生成器表达式中使用的变量会在为生成器对象调用?__next__()?方法的时候以惰性方式被求值（即与普通生成器相同的方式）。但是，最左侧?for?子句内的可迭代对象是会被立即求值的，因此它所造成的错误会在生成器表达式被定义时被检测到，而不是在获取第一个值时才出错。后续的?for?子句以及最左侧?for?子句内的任何筛选条件无法在外层作用域内被求值，因为它们可能会依赖于从最左侧可迭代对象获取的值。例如:?(x*y?for?x?in?range(10)?for?y?in?range(x,?x+10)).

圆括号在只附带一个参数的调用中可以被省略。详情参见?调用?一节。

为了避免干扰到生成器表达式本身的预期操作，禁止在隐式定义的生成器中使用?yield?和?yield?from?表达式。

如果生成器表达式包含?async?for?子句或?await?表达式，则称为?异步生成器表达式。异步生成器表达式会返回一个新的异步生成器对象，此对象属于异步迭代器 (参见?异步迭代器)。

3.6 新版功能:?引入了异步生成器表达式。

在 3.7 版更改:?在 Python 3.7 之前，异步生成器表达式只能在?async?def?协和中出现。从 3.7 开始，任何函数都可以使用异步生成器表达式。

在 3.8 版更改:?yield?和?yield?from?在隐式嵌套的作用域中已被禁用。

6.2.9.?yield 表达式

yield_atom       ::=  "(" yield_expression ")"
yield_expression ::=  "yield" [expression_list | "from" expression]

The yield expression is used when defining a?generator?function or an?asynchronous generator?function and thus can only be used in the body of a function definition. Using a yield expression in a function's body causes that function to be a generator function, and using it in an?async?def?function's body causes that coroutine function to be an asynchronous generator function. For example:

def gen():  # defines a generator function
    yield 123

async def agen(): # defines an asynchronous generator function
    yield 123

由于它们会对外层作用域造成附带影响，yield?表达式不被允许作为用于实现推导式和生成器表达式的隐式定义作用域的一部分。

在 3.8 版更改:?禁止在实现推导式和生成器表达式的隐式嵌套作用域中使用 yield 表达式。

下面是对生成器函数的描述，异步生成器函数会在?异步生成器函数?一节中单独介绍。

When a generator function is called, it returns an iterator known as a generator. That generator then controls the execution of the generator function. The execution starts when one of the generator's methods is called. At that time, the execution proceeds to the first yield expression, where it is suspended again, returning the value of?expression_list?to the generator's caller. By suspended, we mean that all local state is retained, including the current bindings of local variables, the instruction pointer, the internal evaluation stack, and the state of any exception handling. When the execution is resumed by calling one of the generator's methods, the function can proceed exactly as if the yield expression were just another external call. The value of the yield expression after resuming depends on the method which resumed the execution. If?__next__()?is used (typically via either a?for?or the?next()?builtin) then the result is?None. Otherwise, if?send()?is used, then the result will be the value passed in to that method.

所有这些使生成器函数与协程非常相似；它们 yield 多次，它们具有多个入口点，并且它们的执行可以被挂起。唯一的区别是生成器函数不能控制在它在 yield 后交给哪里继续执行；控制权总是转移到生成器的调用者。

在?try?结构中的任何位置都允许yield表达式。如果生成器在(因为引用计数到零或是因为被垃圾回收)销毁之前没有恢复执行，将调用生成器-迭代器的?close()?方法. close 方法允许任何挂起的?finally?子句执行。

当使用?yield?from?<expr>?时，所提供的表达式必须是一个可迭代对象。迭代该可迭代对象所产生的值会被直接传递给当前生成器方法的调用者。任何通过?send()?传入的值以及任何通过?throw()?传入的异常如果有适当的方法则会被传给下层迭代器。如果不是这种情况，那么?send()?将引发?AttributeError?或?TypeError，而?throw()?将立即引发所转入的异常。

当下层迭代器完成时，被引发的?StopIteration?实例的?value?属性会成为 yield 表达式的值。它可以在引发?StopIteration?时被显式地设置，也可以在子迭代器是一个生成器时自动地设置（通过从子生成器返回一个值）。

在 3.3 版更改:?添加?yield?from?<expr>?以委托控制流给一个子迭代器。

当yield表达式是赋值语句右侧的唯一表达式时，括号可以省略。

参见

PEP 255?- 简单生成器

在 Python 中加入生成器和?yield?语句的提议。

PEP 342?- 通过增强型生成器实现协程

增强生成器 API 和语法的提议，使其可以被用作简单的协程。

PEP 380?- 委托给子生成器的语法

The proposal to introduce the?yield_from?syntax, making delegation to subgenerators easy.

PEP 525?- 异步生成器

通过给协程函数加入生成器功能对?PEP 492?进行扩展的提议。

6.2.9.1.?生成器-迭代器的方法

这个子小节描述了生成器迭代器的方法。它们可被用于控制生成器函数的执行。

请注意在生成器已经在执行时调用以下任何方法都会引发?ValueError?异常。

generator.__next__()

Starts the execution of a generator function or resumes it at the last executed yield expression. When a generator function is resumed with a?__next__()?method, the current yield expression always evaluates to?None. The execution then continues to the next yield expression, where the generator is suspended again, and the value of the?expression_list?is returned to?__next__()'s caller. If the generator exits without yielding another value, a?StopIteration?exception is raised.

此方法通常是隐式地调用，例如通过?for?循环或是内置的?next()?函数。

generator.send(value)

恢复执行并向生成器函数“发送”一个值。?value?参数将成为当前 yield 表达式的结果。?send()?方法会返回生成器所产生的下一个值，或者如果生成器没有产生下一个值就退出则会引发?StopIteration。当调用?send()?来启动生成器时，它必须以?None?作为调用参数，因为这时没有可以接收值的 yield 表达式。

generator.throw(value)

generator.throw(type[,?value[,?traceback]])

Raises an exception at the point where the generator was paused, and returns the next value yielded by the generator function. If the generator exits without yielding another value, a?StopIteration?exception is raised. If the generator function does not catch the passed-in exception, or raises a different exception, then that exception propagates to the caller.

In typical use, this is called with a single exception instance similar to the way the?raise?keyword is used.

For backwards compatibility, however, the second signature is supported, following a convention from older versions of Python. The?type?argument should be an exception class, and?value?should be an exception instance. If the?value?is not provided, the?type?constructor is called to get an instance. If?traceback?is provided, it is set on the exception, otherwise any existing?__traceback__?attribute stored in?value?may be cleared.

generator.close()

在生成器函数暂停的位置引发?GeneratorExit。如果之后生成器函数正常退出、关闭或引发?GeneratorExit?(由于未捕获该异常) 则关闭并返回其调用者。如果生成器产生了一个值，关闭会引发?RuntimeError。如果生成器引发任何其他异常，它会被传播给调用者。如果生成器已经由于异常或正常退出则?close()?不会做任何事。

6.2.9.2.?例子

这里是一个简单的例子，演示了生成器和生成器函数的行为:

>>>

>>> def echo(value=None):
...     print("Execution starts when 'next()' is called for the first time.")
...     try:
...         while True:
...             try:
...                 value = (yield value)
...             except Exception as e:
...                 value = e
...     finally:
...         print("Don't forget to clean up when 'close()' is called.")
...
>>> generator = echo(1)
>>> print(next(generator))
Execution starts when 'next()' is called for the first time.
1
>>> print(next(generator))
None
>>> print(generator.send(2))
2
>>> generator.throw(TypeError, "spam")
TypeError('spam',)
>>> generator.close()
Don't forget to clean up when 'close()' is called.

对于?yield?from?的例子, 参见“Python 有什么新变化”中的?PEP 380: 委托给子生成器的语法。

6.2.9.3.?异步生成器函数

在一个使用?async?def?定义的函数或方法中出现的 yield 表达式会进一步将该函数定义为一个?asynchronous generator?函数。

当一个异步生成器函数被调用时，它会返回一个名为异步生成器对象的异步迭代器。此对象将在之后控制该生成器函数的执行。异步生成器对象通常被用在协程函数的?async?for?语句中，类似于在?for?语句中使用生成器对象。

Calling one of the asynchronous generator's methods returns an?awaitable?object, and the execution starts when this object is awaited on. At that time, the execution proceeds to the first yield expression, where it is suspended again, returning the value of?expression_list?to the awaiting coroutine. As with a generator, suspension means that all local state is retained, including the current bindings of local variables, the instruction pointer, the internal evaluation stack, and the state of any exception handling. When the execution is resumed by awaiting on the next object returned by the asynchronous generator's methods, the function can proceed exactly as if the yield expression were just another external call. The value of the yield expression after resuming depends on the method which resumed the execution. If?__anext__()?is used then the result is?None. Otherwise, if?asend()?is used, then the result will be the value passed in to that method.

如果一个异步生成器恰好因?break、调用方任务被取消，或是其他异常而提前退出，生成器的异步清理代码将会运行并可能引发异常或访问意外上下文中的上下文变量 -- 也许是在它所依赖的任务的生命周期之后，或是在异步生成器垃圾回收钩子被调用时的事件循环关闭期间。为了防止这种情况，调用方必须通过调用?aclose()?方法来显式地关闭异步生成器以终结生成器并最终从事件循环中将其分离。

在异步生成器函数中，yield 表达式允许出现在?try?结构的任何位置。但是，如果一个异步生成器在其被终结（由于引用计数达到零或被作为垃圾回收）之前未被恢复，则then a yield expression within a?try?结构中的 yield 表达式可能导致挂起的?finally?子句执行失败。在此情况下，应由运行该异步生成器的事件循环或任务调度器来负责调用异步生成器-迭代器的?aclose()?方法并运行所返回的协程对象，从而允许任何挂起的?finally?子句得以执行。

为了能在事件循环终结时执行最终化处理，事件循环应当定义一个?终结器?函数，它接受一个异步生成器迭代器并将调用?aclose()?且执行该协程。这个?终结器?可以通过调用?sys.set_asyncgen_hooks()?来注册。当首次迭代时，异步生成器迭代器将保存已注册的?终结器?以便在最终化时调用。有关?终结器?方法的参考示例请查看在?Lib/asyncio/base_events.py?的中的?asyncio.Loop.shutdown_asyncgens?实现。

yield?from?<expr>?表达式如果在异步生成器函数中使用会引发语法错误。

6.2.9.4.?异步生成器-迭代器方法

这个子小节描述了异步生成器迭代器的方法，它们可被用于控制生成器函数的执行。

coroutine?agen.__anext__()

Returns an awaitable which when run starts to execute the asynchronous generator or resumes it at the last executed yield expression. When an asynchronous generator function is resumed with an?__anext__()?method, the current yield expression always evaluates to?None?in the returned awaitable, which when run will continue to the next yield expression. The value of the?expression_list?of the yield expression is the value of the?StopIteration?exception raised by the completing coroutine. If the asynchronous generator exits without yielding another value, the awaitable instead raises a?StopAsyncIteration?exception, signalling that the asynchronous iteration has completed.

此方法通常是通过?async?for?循环隐式地调用。

coroutine?agen.asend(value)

返回一个可等待对象，它在运行时会恢复该异步生成器的执行。与生成器的?send()?方法一样，此方法会“发送”一个值给异步生成器函数，其?value?参数会成为当前 yield 表达式的结果值。?asend()?方法所返回的可等待对象将返回生成器产生的下一个值，其值为所引发的?StopIteration，或者如果异步生成器没有产生下一个值就退出则引发?StopAsyncIteration。当调用?asend()?来启动异步生成器时，它必须以?None?作为调用参数，因为这时没有可以接收值的 yield 表达式。

coroutine?agen.athrow(type[,?value[,?traceback]])

返回一个可等待对象，它会在异步生成器暂停的位置引发?type?类型的异常，并返回该生成器函数所产生的下一个值，其值为所引发的?StopIteration?异常。如果异步生成器没有产生下一个值就退出，则将由该可等待对象引发?StopAsyncIteration?异步。如果生成器函数没有捕获传入的异常，或引发了另一个异常，则当可等待对象运行时该异常会被传播给可等待对象的调用者。

coroutine?agen.aclose()

返回一个可等待对象，它会在运行时向异步生成器函数暂停的位置抛入一个?GeneratorExit。如果该异步生成器函数正常退出、关闭或引发?GeneratorExit?(由于未捕获该异常) 则返回的可等待对象将引发?StopIteration?异常。后续调用异步生成器所返回的任何其他可等待对象将引发?StopAsyncIteration?异常。如果异步生成器产生了一个值，该可等待对象会引发?RuntimeError。如果异步生成器引发任何其他异常，它会被传播给可等待对象的调用者。如果异步生成器已经由于异常或正常退出则后续调用?aclose()?将返回一个不会做任何事的可等待对象。

6.3.?原型

原型代表编程语言中最紧密绑定的操作。它们的句法如下:

primary ::=  atom | attributeref | subscription | slicing | call

6.3.1.?属性引用

属性引用是后面带有一个句点加一个名称的原型:

attributeref ::=  primary "." identifier

此原型必须求值为一个支持属性引用的类型的对象，多数对象都支持属性引用。随后该对象会被要求产生以指定标识符为名称的属性。这个产生过程可通过重载?__getattr__()?方法来自定义。如果这个属性不可用，则将引发?AttributeError?异常。否则的话，所产生对象的类型和值会根据该对象来确定。对同一属性引用的多次求值可能产生不同的对象。

6.3.2.?抽取

The subscription of an instance of a?container class?will generally select an element from the container. The subscription of a?generic class?will generally return a?GenericAlias?object.

subscription ::=  primary "[" expression_list "]"

When an object is subscripted, the interpreter will evaluate the primary and the expression list.

The primary must evaluate to an object that supports subscription. An object may support subscription through defining one or both of?__getitem__()?and?__class_getitem__(). When the primary is subscripted, the evaluated result of the expression list will be passed to one of these methods. For more details on when?__class_getitem__?is called instead of?__getitem__, see?__class_getitem__ versus __getitem__.

If the expression list contains at least one comma, it will evaluate to a?tuple?containing the items of the expression list. Otherwise, the expression list will evaluate to the value of the list's sole member.

For built-in objects, there are two types of objects that support subscription via?__getitem__():

Mappings. If the primary is a?mapping, the expression list must evaluate to an object whose value is one of the keys of the mapping, and the subscription selects the value in the mapping that corresponds to that key. An example of a builtin mapping class is the?dict?class.
Sequences. If the primary is a?sequence, the expression list must evaluate to an?int?or a?slice?(as discussed in the following section). Examples of builtin sequence classes include the?str,?list?and?tuple?classes.

The formal syntax makes no special provision for negative indices in?sequences. However, built-in sequences all provide a?__getitem__()?method that interprets negative indices by adding the length of the sequence to the index so that, for example,?x[-1]?selects the last item of?x. The resulting value must be a nonnegative integer less than the number of items in the sequence, and the subscription selects the item whose index is that value (counting from zero). Since the support for negative indices and slicing occurs in the object's?__getitem__()?method, subclasses overriding this method will need to explicitly add that support.

A?string?is a special kind of sequence whose items are?characters. A character is not a separate data type but a string of exactly one character.

6.3.3.?切片

切片就是在序列对象（字符串、元组或列表）中选择某个范围内的项。切片可被用作表达式以及赋值或?del?语句的目标。切片的句法如下:

slicing      ::=  primary "[" slice_list "]"
slice_list   ::=  slice_item ("," slice_item)* [","]
slice_item   ::=  expression | proper_slice
proper_slice ::=  [lower_bound] ":" [upper_bound] [ ":" [stride] ]
lower_bound  ::=  expression
upper_bound  ::=  expression
stride       ::=  expression

此处的正式句法中存在一点歧义：任何形似表达式列表的东西同样也会形似切片列表，因此任何抽取操作也可以被解析为切片。为了不使句法更加复杂，于是通过定义将此情况解析为抽取优先于解析为切片来消除这种歧义（切片列表未包含正确的切片就属于此情况）。

切片的语义如下所述。元型通过一个根据下面的切片列表来构造的键进行索引（与普通抽取一样使用?__getitem__()?方法）。如果切片列表包含至少一个逗号，则键将是一个包含切片项转换的元组；否则的话，键将是单个切片项的转换。切片项如为一个表达式，则其转换就是该表达式。一个正确切片的转换就是一个切片对象（参见?标准类型层级结构?一节），该对象的?start,?stop?和?step?属性将分别为表达式所给出的下界、上界和步长值，省略的表达式将用?None?来替换。

6.3.4.?调用

所谓调用就是附带可能为空的一系列?参数?来执行一个可调用对象 (例如?function):

call                 ::=  primary "(" [argument_list [","] | comprehension] ")"
argument_list        ::=  positional_arguments ["," starred_and_keywords]
                            ["," keywords_arguments]
                          | starred_and_keywords ["," keywords_arguments]
                          | keywords_arguments
positional_arguments ::=  positional_item ("," positional_item)*
positional_item      ::=  assignment_expression | "*" expression
starred_and_keywords ::=  ("*" expression | keyword_item)
                          ("," "*" expression | "," keyword_item)*
keywords_arguments   ::=  (keyword_item | "**" expression)
                          ("," keyword_item | "," "**" expression)*
keyword_item         ::=  identifier "=" expression

一个可选项为在位置和关键字参数后加上逗号而不影响语义。

此原型必须求值为一个可调用对象（用户定义的函数，内置函数，内置对象的方法，类对象，类实例的方法以及任何具有?__call__()?方法的对象都是可调用对象）。所有参数表达式将在尝试调用前被求值。请参阅?函数定义?一节了解正式的?parameter?列表句法。

If keyword arguments are present, they are first converted to positional arguments, as follows. First, a list of unfilled slots is created for the formal parameters. If there are N positional arguments, they are placed in the first N slots. Next, for each keyword argument, the identifier is used to determine the corresponding slot (if the identifier is the same as the first formal parameter name, the first slot is used, and so on). If the slot is already filled, a?TypeError?exception is raised. Otherwise, the argument is placed in the slot, filling it (even if the expression is?None, it fills the slot). When all arguments have been processed, the slots that are still unfilled are filled with the corresponding default value from the function definition. (Default values are calculated, once, when the function is defined; thus, a mutable object such as a list or dictionary used as default value will be shared by all calls that don't specify an argument value for the corresponding slot; this should usually be avoided.) If there are any unfilled slots for which no default value is specified, a?TypeError?exception is raised. Otherwise, the list of filled slots is used as the argument list for the call.

CPython implementation detail:?某些实现可能提供位置参数没有名称的内置函数，即使它们在文档说明的场合下有“命名”，因此不能以关键字形式提供参数。在 CPython 中，以 C 编写并使用?PyArg_ParseTuple()?来解析其参数的函数实现就属于这种情况。

如果存在比正式参数空位多的位置参数，将会引发?TypeError?异常，除非有一个正式参数使用了?*identifier?句法；在此情况下，该正式参数将接受一个包含了多余位置参数的元组（如果没有多余位置参数则为一个空元组）。

如果任何关键字参数没有与之对应的正式参数名称，将会引发?TypeError?异常，除非有一个正式参数使用了?**identifier?句法，该正式参数将接受一个包含了多余关键字参数的字典（使用关键字作为键而参数值作为与键对应的值），如果没有多余关键字参数则为一个（新的）空字典。

如果函数调用中出现了?*expression?句法，expression?必须求值为一个?iterable。来自该可迭代对象的元素会被当作是额外的位置参数。对于?f(x1,?x2,?*y,?x3,?x4)?调用，如果?y?求值为一个序列?y1, ...,?yM，则它就等价于一个带有 M+4 个位置参数?x1,?x2,?y1, ...,?yM,?x3,?x4?的调用。

这样做的一个后果是虽然?*expression?句法可能出现于显式的关键字参数?之后，但它会在关键字参数（以及任何?**expression?参数 -- 见下文）?之前?被处理。因此:

>>>

>>> def f(a, b):
...     print(a, b)
...
>>> f(b=1, *(2,))
2 1
>>> f(a=1, *(2,))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() got multiple values for keyword argument 'a'
>>> f(1, *(2,))
1 2

It is unusual for both keyword arguments and the?*expression?syntax to be used in the same call, so in practice this confusion does not often arise.

如果函数调用中出现了?**expression?句法，expression?必须求值为一个?mapping，其内容会被当作是额外的关键字参数。如果一个关键字已存在（作为显式关键字参数，或来自另一个拆包），则将引发?TypeError?异常。

使用?*identifier?或?**identifier?句法的正式参数不能被用作位置参数空位或关键字参数名称。

在 3.5 版更改:?函数调用接受任意数量的?*?和?**?拆包，位置参数可能跟在可迭代对象拆包 (*) 之后，而关键字参数可能跟在字典拆包 (**) 之后。由?PEP 448?发起最初提议。

除非引发了异常，调用总是会有返回值，返回值也可能为?None。返回值的计算方式取决于可调用对象的类型。

如果类型为---

用户自定义函数:

函数的代码块会被执行，并向其传入参数列表。代码块所做的第一件事是将正式形参绑定到对应参数；相关描述参见?函数定义?一节。当代码块执行?return?语句时，由其指定函数调用的返回值。

内置函数或方法:

具体结果依赖于解释器；有关内置函数和方法的描述参见?内置函数。

类对象:

返回该类的一个新实例。

类实例方法:

调用相应的用户自定义函数，向其传入的参数列表会比调用的参数列表多一项：该实例将成为第一个参数。

类实例:

该类必须定义有?__call__()?方法；作用效果将等价于调用该方法。

6.4.?await 表达式

挂起?coroutine?的执行以等待一个?awaitable?对象。只能在?coroutine function?内部使用。

await_expr ::=  "await" primary

3.5 新版功能.

6.5.?幂运算符

幂运算符的绑定比在其左侧的一元运算符更紧密；但绑定紧密程度不及在其右侧的一元运算符。句法如下:

power ::=  (await_expr | primary) ["**" u_expr]

因此，在一个未加圆括号的幂运算符和单目运算符序列中，运算符将从右向左求值（这不会限制操作数的求值顺序）:?-1**2?结果将为?-1。

幂运算符与附带两个参数调用内置?pow()?函数具有相同的语义：结果为对其左参数进行其右参数所指定幂次的乘方运算。数值参数会先转换为相同类型，结果也为转换后的类型。

对于 int 类型的操作数，结果将具有与操作数相同的类型，除非第二个参数为负数；在那种情况下，所有参数会被转换为 float 类型并输出 float 类型的结果。例如，10**2?返回?100，而?10**-2?返回?0.01。

对?0.0?进行负数幂次运算将导致?ZeroDivisionError。对负数进行分数幂次运算将返回?complex?数值。（在早期版本中这将引发?ValueError。）

此运算符可使用特殊的?__pow__()?方法来自定义。

6.6.?一元算术和位运算

所有算术和位运算具有相同的优先级:

u_expr ::=  power | "-" u_expr | "+" u_expr | "~" u_expr

一元的?-?(负值) 运算符会产生其数字参数的负值；该运算可通过?__neg__()?特殊方法来重载。

一元的?+?(正值) 运算符会原样输出其数字参数；该运算可通过?__pos__()?特殊方法来重载。

一元的?~?(取反) 运算符会对其整数参数按位取反。?x?的按位取反被定义为?-(x+1)。它只作用于整数或是重载了?__invert__()?特殊方法的自定义对象。

在所有三种情况下，如果参数的类型不正确，将引发?TypeError?异常。

6.7.?二元算术运算符

二元算术运算符遵循传统的优先级。请注意某些此类运算符也作用于特定的非数字类型。除幂运算符以外只有两个优先级别，一个作用于乘法型运算符，另一个作用于加法型运算符:

m_expr ::=  u_expr | m_expr "*" u_expr | m_expr "@" m_expr |
            m_expr "//" u_expr | m_expr "/" u_expr |
            m_expr "%" u_expr
a_expr ::=  m_expr | a_expr "+" m_expr | a_expr "-" m_expr

运算符?*?(乘) 将输出其参数的乘积。两个参数或者必须都为数字，或者一个参数必须为整数而另一个参数必须为序列。在前一种情况下，两个数字将被转换为相同类型然后相乘。在后一种情况下，将执行序列的重复；重复因子为负数将输出空序列。

此运算可使用特殊的?__mul__()?和?__rmul__()?方法来自定义。

运算符?@?(at) 的目标是用于矩阵乘法。没有内置 Python 类型实现此运算符。

3.5 新版功能.

运算符?/?(除) 和?//?(整除) 将输出其参数的商。两个数字参数将先被转换为相同类型。整数相除会输出一个 float 值，整数相整除的结果仍是整数；整除的结果就是使用 'floor' 函数进行算术除法的结果。除以零的运算将引发?ZeroDivisionError?异常。

This operation can be customized using the special?__truediv__()?and?__floordiv__()?methods.

运算符?%?(模) 将输出第一个参数除以第二个参数的余数。两个数字参数将先被转换为相同类型。右参数为零将引发?ZeroDivisionError?异常。参数可以为浮点数，例如?3.14%0.7?等于?0.34?(因为?3.14?等于?4*0.7?+?0.34)。模运算符的结果的正负总是与第二个操作数一致（或是为零）；结果的绝对值一定小于第二个操作数的绝对值?1。

整除与模运算符的联系可通过以下等式说明:?x?==?(x//y)*y?+?(x%y)。此外整除与模也可通过内置函数?divmod()?来同时进行:?divmod(x,?y)?==?(x//y,?x%y)。?2。

除了对数字执行模运算，运算符?%?还被字符串对象重载用于执行旧式的字符串格式化（又称插值）。字符串格式化句法的描述参见 Python 库参考的?printf 风格的字符串格式化?一节。

取余?运算可使用特殊的?__mod__()?方法来自定义。

整除运算符，模运算符和?divmod()?函数未被定义用于复数。如果有必要可以使用?abs()?函数将其转换为浮点数。

运算符?+?(addition) 将输出其参数的和。两个参数或者必须都为数字，或者都为相同类型的序列。在前一种情况下，两个数字将被转换为相同类型然后相加。在后一种情况下，将执行序列拼接操作。

此运算可使用特殊的?__add__()?和?__radd__()?方法来自定义。

运算符?-?(减) 将输出其参数的差。两个数字参数将先被转换为相同类型。

此运算可使用特殊的?__sub__()?方法来自定义。

6.8.?移位运算

移位运算的优先级低于算术运算:

shift_expr ::=  a_expr | shift_expr ("<<" | ">>") a_expr

这些运算符接受整数参数。它们会将第一个参数左移或右移第二个参数所指定的比特位数。

此运算可使用特殊的?__lshift__()?和?__rshift__()?方法来自定义。

右移?n?位被定义为被?pow(2,n)?整除。左移?n?位被定义为乘以?pow(2,n)。

6.9.?二元位运算

三种位运算具有各不相同的优先级:

and_expr ::=  shift_expr | and_expr "&" shift_expr
xor_expr ::=  and_expr | xor_expr "^" and_expr
or_expr  ::=  xor_expr | or_expr "|" xor_expr

&?运算符会对其参数执行按位 AND，参数必须都为整数或者其中之一必须为重载了?__and__()?或?__rand__()?特殊方法的自定义对象。

^?运算符会对其参数执行按位 XOR (异 OR)，参数必须都为整数或者其中之一必须为重载了?__xor__()?或?__rxor__()?特殊方法的自定义对象。

|?运算符会对其参数执行按位 (合并) OR，参数必须都为整数或者其中之一必须为重载了?__or__()?或?__ror__()?特殊方法的自定义对象。

6.10.?比较运算

与 C 不同，Python 中所有比较运算的优先级相同，低于任何算术、移位或位运算。另一个与 C 不同之处在于?a?<?b?<?c?这样的表达式会按传统算术法则来解读:

comparison    ::=  or_expr (comp_operator or_expr)*
comp_operator ::=  "<" | ">" | "==" | ">=" | "<=" | "!="
                   | "is" ["not"] | ["not"] "in"

比较运算会产生布尔值:?True?或?False。自定义的?富比较方法?可能返回非布尔值。在此情况下 Python 将在布尔运算上下文中对该值调用?bool()。

比较运算可以任意串连，例如?x?<?y?<=?z?等价于?x?<?y?and?y?<=?z，除了?y?只被求值一次（但在两种写法下当?x?<?y?值为假时?z?都不会被求值）。

正式的说法是这样：如果?a,?b,?c, ...,?y,?z?为表达式而?op1,?op2, ...,?opN?为比较运算符，则?a?op1?b?op2?c?...?y?opN?z?就等价于?a?op1?b?and?b?op2?c?and?...?y?opN?z，不同点在于每个表达式最多只被求值一次。

请注意?a?op1?b?op2?c?不意味着在?a?和?c?之间进行任何比较，因此，如?x?<?y?>?z?这样的写法是完全合法的（虽然也许不太好看）。

6.10.1.?值比较

运算符?<,?>,?==,?>=,?<=?和?!=?将比较两个对象的值。两个对象不要求为相同类型。

对象、值与类型?一章已说明对象都有相应的值（还有类型和标识号）。对象值在 Python 中是一个相当抽象的概念：例如，对象值并没有一个规范的访问方法。而且，对象值并不要求具有特定的构建方式，例如由其全部数据属性组成等。比较运算符实现了一个特定的对象值概念。人们可以认为这是通过实现对象比较间接地定义了对象值。

由于所有类型都是?object?的（直接或间接）子类型，它们都从?object?继承了默认的比较行为。类型可以通过实现?丰富比较方法?例如?__lt__()?来定义自己的比较行为，详情参见?基本定制。

默认的一致性比较 (==?和?!=) 是基于对象的标识号。因此，具有相同标识号的实例一致性比较结果为相等，具有不同标识号的实例一致性比较结果为不等。规定这种默认行为的动机是希望所有对象都应该是自反射的 (即?x?is?y?就意味着?x?==?y)。

次序比较 (<,?>,?<=?和?>=) 默认没有提供；如果尝试比较会引发?TypeError。规定这种默认行为的原因是缺少与一致性比较类似的固定值。

按照默认的一致性比较行为，具有不同标识号的实例总是不相等，这可能不适合某些对象值需要有合理定义并有基于值的一致性的类型。这样的类型需要定制自己的比较行为，实际上，许多内置类型都是这样做的。

以下列表描述了最主要内置类型的比较行为。

内置数值类型 (数字类型 --- int, float, complex) 以及标准库类型?fractions.Fraction?和?decimal.Decimal?可进行类型内部和跨类型的比较，例外限制是复数不支持次序比较。在类型相关的限制以内，它们会按数学（算法）规则正确进行比较且不会有精度损失。

非数字值?float('NaN')?和?decimal.Decimal('NaN')?属于特例。任何数字与非数字值的排序比较均返回假值。还有一个反直觉的结果是非数字值不等于其自身。举例来说，如果?x?=?float('NaN')?则?3?<?x,?x?<?3?和?x?==?x?均为假值，而?x?!=?x?则为真值。此行为是遵循 IEEE 754 标准的。
None?和?NotImplemented?都是单例对象。?PEP 8?建议单例对象的比较应当总是通过?is?或?is?not?而不是等于运算符来进行。
二进制码序列 (bytes?或?bytearray?的实例) 可进行类型内部和跨类型的比较。它们使用其元素的数字值按字典顺序进行比较。
字符串 (str?的实例) 使用其字符的 Unicode 码位数字值 (内置函数?ord()?的结果) 按字典顺序进行比较。?3

字符串和二进制码序列不能直接比较。
序列 (tuple,?list?或?range?的实例) 只可进行类型内部的比较，range 还有一个限制是不支持次序比较。以上对象的跨类型一致性比较结果将是不相等，跨类型次序比较将引发?TypeError。

序列比较是按字典序对相应元素进行逐个比较。内置容器通常设定同一对象与其自身是相等的。这使得它们能跳过同一对象的相等性检测以提升运行效率并保持它们的内部不变性。

内置多项集间的字典序比较规则如下:
- 两个多项集若要相等，它们必须为相同类型、相同长度，并且每对相应的元素都必须相等（例如，[1,2]?==?(1,2)?为假值，因为类型不同）。
- 对于支持次序比较的多项集，排序与其第一个不相等元素的排序相同（例如?[1,2,x]?<=?[1,2,y]?的值与``x <= y`` 相同）。如果对应元素不存在，较短的多项集排序在前（例如?[1,2]?<?[1,2,3]?为真值）。
两个映射 (dict?的实例) 若要相等，必须当且仅当它们具有相同的?(键, 值)?对。键和值的一致性比较强制规定自反射性。

次序比较 (<,?>,?<=?和?>=) 将引发?TypeError。
集合 (set?或?frozenset?的实例) 可进行类型内部和跨类型的比较。

它们将比较运算符定义为子集和超集检测。这类关系没有定义完全排序（例如?{1,2}?和?{2,3}?两个集合不相等，即不为彼此的子集，也不为彼此的超集。相应地，集合不适宜作为依赖于完全排序的函数的参数（例如如果给出一个集合列表作为?min(),?max()?和?sorted()?的输入将产生未定义的结果）。

集合的比较强制规定其元素的自反射性。
大多数其他内置类型没有实现比较方法，因此它们会继承默认的比较行为。

在可能的情况下，用户定义类在定制其比较行为时应当遵循一些一致性规则:

相等比较应该是自反射的。换句话说，相同的对象比较时应该相等:

x?is?y?意味着?x?==?y
比较应该是对称的。换句话说，下列表达式应该有相同的结果:

x?==?y?和?y?==?x

x?!=?y?和?y?!=?x

x?<?y?和?y?>?x

x?<=?y?和?y?>=?x
比较应该是可传递的。下列（简要的）例子显示了这一点:

x?>?y?and?y?>?z?意味着?x?>?z

x?<?y?and?y?<=?z?意味着?x?<?z
反向比较应该导致布尔值取反。换句话说，下列表达式应该有相同的结果:

x?==?y?和?not?x?!=?y

x?<?y?和?not?x?>=?y?(对于完全排序)

x?>?y?和?not?x?<=?y?(对于完全排序)

最后两个表达式适用于完全排序的多项集（即序列而非集合或映射）。另请参阅?total_ordering()?装饰器。
hash()?的结果应该与是否相等一致。相等的对象应该或者具有相同的哈希值，或者标记为不可哈希。

Python 并不强制要求这些一致性规则。实际上，非数字值就是一个不遵循这些规则的例子。

6.10.2.?成员检测运算

运算符?in?和?not?in?用于成员检测。如果?x?是?s?的成员则?x?in?s?求值为?True，否则为?False。?x?not?in?s?返回?x?in?s?取反后的值。所有内置序列和集合类型以及字典都支持此运算，对于字典来说?in?检测其是否有给定的键。对于 list, tuple, set, frozenset, dict 或 collections.deque 这样的容器类型，表达式?x?in?y?等价于?any(x?is?e?or?x?==?e?for?e?in?y)。

对于字符串和字节串类型来说，当且仅当?x?是?y?的子串时?x?in?y?为?True。一个等价的检测是?y.find(x)?!=?-1。空字符串总是被视为任何其他字符串的子串，因此?""?in?"abc"?将返回?True。

对于定义了?__contains__()?方法的用户自定义类来说，如果?y.__contains__(x)?返回真值则?x?in?y?返回?True，否则返回?False。

对于未定义?__contains__()?但定义了?__iter__()?的用户自定义类来说，如果在对?y?进行迭代时产生了值?z?使得表达式?x?is?z?or?x?==?z?为真，则?x?in?y?为?True。如果在迭代期间引发了异常，则等同于?in?引发了该异常。

最后将会尝试旧式的迭代协议：如果一个类定义了?__getitem__()，则当且仅当存在非负整数索引号?i?使得?x?is?y[i]?or?x?==?y[i]?并且没有更小的索引号引发?IndexError?异常时?x?in?y?为?True。（如果引发了任何其他异常，则等同于?in?引发了该异常）。

运算符?not?in?被定义为具有与?in?相反的逻辑值。

6.10.3.?标识号比较

运算符?is?和?is?not?用于检测对象的标识号：当且仅当?x?和?y?是同一对象时?x?is?y?为真。一个对象的标识号可使用?id()?函数来确定。?x?is?not?y?会产生相反的逻辑值。?4

6.11.?布尔运算

or_test  ::=  and_test | or_test "or" and_test
and_test ::=  not_test | and_test "and" not_test
not_test ::=  comparison | "not" not_test

在执行布尔运算的情况下，或是当表达式被用于流程控制语句时，以下值会被解析为假值:?False,?None, 所有类型的数字零，以及空字符串和空容器（包括字符串、元组、列表、字典、集合与冻结集合）。所有其他值都会被解析为真值。用户自定义对象可通过提供?__bool__()?方法来定制其逻辑值。

运算符?not?将在其参数为假值时产生?True，否则产生?False。

表达式?x?and?y?首先对?x?求值；如果?x?为假则返回该值；否则对?y?求值并返回其结果值。

表达式?x?or?y?首先对?x?求值；如果?x?为真则返回该值；否则对?y?求值并返回其结果值。

请注意?and?和?or?都不限制其返回的值和类型必须为?False?和?True，而是返回最后被求值的操作数。此行为是有必要的，例如假设?s?为一个当其为空时应被替换为某个默认值的字符串，表达式?s?or?'foo'?将产生希望的值。由于?not?必须创建一个新值，不论其参数为何种类型它都会返回一个布尔值（例如，not?'foo'?结果为?False?而非?''。）

6.12.?赋值表达式

assignment_expression ::=  [identifier ":="] expression

An assignment expression (sometimes also called a "named expression" or "walrus") assigns an?expression?to an?identifier, while also returning the value of the?expression.

一个常见用例是在处理匹配的正则表达式的时候:

if matching := pattern.search(data):
    do_something(matching)

或者是在处理分块的文件流的时候:

while chunk := file.read(9000):
    process(chunk)

3.8 新版功能:?请参阅?PEP 572?了解有关赋值表达式的详情。

6.13.?条件表达式

conditional_expression ::=  or_test ["if" or_test "else" expression]
expression             ::=  conditional_expression | lambda_expr

条件表达式（有时称为“三元运算符”）在所有 Python 运算中具有最低的优先级。

表达式?x?if?C?else?y?首先是对条件?C?而非?x?求值。如果?C?为真，x?将被求值并返回其值；否则将对?y?求值并返回其值。

请参阅?PEP 308?了解有关条件表达式的详情。

6.14.?lambda 表达式

lambda_expr ::=  "lambda" [parameter_list] ":" expression

lambda 表达式（有时称为 lambda 构型）被用于创建匿名函数。表达式?lambda?parameters:?expression?会产生一个函数对象。该未命名对象的行为类似于用以下方式定义的函数:

def <lambda>(parameters):
    return expression

请参阅?函数定义?了解有关参数列表的句法。请注意通过 lambda 表达式创建的函数不能包含语句或标注。

6.15.?表达式列表

expression_list    ::=  expression ("," expression)* [","]
starred_list       ::=  starred_item ("," starred_item)* [","]
starred_expression ::=  expression | (starred_item ",")* [starred_item]
starred_item       ::=  assignment_expression | "*" or_expr

除了作为列表或集合显示的一部分，包含至少一个逗号的表达式列表将生成一个元组。元组的长度就是列表中表达式的数量。表达式将从左至右被求值。

一个星号?*?表示?可迭代拆包。其操作数必须为一个?iterable。该可迭代对象将被拆解为迭代项的序列，并被包含于在拆包位置上新建的元组、列表或集合之中。

3.5 新版功能:?表达式列表中的可迭代对象拆包，最初由?PEP 448?提出。

末尾的逗号仅在创建单独元组 (或称?单例) 时需要；在所有其他情况下都是可选项。没有末尾逗号的单独表达式不会创建一个元组，而是产生该表达式的值。（要创建一个空元组，应使用一对内容为空的圆括号:?()。）

6.16.?求值顺序

Python 按从左至右的顺序对表达式求值。但注意在对赋值操作求值时，右侧会先于左侧被求值。

在以下几行中，表达式将按其后缀的算术优先顺序被求值。:

expr1, expr2, expr3, expr4
(expr1, expr2, expr3, expr4)
{expr1: expr2, expr3: expr4}
expr1 + expr2 * (expr3 - expr4)
expr1(expr2, expr3, *expr4, **expr5)
expr3, expr4 = expr1, expr2

6.17.?运算符优先级

下表对 Python 中运算符的优先顺序进行了总结，从最高优先级（最先绑定）到最低优先级（最后绑定）。相同单元格内的运算符具有相同优先级。除非句法显式地给出，否则运算符均指二元运算。相同单元格内的运算符从左至右分组（除了幂运算是从右至左分组）。

请注意比较、成员检测和标识号检测均为相同优先级，并具有如?比较运算?一节所描述的从左至右串连特性。

运算符	描述
`(expressions...)`, `[expressions...]`,?`{key:?value...}`,?`{expressions...}`	绑定或加圆括号的表达式，列表显示，字典显示，集合显示
`x[index]`,?`x[index:index]`,?`x(arguments...)`,?`x.attribute`	抽取，切片，调用，属性引用
await?x	await 表达式
`**`	乘方?5
`+x`,?`-x`,?`~x`	正，负，按位非 NOT
`*`,?`@`,?`/`,?`//`,?`%`	乘，矩阵乘，除，整除，取余?6
`+`,?`-`	加和减
`<<`,?`>>`	移位
`&`	按位与 AND
`^`	按位异或 XOR
`\|`	按位或 OR
in,?not?in,?is,?is?not,?`<`,?`<=`,?`>`,?`>=`,?`!=`,?`==`	比较运算，包括成员检测和标识号检测
not?x	布尔逻辑非 NOT
and	布尔逻辑与 AND
or	布尔逻辑或 OR
if?--?`else`	条件表达式
lambda	lambda 表达式
`:=`	赋值表达式

备注

虽然?abs(x%y)?<?abs(y)?在数学中必为真，但对于浮点数而言，由于舍入的存在，其在数值上未必为真。例如，假设在某个平台上的 Python 浮点数为一个 IEEE 754 双精度数值，为了使?-1e-100?%?1e100?具有与?1e100?相同的正负性，计算结果将是?-1e-100?+?1e100，这在数值上正好等于?1e100。函数?math.fmod()?返回的结果则会具有与第一个参数相同的正负性，因此在这种情况下将返回?-1e-100。何种方式更适宜取决于具体的应用。

如果 x 恰好非常接近于 y 的整数倍，则由于舍入的存在?x//y?可能会比?(x-x%y)//y?大。在这种情况下，Python 会返回后一个结果，以便保持令?divmod(x,y)[0]?*?y?+?x?%?y?尽量接近?x.

Unicode 标准明确区分?码位?(例如 U+0041) 和?抽象字符?(例如 "大写拉丁字母 A")。虽然 Unicode 中的大多数抽象字符都只用一个码位来代表，但也存在一些抽象字符可使用由多个码位组成的序列来表示。例如，抽象字符 "带有下加符的大写拉丁字母 C" 可以用 U+00C7 码位上的单个?预设字符?来表示，也可以用一个 U+0043 码位上的?基础字符?(大写拉丁字母 C) 加上一个 U+0327 码位上的?组合字符?(组合下加符) 组成的序列来表示。

对于字符串，比较运算符会按 Unicode 码位级别进行比较。这可能会违反人类的直觉。例如，"\u00C7"?==?"\u0043\u0327"?为?False，虽然两个字符串都代表同一个抽象字符 "带有下加符的大写拉丁字母 C"。

要按抽象字符级别（即对人类来说更直观的方式）对字符串进行比较，应使用?unicodedata.normalize()。

由于存在自动垃圾收集、空闲列表以及描述器的动态特性，你可能会注意到在特定情况下使用?is?运算符会出现看似不正常的行为，例如涉及到实例方法或常量之间的比较时就是如此。更多信息请查看有关它们的文档。

幂运算符?**?绑定的紧密程度低于在其右侧的算术或按位一元运算符，也就是说?2**-1?为?0.5。

%?运算符也被用于字符串格式化；在此场合下会使用同样的优先级。

Python知识库最新文章

Python中String模块

【Python】 14-CVS文件操作

python的panda库读写文件

使用Nordic的nrf52840实现蓝牙DFU过程

【Python学习记录】numpy数组用法整理

Python学习笔记

python字符串和列表

python如何从txt文件中解析出有效的数据

Python编程从入门到实践自学/3.1-3.2

python变量

加:2022-06-29 19:00:05 更:2022-06-29 19:01:18

360图书馆购物三丰科技阅读网日历万年历 2024年12日历

-2024/12/25 13:17:54-

图片自动播放器
↓图片自动播放器↓

TxT小说阅读器
↓语音阅读,小说下载,古典文学↓

一键清除垃圾
↓轻轻一点,清除系统垃圾↓

图片批量下载器
↓批量下载图片,美女图库↓

网站联系: qq:121756557 email:121756557@qq.com IT数码

数据统计

[Python知识库]python相关函数介绍

内置函数?