5. Built-in Types

以下各节描述了解释器中内置的标准类型。

内置的主要类型是数字，序列，Map，文件，类，实例和异常。

一些对象类型支持某些操作。特别是，几乎所有对象都可以进行比较，测试真值并转换为字符串(使用repr()函数或稍有不同的str()函数)。当passprint()函数写入对象时，隐式使用后一个函数。

5.1. 真值测试

可以测试任何对象的真值，以用于if或while条件或用作以下布尔运算的操作数。以下值为“假”：

• None

• False

• 任何数字类型的零，例如0，0L，0.0，0j。

• 任何空序列，例如''，()，[]。

• 任何空 Map，例如{}。

• 用户定义的类的实例，如果该类定义了nonzero()或len()方法，则该方法返回整数零或bool值False时。 [1]

所有其他值都被认为是真实的-因此许多类型的对象总是真实的。

除非另有说明，否则具有布尔结果的操作和内置函数始终返回0或False代表 false，返回1或True代表 true。 (重要的 exception：布尔运算or和and始终返回其操作数之一.)

5.2. 布尔运算-和，或不

这些是布尔运算，按优先级升序排列：

Notes:

• 这是一个短路运算符，因此仅在第一个参数为 false 时才评估第二个参数。

• 这是一个短路运算符，因此只有第一个为 true 时，它才求值第二个参数。

• not的优先级低于非布尔运算符，因此not a == b被解释为not (a == b)，而a == not b是语法错误。

5.3. Comparisons

所有对象都支持比较操作。它们都具有相同的优先级(高于布尔运算的优先级)。比较可以任意链接；例如，x < y <= z等效于x < y and y <= z，除了* y 仅被评估一次(但在两种情况下，如果x < y被发现为假，则根本不评估 z *)。

下表总结了比较操作：

Notes:

• !=也可以写成<>，但这只是为了向后兼容而保留的过时用法。新代码应始终使用!=。

不同类型的对象(不同的数字类型和不同的字符串类型除外)绝不会相等。这样的对象可以一致但任意地排序(以便对异构数组进行排序可以得到一致的结果)。此外，某些类型(例如文件对象)仅支持简并的比较概念，其中该类型的任何两个对象都不相等。同样，这些对象是任意但一致地排序的。当任何操作数为复数时，<，<=，>和>=运算符将引发TypeError异常。

通常，除非类定义eq()方法或cmp()方法，否则类的不同实例通常比较为不相等。

一个类的实例不能相对于同一类的其他实例或其他类型的对象进行排序，除非该类定义了足够的丰富比较方法(lt()，le()，gt()和ge())或cmp()方法。

CPython 实现细节： 不同类型的对象(数字除外)按其类型名称排序；不支持正确比较的相同类型的对象按其地址排序。

语法类型相同的另外两个操作in和not in仅受序列类型(以下)支持。

5.4. 数值类型-整型，浮点型，长整型

有四种不同的数字类型：普通整数，长整数，浮点数和复数。另外，布尔值是纯整数的子类型。普通整数(也称为* integers )是使用 C 语言中的long实现的，这使它们至少具有 32 位精度(对于当前平台，sys.maxint始终设置为最大普通整数值，最小值是-sys.maxint - 1)。长整数具有无限的精度。浮点数通常在 C 语言中使用double来实现； sys.float_info中提供了有关运行程序的计算机的浮点数的精度和内部表示形式的信息。复数具有实部和虚部，每个均是浮点数。要从复数 z *中提取这些部分，请使用z.real和z.imag。 (标准库包括其他数字类型，具有逻辑的fractions和具有用户可定义精度的浮点数的decimal。)

数字是pass数字 Literals 或内置函数和运算符创建的。未经修饰的整数 Literals(包括二进制，十六进制和八进制数字)将生成纯整数，除非它们所表示的值太大而无法表示为纯整数，在这种情况下，它们将生成一个长整数。带'L'或'l'后缀的整数 Literals 会产生长整数(首选'L'，因为1l看起来很像 11！)。包含小数点或指数符号的数字 Literals 会产生浮点数。将'j'或'J'附加到数字 Literals 会产生虚数(实数为零的复数)，您可以将其添加到整数或浮点数以获得具有实数和虚数的复数。

Python 完全支持混合算术：当二进制算术运算符具有不同数值类型的操作数时，具有“更窄”类型的操作数将扩展为另一种，其中普通整数窄于长整数窄于浮点窄于整数复杂。混合类型数之间的比较使用相同的规则。 [2]构造函数int()，long()，float()和complex()可用于生成特定类型的数字。

所有内置数字类型均支持以下操作。有关操作员的优先级，请参见power operator和后续部分。

Notes:

• 对于(普通或长整数)除法，结果是整数。结果总是四舍五入为负无穷大：1/2 为 0，(-1)/ 2 为-1，1 /(-2)为-1，(-1)/(-2)为 0.请注意如果两个操作数中的任何一个为长整数，则结果均为长整数，而与数值无关。

• 像相关函数math.trunc()一样，使用int()或long()从浮点数的转换将截断为零。使用Functionmath.floor()向下舍入，使用math.ceil()向上舍入。

• 完整说明请参见Built-in Functions。

• 从版本 2.3 开始弃用：不再为复数定义地板除法运算符，模运算符和divmod()函数。相反，如果合适，请使用abs()函数转换为浮点数。

• 也称为整数除法。结果值是一个整数，尽管结果的类型不一定是 int。

• 对于非数字(NaN)和正负无穷大，float 还接受带有可选前缀“”或“-”的字符串“ nan”和“ inf”。

2.6 版的新Function。

• Python 将pow(0, 0)和0 ** 0定义为1，这在编程语言中很常见。

所有numbers.Real类型(int，long和float)还包括以下操作：

5.4.1. 整数类型的按位运算

按位运算仅对整数有意义。负数被视为其 2 的补码值(这假设有足够多的位，因此在操作期间不会发生溢出)。

二进制按位运算的优先级均低于数字运算，且高于比较运算。一元运算~与其他一元数值运算(+和-)具有相同的优先级。

下表列出了按优先级升序排列的按位运算：

Notes:

• 负班次计数是非法的，并且会引起ValueError的提高。

• 向左移位* n *位等效于与pow(2, n)相乘。如果结果超出纯整数范围，则返回一个长整数。

• 向右移位* n *位等效于被pow(2, n)除。

5.4.2. 整数类型的其他方法

整数类型实现numbers.Integral 抽象 Base Class。此外，它们还提供了另一种方法：

• int. bit_length ( )

• long. bit_length ( )

  • 返回表示二进制整数的必要位数，不包括符号和前导零：

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

更准确地说，如果x为非零，则x.bit_length()是唯一的正整数k，使得2**(k-1) <= abs(x) < 2**k。等效地，当abs(x)小到足以具有正确舍入的对数时，则k = 1 + int(log(abs(x), 2))。如果x为零，则x.bit_length()返回0。

Equivalent to:

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6

2.7 版的新Function。

5.4.3. 浮点数的其他方法

浮点类型实现numbers.Real 抽象 Base Class。 float 还具有以下其他方法。

• float. as_integer_ratio ( )
  • 返回Pair整数，其比率与原始浮点数完全相等，并且带有一个正分母。在无穷大上提高OverflowError，在 NaN 上提高ValueError。

2.6 版的新Function。

• float. is_integer ( )
  • 如果 float 实例是带整数值的有限实例，则返回True，否则返回False：

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

2.6 版的新Function。

有两种方法支持与十六进制字符串之间的转换。由于 Python 的浮点数在内部存储为二进制数字，因此，将浮点数与* decimal *字符串进行相互转换通常会产生较小的舍入误差。相反，十六进制字符串允许精确表示和指定浮点数。这在调试和数值工作时很有用。

• float. hex ( )
  • 以十六进制字符串形式返回浮点数的表示形式。对于有限的浮点数，此表示将始终包括前导0x和尾随p以及指数。

2.6 版的新Function。

• float. fromhex(* s *)
  • 返回由十六进制字符串* s 表示的 float 的类方法。字符串 s *可能具有前导和尾随空格。

2.6 版的新Function。

请注意，float.hex()是实例方法，而float.fromhex()是类方法。

十六进制字符串的形式为：

[sign] ['0x'] integer ['.' fraction] ['p' exponent]

其中可选的sign可以是+或-，integer和fraction是十六进制数字的字符串，而exponent是带有可选前导符号的十进制整数。大小写无关紧要，并且整数或分数中必须至少有一个十六进制数字。此语法与 C99 标准的 6.4.4.2 节中指定的语法相似，也与 Java 1.5 及更高版本中使用的语法相似。特别地，float.hex()的输出可用作 C 或 Java 代码中的十六进制浮点 Literals，并且float.fromhex()接受 C 的%a格式字符或 Java 的Double.toHexString产生的十六进制字符串。

请注意，指数用十进制而不是十六进制表示，并且乘以 2 的幂乘以系数。例如，十六进制字符串0x3.a7p10表示浮点数(3 + 10./16 + 7./16**2) * 2.0**10或3740.0：

>>> float.fromhex('0x3.a7p10')
3740.0

将反向转换应用于3740.0会给出不同的十六进制字符串，表示相同的数字：

>>> float.hex(3740.0)
'0x1.d380000000000p+11'

5.5. 迭代器类型

2.2 版中的新Function。

Python 支持容器迭代的概念。这是pass两种不同的方法实现的：这些用于允许用户定义的类支持迭代。下面更详细描述的序列始终支持迭代方法。

需要为容器对象定义一种方法以提供迭代支持：

• container. __iter__ ( )
  • 返回一个迭代器对象。需要该对象支持以下所述的迭代器协议。如果容器支持不同类型的迭代，则可以提供其他方法来专门请求那些迭代类型的迭代器。 (支持多种形式的迭代的对象的示例是支持广度优先和深度优先遍历的树结构.)此方法对应于 Python/C API 中 Python 对象的类型结构的tp_iter插槽。

需要迭代器对象本身支持以下两种方法，它们共同构成* iterator 协议*：

• iterator. __iter__ ( )

  • 返回迭代器对象本身。这是允许容器和迭代器与for和in语句一起使用所必需的。此方法对应于 Python/C API 中 Python 对象的类型结构的tp_iter插槽。

• iterator. next ( )

  • 从容器返回下一项。如果没有其他项目，请提出StopIterationexception。此方法对应于 Python/C API 中 Python 对象的类型结构的tp_iternext插槽。

Python 定义了几个迭代器对象，以支持对常规和特定序列类型，字典以及其他更专门形式的迭代。除了其迭代器协议的实现之外，特定类型并不重要。

该协议的目的是，一旦迭代器的next()方法引发StopIteration，它将在后续调用中 continue 这样做。不遵守此属性的实现被视为已损坏。 (在 Python 2.3 中添加了此约束；在 Python 2.2 中，根据此规则破坏了各种迭代器.)

5.5.1. Generator 类型

Python 的generator提供了一种实现迭代器协议的便捷方法。如果将容器对象的iter()方法实现为生成器，它将自动返回提供iter()和next()方法的迭代器对象(从技术上讲，是生成器对象)。有关生成器的更多信息，请参见yield表达文件。

5.6. 序列类型— str，unicode，list，tuple，bytearray，buffer，xrange

有七种序列类型：字符串，Unicode 字符串，列表，Tuples，字节数组，缓冲区和 xrange 对象。

对于其他容器，请参见内置的dict和set类以及collections模块。

字符串 Literals 用单引号或双引号引起来：'xyzzy'，"frobozz"。有关字符串 Literals 的更多信息，请参见String literals。 Unicode 字符串与字符串非常相似，但是在语法中使用前面的'u'字符：u'abc'，u"def"指定。除了此处描述的Function外，在String Methods部分中还描述了特定于字符串的方法。列表用方括号构成，用逗号分隔项目：[a, b, c]。Tuples 由逗号运算符构造(不在方括号内)，带有或不带有括号，但是空的 tuple 必须带有括号，例如a, b, c或()。单个项目 Tuples 必须带有尾随逗号，例如(d,)。

字节数组对象是使用内置函数bytearray()创建的。

缓冲区对象不受 Python 语法的直接支持，但可以pass调用内置函数buffer()来创建。他们不支持串联或重复。

xrange 类型的对象与缓冲区类似，因为没有特定的语法可以创建它们，但是它们是使用xrange()函数创建的。它们不支持切片，连接或重复，并且在它们上使用in，not in，min()或max()效率低下。

大多数序列类型支持以下操作。 in和not in操作具有与比较操作相同的优先级。 +和*运算与相应的数字运算具有相同的优先级。 [3]为可变序列类型提供了其他方法。

下表列出了按优先级升序排列的序列操作。在表中，* s 和 t *是相同类型的序列； * n ， i 和 j *是整数：

序列类型也支持比较。特别是，pass比较相应的元素按字典 Sequences 比较 Tuples 和列表。这意味着要进行相等比较，每个元素必须进行相等比较，并且两个序列必须具有相同的类型并且具有相同的长度。 (有关详细信息，请参见语言参考中的Comparisons。)

Notes:

• 当* s 是字符串或 Unicode 字符串对象时，in和not in操作就像子字符串测试一样。在 2.3 之前的 Python 版本中， x 必须是长度为 1 的字符串。在 Python 2.3 及更高版本中， x *可以是任意长度的字符串。

• • n 小于0的值被视为0(这会产生与 s 相同类型的空序列)。请注意，序列 s *中的项目不会被复制；它们被多次引用。这常常困扰着新的 Python 程序员。考虑：

>>> lists = [[]] * 3
>>> lists
[[], [], []]
>>> lists[0].append(3)
>>> lists
[[3], [3], [3]]

发生的事情是[[]]是一个包含一个空列表的单元素列表，因此[[]] * 3的所有三个元素都是对该单个空列表的引用。修改lists的任何元素都将修改此单个列表。您可以pass以下方式创建不同列表的列表：

>>> lists = [[] for i in range(3)]
>>> lists[0].append(3)
>>> lists[1].append(5)
>>> lists[2].append(7)
>>> lists
[[3], [5], [7]]

常见问题解答条目如何创建多维列表？中提供了更多说明。

• 如果* i 或 j 为负，则索引相对于序列 s *的结尾：替换len(s) + i或len(s) + j。但是请注意-0仍然是0。

• 从* i 到 j 的 s 切片被定义为索引为 k 的项目序列，例如i <= k < j。如果 i 或 j 大于len(s)，请使用len(s)。如果Ellipsis i 或None，请使用0。如果Ellipsis j 或None，请使用len(s)。如果 i 大于或等于 j *，则切片为空。

• 从* i 到 j 的带 k 步骤的 s 切片被定义为索引为x = i + n*k从而0 <= n < (j-i)/k的项目序列。换句话说，索引是i，i+k，i+2*k，i+3*k等，当达到 j 时停止(但不包括 j )。当 k 为正时，如果 i 和 j 较大，则将它们减小为len(s)。当 k 为负时，如果 i 和 j 较大，则将它们减小为len(s) - 1。如果Ellipsis i 或 j 或None，它们将成为“结束”值(该结束取决于 k 的符号)。注意， k 不能为零。如果 k *为None，则将其视为1。

• CPython 实现细节： 如果* s 和 t *都是字符串，则某些 Python 实现(例如 CPython)通常可以对s = s + t或s += t形式的赋值执行就地优化。如果适用，此优化将使二次运行的可能性大大降低。此优化取决于版本和实现。对于性能敏感的代码，最好使用str.join()方法，以确保跨版本和实现的一致线性连接性能。

在版本 2.4 中进行了更改：以前，字符串连接从未就位发生。

5.6.1. 字符串方法

下面列出了 8 位字符串和 Unicode 对象都支持的字符串方法。其中一些也可以在bytearray个对象上使用。

另外，Python 的字符串支持序列类型— str，unicode，list，tuple，bytearray，buffer，xrange部分中描述的序列类型方法。要输出格式化的字符串，请使用模板字符串或字符串格式化操作部分中所述的%运算符。另外，有关基于正则表达式的字符串函数，请参见re模块。

• str. capitalize ( )
  • 返回字符串的副本，该字符串的首个字符首字母大写，其余首字母小写。

对于 8 位字符串，此方法与语言环境有关。

• str. center(* width * [，* fillchar *])
  • 返回以长* width 的字符串为中心。使用指定的 fillchar *(默认为空格)填充。

在版本 2.4 中更改：支持* fillchar *参数。

• str. count(* sub * [，* start * [，* end *]])

  • 返回子字符串* sub 在[* start ， end *]范围内不重叠的次数。可选参数 start 和 end *的解释方式为切片符号。

• str. decode([编码 [，错误]])

  • 使用为* encoding *注册的编解码器对字符串进行解码。 * encoding *默认为默认字符串编码。 * errors *可以用来设置不同的错误处理方案。默认值为'strict'，这意味着编码错误会引发UnicodeError。其他可能的值是'ignore'，'replace'以及passcodecs.register_error()注册的任何其他名称，请参见编解码器 Base Class部分。

2.2 版中的新Function。

在版本 2.3 中进行了更改：添加了对其他错误处理方案的支持。

在 2.7 版中进行了更改：添加了对关键字参数的支持。

• str. encode([编码 [，错误]])
  • 返回字符串的编码版本。默认编码是当前的默认字符串编码。 * errors *可以用来设置不同的错误处理方案。 * errors *的默认值为'strict'，这意味着编码错误会引发UnicodeError。其他可能的值是'ignore'，'replace'，'xmlcharrefreplace'，'backslashreplace'以及passcodecs.register_error()注册的任何其他名称，请参见编解码器 Base Class部分。有关可能的编码的列表，请参见Standard Encodings部分。

2.0 版中的新Function。

在版本 2.3 中进行了更改：添加了对'xmlcharrefreplace'和'backslashreplace'的支持以及其他错误处理方案。

在 2.7 版中进行了更改：添加了对关键字参数的支持。

• str. endswith(后缀 [，开始 [，结束]])
  • 如果字符串以指定的后缀结尾，则返回True，否则返回False。 后缀也可以是要查找的后缀 Tuples。使用可选的* start ，从该位置开始测试。使用可选的 end *，在该位置停止比较。

在版本 2.5 中进行了更改：将 Tuples 接受为后缀。

• str. expandtabs([* tabsize *])
  • 返回字符串的副本，其中所有制表符都被一个或多个空格替换，具体取决于当前列和给定的制表符大小。制表符位置每隔* tabsize *个字符出现一次(默认值为 8，在第 0、8、16 列等处给出制表符位置)。为了扩展字符串，将当前列设置为零，并逐字符检查字符串。如果字符是制表符(\t)，则在结果中插入一个或多个空格字符，直到当前列等于下一个制表符位置为止。 (制表符本身不会被复制.)如果该字符是换行符(\n)或返回(\r)，则将其复制并将当前列重置为零。无论打印时如何显示该字符，任何其他字符都将原样复制，并且当前列将增加一。

>>> '01\t012\t0123\t01234'.expandtabs()
'01      012     0123    01234'
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01  012 0123    01234'

• str. find(* sub * [，* start * [，* end *]])
  • 返回在切片s[start:end]中找到子字符串* sub 的字符串中的最低索引。可选参数 start 和 end 的解释方式为切片符号。如果未找到 sub *，则返回-1。

>>> 'Py' in 'Python'
True

• str. format( *args ， * kwargs *)
  • 执行字符串格式化操作。调用此方法的字符串可以包含 Literals 文本或用大括号{}分隔的替换字段。每个替换字段都包含位置参数的数字索引或关键字参数的名称。返回字符串的副本，其中每个替换字段都用相应参数的字符串值替换。

>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'

有关可以在格式字符串中指定的各种格式选项的说明，请参见格式字符串语法。

这种字符串格式设置方法是 Python 3 中的新标准，并且应优先于新代码中字符串格式化操作中描述的%格式。

2.6 版的新Function。

• str. index(* sub * [，* start * [，* end *]])

  • 类似于find()，但是在找不到子字符串时提高ValueError。

• str. isalnum ( )

  • 如果字符串中的所有字符都是字母数字并且至少包含一个字符，则返回 true，否则返回 false。

对于 8 位字符串，此方法与语言环境有关。

• str. isalpha ( )
  • 如果字符串中的所有字符均为字母并且至少包含一个字符，则返回 true，否则返回 false。

对于 8 位字符串，此方法与语言环境有关。

• str. isdigit ( )
  • 如果字符串中的所有字符都是数字并且至少有一个字符，则返回 true，否则返回 false。

对于 8 位字符串，此方法与语言环境有关。

• str. islower ( )
  • 如果字符串中所有大小写的字符[4]均为小写且至少有一个大小写的字符，则返回 true，否则返回 false。

对于 8 位字符串，此方法与语言环境有关。

• str. isspace ( )
  • 如果字符串中只有空格字符并且至少有一个字符，则返回 true，否则返回 false。

对于 8 位字符串，此方法与语言环境有关。

• str. istitle ( )
  • 如果字符串是一个用大写字母区分大小写的字符串，并且至少有一个字符，则返回 true，例如，大写字符只能跟在无大小写的字符之后，而小写字母只能跟在大写的字符后面。否则返回 false。

对于 8 位字符串，此方法与语言环境有关。

• str. isupper ( )
  • 如果字符串中所有大小写的字符[4]为大写且至少有一个大小写的字符，则返回 true，否则返回 false。

对于 8 位字符串，此方法与语言环境有关。

• str. join(可迭代)

  • 返回一个字符串，该字符串是* iterable 中字符串的串联。如果 iterable 中有任何 Unicode 对象，请改为返回 Unicode。如果 iterable *中存在任何非字符串或非 Unicode 对象值，则将引发TypeError。元素之间的分隔符是提供此方法的字符串。

• str. ljust(* width * [，* fillchar *])

  • 返回长度为* width 的左对齐字符串。使用指定的 fillchar (默认为空格)填充。如果 width *小于或等于len(s)，则返回原始字符串。

在版本 2.4 中更改：支持* fillchar *参数。

• str. lower ( )
  • 返回字符串的副本，并将所有大小写的字符[4]转换为小写。

对于 8 位字符串，此方法与语言环境有关。

• str. lstrip([字符])
  • 返回删除了前导字符的字符串的副本。 * chars 参数是一个字符串，指定要删除的字符集。如果Ellipsis或None，则 chars *参数默认为删除空格。 * chars *参数不是前缀；而是删除其值的所有组合：

>>> '   spacious   '.lstrip()
'spacious   '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'

在版本 2.2.2 中更改：支持* chars *参数。

• str. partition(* sep *)
  • 在第一次出现* sep *时拆分字符串，并返回一个三 Tuples，其中包含分隔符之前的部分，分隔符本身以及分隔符之后的部分。如果找不到分隔符，则返回一个包含字符串本身的 3Tuples，然后是两个空字符串。

2.5 版的新Function。

• str. replace(* old ， new * [，* count *])

  • 返回该字符串的副本，其中所有出现的子字符串* old 被 new 替换。如果给出了可选参数 count ，则仅替换第一个 count *项。

• str. rfind(* sub * [，* start * [，* end *]])

  • 返回找到子字符串* sub 的字符串中的最高索引，以使 sub 包含在s[start:end]中。可选参数 start 和 end *的解释方式为切片符号。失败时返回-1。

• str. rindex(* sub * [，* start * [，* end *]])

  • 与rfind()类似，但是在未找到子字符串* sub *时引发ValueError。

• str. rjust(* width * [，* fillchar *])

  • 返回长度为* width 的右对齐字符串。使用指定的 fillchar (默认为空格)填充。如果 width *小于或等于len(s)，则返回原始字符串。

在版本 2.4 中更改：支持* fillchar *参数。

• str. rpartition(* sep *)
  • 在最后一次出现* sep *时拆分字符串，并返回一个三 Tuples，其中包含分隔符之前的部分，分隔符本身和分隔符之后的部分。如果找不到分隔符，则返回一个包含两个空字符串的三 Tuples，然后是字符串本身。

2.5 版的新Function。

• str. rsplit([* sep * [，* maxsplit *]])
  • 使用* sep 作为分隔符字符串，返回字符串中单词的列表。如果给出了 maxsplit ，最多完成 maxsplit 个分割，最右边的分割。如果未指定 sep *或None，则任何空格字符串都是分隔符。除了从右侧拆分外，rsplit()的行为与split()相似，下面将对其进行详细说明。

2.4 版的新Function。

• str. rstrip([字符])
  • 返回删除了结尾字符的字符串副本。 * chars 参数是一个字符串，指定要删除的字符集。如果Ellipsis或None，则 chars *参数默认为删除空格。 * chars *参数不是后缀；而是删除其值的所有组合：

>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'

在版本 2.2.2 中更改：支持* chars *参数。

• str. split([* sep * [，* maxsplit *]])
  • 使用* sep 作为分隔符字符串，返回字符串中单词的列表。如果给出 maxsplit ，最多完成 maxsplit 个分割(因此，列表最多包含maxsplit+1个元素)。如果未指定 maxsplit *或-1，则分割数没有限制(已进行所有可能的分割)。

如果给定* sep *，则不将连续的定界符分组在一起，并且将其视为定界空字符串(例如'1,,2'.split(',')返回['1', '', '2'])。 * sep *参数可以包含多个字符(例如'1<>2<>3'.split('<>')返回['1', '2', '3'])。使用指定的分隔符分割空字符串将返回['']。

如果未指定* sep *或为None，则将应用不同的拆分算法：连续的空白行被视为单个分隔符，并且如果字符串的开头或结尾处有空格，则结果在开头或结尾将不包含空字符串。因此，使用None分隔符拆分空字符串或仅包含空格的字符串将返回[]。

例如，' 1 2 3 '.split()返回['1', '2', '3']，而' 1 2 3 '.split(None, 1)返回['1', '2 3 ']。

• str. splitlines([* keepends *])
  • 返回字符串中的行列表，在行边界处break。此方法使用universal newlines方法分割线。除非给出* keepends *并且为 true，否则换行符不包含在结果列表中。

Python 将"\r"，"\n"和"\r\n"识别为 8 位字符串的行边界。

For example:

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

与split()不同，当给出分隔符* sep *时，此方法返回空字符串的空列表，并且终端换行不会导致多余的行：

>>> "".splitlines()
[]
>>> "One line\n".splitlines()
['One line']

为了进行比较，split('\n')给出：

>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']

• unicode. splitlines([* keepends *])
  • 返回字符串中的行的列表，例如str.splitlines()。但是，Unicode 方法在以下行边界上分割，这是 8 位字符串识别的universal newlines的超集。

在 2.7 版中进行了更改：\v和\f已添加到行边界列表中。

• str. startswith(前缀 [，开始 [，结束]])
  • 如果 string 以* prefix *开头，则返回True，否则返回False。 * prefix 也可以是要查找的前缀的 Tuples。使用可选的 start ，测试从该位置开始的字符串。使用可选的 end *，在该位置停止比较字符串。

在版本 2.5 中更改：将 Tuples 接受为* prefix *。

• str. strip([字符])
  • 返回删除前导和尾随字符的字符串的副本。 * chars 参数是一个字符串，指定要删除的字符集。如果Ellipsis或None，则 chars *参数默认为删除空格。 * chars *参数不是前缀或后缀；而是删除其值的所有组合：

>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'

在版本 2.2.2 中更改：支持* chars *参数。

• str. swapcase ( )
  • 返回字符串的副本，将大写字符转换为小写，反之亦然。

对于 8 位字符串，此方法与语言环境有关。

• str. title ( )
  • 返回标题的字符串形式，其中单词以大写字母开头，其余字符为小写字母。

该算法使用单词的简单语言独立定义作为连续字母的组。该定义在许多情况下都适用，但是它意味着缩略语和所有格中的撇号形成单词边界，这可能不是期望的结果：

>>> "they're bill's friends from the UK".title()
"They'Re Bill'S Friends From The Uk"

撇号的变通办法可以使用正则表达式构造：

>>> import re
>>> def titlecase(s):
...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
...                   lambda mo: mo.group(0)[0].upper() +
...                              mo.group(0)[1:].lower(),
...                   s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."

对于 8 位字符串，此方法与语言环境有关。

• str. translate(* table * [，* deletechars *])
  • 返回字符串的副本，其中删除了可选参数* deletechars *中出现的所有字符，并且其余字符已pass给定的转换表进行 Map，该转换表必须是长度为 256 的字符串。

您可以使用string模块中的maketrans()辅助函数来创建翻译表。对于字符串对象，对于仅删除字符的翻译，将* table *参数设置为None：

>>> 'read this short text'.translate(None, 'aeiou')
'rd ths shrt txt'

2.6 版的新Function：支持None * table *参数。

对于 Unicode 对象，translate()方法不接受可选的* deletechars 参数。相反，它返回 s *的副本，其中所有字符都已pass给定的转换表进行 Map，该表必须是 Unicode 序号到 Unicode 序号，Unicode 字符串或None的 Map。未 Map 的字符保持不变。Map 到None的字符将被删除。请注意，更灵活的方法是使用codecs模块创建自定义字符 Map 编解码器(有关示例，请参见encodings.cp1251)。

• str. upper ( )
  • 返回字符串的副本，其中所有大小写的字符[4]都转换为大写。请注意，如果s包含无大小写的字符，或者生成的字符的 Unicode 类别不是“ Lu”(字母大写)，例如s.upper().isupper()，则可能是False。 “ Lt”(字母，大写)。

对于 8 位字符串，此方法与语言环境有关。

• str. zfill(* width *)
  • 返回长度为* width 的字符串中用零填充的数字字符串。正确处理符号前缀。如果 width *小于或等于len(s)，则返回原始字符串。

版本 2.2.2 中的新Function。

以下方法仅在 unicode 对象上存在：

• unicode. isnumeric ( )

  • 如果 S 中只有数字字符，则返回True，否则返回False。数字字符包括数字字符，以及所有具有 Unicode 数值属性的字符，例如 U 2155，粗俗分数五分之一。

• unicode. isdecimal ( )

  • 如果 S 中只有十进制字符，则返回True，否则返回False。十进制字符包括数字字符，以及可用于形成十进制基数的所有字符，例如 U 0660，阿拉伯文-印度数字零。

5.6.2. 字符串格式化操作

字符串和 Unicode 对象具有一个唯一的内置操作：%运算符(模)。这也称为字符串* formatting 或 interpolation 运算符。给定format % values(其中 format 是字符串或 Unicode 对象)，将 format 中的%转换规范替换为 values 的零个或多个元素。效果类似于在 C 语言中使用sprintf()。如果 format *是 Unicode 对象，或者使用%s转换转换的任何对象是 Unicode 对象，则结果也将是 Unicode 对象。

如果* format 需要单个参数，则 values *可以是单个非 Tuples 对象。 [5]否则，“值”必须是一个具有由格式字符串指定的项目数完全相同的 Tuples，或者是单个 Map 对象(例如，词典)。

转换说明符包含两个或多个字符，并具有以下组件，这些组件必须按此 Sequences 出现：

• '%'字符，指示说明符的开始。

• Map 键(可选)，由带括号的字符序列(例如(somename))组成。

• 转换标志(可选)，会影响某些转换类型的结果。

• 最小字段宽度(可选)。如果指定为'*'(星号)，则从 Tuples 的下一个元素(* values *)中读取实际宽度，并且要转换的对象位于最小字段宽度和可选精度之后。

• 精度(可选)，后跟精度为'.'(点)。如果指定为'*'(星号)，则从* values *中的 Tuples 的下一个元素读取实际宽度，并且要转换的值位于精度之后。

• 长度修改器(可选)。

• Conversion type.

当正确的参数是字典(或其他 Map 类型)时，字符串必须的格式必须在该字典中包含括号的 Map 键，该键直接插入'%'字符后。Map 键从 Map 中选择要格式化的值。例如：

>>> print '%(language)s has %(number)03d quote types.' % \
...       {"language": "Python", "number": 2}
Python has 002 quote types.

在这种情况下，*1 指定符不能以某种格式出现(因为它们需要 Sequences 的参数列表)。

转换标志字符为：

长度修饰符(h，l或L)可能存在，但由于 Python 不必要而被忽略-例如%ld与%d相同。

转换类型为：

Notes:

• 如果结果的前导字符还不是零，则备用格式会导致在左填充和数字格式之间插入前导零('0')。

• 备用格式导致在第一个数字之前插入前导'0x'或'0X'(取决于使用的是'x'还是'X'格式)。

• 备用格式使结果始终包含小数点，即使后面没有数字也是如此。

精度确定小数点后的位数，默认为 6.

• 备用格式导致结果始终包含小数点，尾随的零不会被删除，否则会被删除。

精度确定小数点前后的有效位数，默认为 6.

• %r转换是在 Python 2.0 中添加的。

精度确定使用的最大字符数。

• 如果提供的对象或格式是unicode字符串，则结果字符串也将是unicode。

精度确定使用的最大字符数。

• See PEP 237.

由于 Python 字符串具有明确的长度，因此%s转换不假定'\0'是字符串的结尾。

在 2.7 版中进行了更改：绝对值超过 1e50 的数字的%f转换不再由%g转换代替。

在标准模块string和re中定义了其他字符串操作。

5.6.3. XRange 类型

xrange类型是不可变的序列，通常用于循环。 xrange类型的优点是xrange对象将始终占用相同的内存量，无论它表示的范围大小如何。没有一致的性能优势。

XRange 对象的行为很少：它们仅支持索引，迭代和len()函数。

5.6.4. 可变序列类型

列表和bytearray对象支持允许对对象进行就地修改的其他操作。其他可变序列类型(添加到语言中时)也应支持这些操作。字符串和 Tuples 是不可变的序列类型：此类对象一旦创建就无法修改。在可变序列类型(其中* x *是任意对象)上定义了以下操作：

Notes:

• • t *必须与要替换的切片具有相同的长度。

• 从历史上看，Python 的 C 实现接受多个参数并将它们隐式地加入一个 Tuples。这在 Python 2.0 中不再起作用。从 Python 1.4 开始不推荐使用此Function。

• • t *可以是任何可迭代的对象。

• 当在* s 中找不到 x *时，引发ValueError。当将负索引作为第二个或第三个参数传递给index()方法时，与切片索引一样，将添加列表长度。如果它仍然是负数，则像切片索引一样被截断为零。

在版本 2.3 中进行了更改：以前，index()没有用于指定开始位置和停止位置的参数。

• 当将负索引作为第一个参数传递给insert()方法时，与切片索引一样，添加列表长度。如果它仍然是负数，则像切片索引一样被截断为零。

在版本 2.3 中进行了更改：以前，所有负索引都被截断为零。

• pop()方法的可选参数* i *默认为-1，因此默认情况下，最后一项被删除并返回。

• sort()和reverse()方法会在对大型列表进行排序或反转时修改列表，以节省空间。为了提醒您，它们是副作用，它们不会返回已排序或反向的列表。

• sort()方法采用可选参数来控制比较。

• cmp *指定两个参数(列表项)的自定义比较函数，该函数应返回负数，零数或正数，具体取决于第一个参数是否小于，等于或大于第二个参数：cmp=lambda x,y: cmp(x.lower(), y.lower())。默认值为None。

• key *指定一个参数的Function，该参数用于从每个列表元素key=str.lower中提取比较键。默认值为None。

• reverse *是一个布尔值。如果设置为True，则对列表元素进行排序，就好像每个比较都被反转一样。

通常，* key 和 reverse 转换过程比指定等效的 cmp 函数要快得多。这是因为 cmp 被每个列表元素多次调用，而 key 和 reverse 仅触摸每个元素一次。使用functools.cmp_to_key()将旧式 cmp 函数转换为 key *函数。

在版本 2.3 中进行了更改：添加了对None的支持，等同于Ellipsis了* cmp *。

在版本 2.4 中更改：添加了对* key 和 reverse *的支持。

• 从 Python 2.3 开始，可以保证sort()方法是稳定的。如果排序保证不改变比较相等的元素的相对 Sequences，则该排序是稳定的-这有助于多次pass排序(例如，按部门排序，然后按薪级排序)。

• CPython 实现细节： 在对列表进行排序时，try更改甚至检查列表的效果是不确定的。 Python 2.3 及更高版本的 C 实现使该列表在整个持续时间内都显示为空，并且如果它可以检测到该列表在排序过程中发生了突变，则引发ValueError。

• 值* n *是整数，或者是实现index()的对象。 * n *的零值和负值将清除序列。序列中的项目不会被复制；如序列类型— str，unicode，list，tuple，bytearray，buffer，xrange下针对s * n所述，它们被多次引用。

5.7. 集合类型-集合，frozenset

• set *对象是不同的hashable对象的无序集合。常见用途包括成员资格测试，从序列中删除重复项以及计算 math 运算(例如交集，并集，差和对称差)。 (有关其他容器，请参见内置的dict，list和tuple类以及collections模块。)

2.4 版的新Function。

与其他集合一样，集合支持x in set，len(set)和for x in set。集是无序集合，不记录元素位置或插入 Sequences。因此，集合不支持索引，切片或其他类似序列的行为。

当前有两种内置集类型set和frozenset。 set类型是可变的-可以使用add()和remove()之类的方法更改内容。由于它是可变的，因此它没有哈希值，因此不能用作字典键或另一个集合的元素。 frozenset类型是不可变的，而hashable类型-创建后不能更改其内容；因此，它可以用作字典键或用作另一个集合的元素。

从 Python 2.7 开始，可以pass在括号内放置以逗号分隔的元素列表来创建非空集(非冻结集)，例如：set构造函数之外的{'jack', 'sjoerd'}。

这两个类的构造函数工作相同：

• 类别 set([可迭代])
• 类别 frozenset([可迭代])
  • 返回一个新的 set 或 Frozenset 对象，其元素来自* iterable 。集合的元素必须为hashable。要表示集合集，内部集合必须是frozenset个对象。如果未指定 iterable *，则返回一个新的空集。

set和frozenset的实例提供以下操作：

• len(s)

  • 返回集合* s 中的元素数(基数 s *)。

• x in s

  • 测试* x 作为 s *的成员资格。

• x not in s

  • 测试* x 是否为 s *中的非成员。

• isdisjoint(其他)

  • 如果集合没有与* other *共同的元素，则返回True。当且仅当它们的交集为空集时，集才是不相交的。

2.6 版的新Function。

• issubset(其他)

  • set <= other

    • 测试集合中的每个元素是否都在* other *中。

• set < other

  • 测试集合是否是* other *的正确子集，即set <= other and set != other。

• issuperset(其他)

  • set >= other

    • 测试* other *中的每个元素是否都在集合中。

• set > other

  • 测试该集合是否是* other *的正确超集，即set >= other and set != other。

• union(*其他)

  • set | other | ...

    • 返回具有该集合和所有其他元素的新集合。

在 2.6 版中更改：接受多个 Importing 可迭代项。

• intersection(*其他)

  • set & other & ...

    • 返回一个新集合，其中包含该集合和所有其他集合共同的元素。

在 2.6 版中更改：接受多个 Importing 可迭代项。

• difference(*其他)

  • set - other - ...

    • 返回一个新集合，该集合中的元素不在其他集合中。

在 2.6 版中更改：接受多个 Importing 可迭代项。

• symmetric_difference(其他)

  • set ^ other

    • 返回一个新集合，该集合中包含元素或“其他”中的元素，但不能同时包含两者。

• copy ( )

  • 返回集合的浅表副本。

请注意，union()，intersection()，difference()以及symmetric_difference()，issubset()和issuperset()方法的非运算符版本将接受任何 iterable 作为参数。相反，其基于运算符的对应项要求将其参数设置为。这就避免了像set('abc') & 'cbs'这样的易于出错的结构，而采用了更具可读性的set('abc').intersection('cbs')。

set和frozenset支持均设置为设置比较。当且仅当每个集合的每个元素都包含在另一个集合中(每个元素是另一个子集)时，两个集合才相等。当且仅当第一集合是第二集合的适当子集(是子集，但不相等)时，一个集合小于另一个集合。当且仅当第一个集合是第二个集合的适当超集(是一个超集，但不相等)时，一个集合才大于另一个集合。

set实例将根据其成员与frozenset实例进行比较。例如，set('abc') == frozenset('abc')返回True，set('abc') in set([frozenset('abc')])也返回。

子集和相等性比较不能推广到总排序Function。例如，任何两个非空的不交集都不相等，也不是彼此的子集，因此以下的“全部”返回False：a<b，a==b或a>b。因此，集合不实现cmp()方法。

由于集合仅定义部分排序(子集关系)，因此对于集合列表未定义list.sort()方法的输出。

集合元素(例如字典键)必须为hashable。

将set个实例与frozenset混合的二进制运算返回第一个操作数的类型。例如：frozenset('ab') | set('bc')返回frozenset的实例。

下表列出了适用于set的操作，不适用于frozenset的不可变实例：

• update(*其他)

  • set |= other | ...

    • 更新集合，添加所有其他元素。

在 2.6 版中更改：接受多个 Importing 可迭代项。

• intersection_update(*其他)

  • set &= other & ...

    • 更新集合，仅保留其中以及所有其他元素。

在 2.6 版中更改：接受多个 Importing 可迭代项。

• difference_update(*其他)

  • set -= other | ...

    • 更新集合，删除其他元素。

在 2.6 版中更改：接受多个 Importing 可迭代项。

• symmetric_difference_update(其他)

  • set ^= other

    • 更新集合，只保留在任何一个集合中找到的元素，而不同时在两个集合中找到。

• add(* elem *)

  • 将元素* elem *添加到集合中。

• remove(* elem *)

  • 从集合中删除元素* elem 。如果集合中不包含 elem *，则引发KeyError。

• discard(* elem *)

  • 从集合中删除元素* elem *(如果存在)。

• pop ( )

  • 从集合中删除并返回任意元素。如果集合为空，则引发KeyError。

• clear ( )

  • 从集合中删除所有元素。

请注意，update()，intersection_update()，difference_update()和symmetric_difference_update()方法的非运算符版本将接受任何可迭代的参数。

注意，contains()，remove()和discard()方法的* elem 参数可以是一个集合。为了支持搜索等效的冻结集，从 elem *创建了一个临时集。

5.8. Map 类型— dict

mapping对象将hashable值 Map 到任意对象。Map 是可变的对象。当前只有一种标准 Map 类型* dictionary *。 (有关其他容器，请参见内置的list，set和tuple类以及collections模块。)

词典的键几乎是任意值。非hashable的值，即包含列表，字典或其他可变类型的值(按值而不是对象标识进行比较)不得用作键。用于键的数字类型遵循数字比较的一般规则：如果两个数字比较相等(例如1和1.0)，则可以互换使用它们来索引相同的字典条目。 (但是请注意，由于计算机将浮点数存储为近似值，因此将它们用作字典键通常是不明智的.)

可以pass在括号中放置key: value对的逗号分隔列表(例如{'jack': 4098, 'sjoerd': 4127}或{4098: 'jack', 4127: 'sjoerd'})或dict构造函数来创建字典。

• • class * dict(*** kwarg *)
• • class * dict(* mapping ，** kwarg *)
• • class * dict(* iterable ，** kwarg *)
  • 返回一个新的字典，该字典根据一个可选的位置参数和一组可能为空的关键字参数初始化。

如果没有给出位置参数，则创建一个空字典。如果给出了位置参数并且它是一个 Map 对象，则将使用与该 Map 对象相同的键值对创建一个字典。否则，位置参数必须是iterable对象。可迭代对象中的每个项目本身都必须是具有两个对象的可迭代对象。每个项目的第一个对象成为新字典中的键，第二个对象成为相应的值。如果某个键多次出现，则该键的最后一个值将成为新字典中的相应值。

如果给出了关键字参数，则关键字参数及其值将添加到根据位置参数创建的字典中。如果已经存在要添加的键，则关键字自变量中的值将替换位置自变量中的值。

为了说明，以下示例均返回等于{"one": 1, "two": 2, "three": 3}的字典：

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e
True

如第一个示例中那样，提供关键字参数仅适用于有效的 Python 标识符的键。否则，可以使用任何有效的密钥。

2.2 版中的新Function。

在版本 2.3 中进行了更改：支持从添加的关键字参数构建字典。

这些是词典支持的操作(因此，自定义 Map 类型也应支持)：

• len(d)

  • 返回字典* d *中的项目数。

• d[key]

  • 用键* key 返回 d 的项。如果 key *不在 Map 中，则引发KeyError。

如果 dict 的子类定义了方法missing()，并且* key 不存在，则d[key]操作会以键 key *作为参数调用该方法。 d[key]操作然后返回或引发__missing__(key)调用返回或引发的所有内容。没有其他操作或方法调用missing()。如果未定义missing()，则引发KeyError。 missing()必须是一个方法；它不能是实例变量：

>>> class Counter(dict):
...     def __missing__(self, key):
...         return 0
>>> c = Counter()
>>> c['red']
0
>>> c['red'] += 1
>>> c['red']
1

上面的示例显示了collections.Counter的部分实现。 collections.defaultdict使用了不同的__missing__方法。

2.5 版中的新Function：识别 dict 子类的__missing_方法。

• d[key] = value

  • 将d[key]设置为* value *。

• del d[key]

  • 从* d 中删除d[key]。如果 key *不在 Map 中，则引发KeyError。

• key in d

  • 如果* d 具有键 key *，则返回True，否则返回False。

2.2 版中的新Function。

• key not in d

  • 等效于not key in d。

2.2 版中的新Function。

• iter(d)

  • 在字典的键上返回一个迭代器。这是iterkeys()的快捷方式。

• clear ( )

  • 从字典中删除所有项目。

• copy ( )

  • 返回字典的浅表副本。

• fromkeys(* seq * [，* value *])

  • 使用* seq 中的键和将值设置为 value *来创建新字典。

fromkeys()是返回新字典的类方法。 值默认为None。

2.3 版的新Function。

• get(* key * [，* default *])

  • 如果字典中有* key ，则返回 key 的值，否则返回 default 。如果未提供 default *，则默认为None，因此该方法永远不会引发KeyError。

• has_key(* key *)

  • 测试字典中是否存在* key *。弃用has_key()，而赞成key in d。

• items ( )

  • 返回字典的(key, value)对列表的副本。

CPython 实现细节： 键和值以任意 Sequences 列出，该 Sequences 是非随机的，在 Python 实现中会有所不同，并且取决于字典的插入和删除历史。

如果调用items()，keys()，values()，iteritems()，iterkeys()和itervalues()且未对字典进行任何中间修改，则列表将直接对应。这允许使用zip()：pairs = zip(d.values(), d.keys())创建(value, key)对。 iterkeys()和itervalues()方法具有相同的关系：pairs = zip(d.itervalues(), d.iterkeys())为pairs提供相同的值。创建相同列表的另一种方法是pairs = [(v, k) for (k, v) in d.iteritems()]。

• iteritems ( )
  • 返回字典的(key, value)对上的迭代器。请参阅dict.items()的 Comments。

在字典中添加或删除条目时使用iteritems()可能会引发RuntimeError或无法迭代所有条目。

2.2 版中的新Function。

• iterkeys ( )
  • 在字典的键上返回一个迭代器。请参阅dict.items()的 Comments。

在字典中添加或删除条目时使用iterkeys()可能会引发RuntimeError或无法迭代所有条目。

2.2 版中的新Function。

• itervalues ( )
  • 返回字典值的迭代器。请参阅dict.items()的 Comments。

在字典中添加或删除条目时使用itervalues()可能会引发RuntimeError或无法迭代所有条目。

2.2 版中的新Function。

• keys ( )

  • 返回字典的键列表的副本。请参阅dict.items()的 Comments。

• pop(* key * [，* default *])

  • 如果* key 在字典中，请删除它并返回其值，否则返回 default 。如果未提供 default 且词典中未提供 key *，则会引发KeyError。

2.3 版的新Function。

• popitem ( )
  • 从字典中删除并返回任意的(key, value)对。

popitem()对于破坏性地迭代字典很有用，这在集合算法中经常使用。如果字典为空，则调用popitem()会引发KeyError。

• setdefault(* key * [，* default *])

  • 如果* key 在字典中，则返回其值。如果不是，请使用 default 值插入 key 并返回 default *。 默认默认为None。

• update([[* other *])

  • 使用* other *中的键/值对更新字典，覆盖现有键。返回None。

update()接受另一个字典对象或键/值对的迭代(作为 Tuples 或长度为 2 的其他迭代)。如果指定了关键字参数，则将使用以下键/值对更新字典：d.update(red=1, blue=2)。

在版本 2.4 中更改：允许参数是键/值对的迭代，并允许关键字参数。

• values ( )

  • 返回字典值列表的副本。请参阅dict.items()的 Comments。

• viewitems ( )

  • 返回字典项的新视图((key, value)对)。请参阅以下有关视图对象的文档。

2.7 版的新Function。

• viewkeys ( )
  • 返回字典键的新视图。请参阅以下有关视图对象的文档。

2.7 版的新Function。

• viewvalues ( )
  • 返回字典值的新视图。请参阅以下有关视图对象的文档。

2.7 版的新Function。

当且仅当它们具有相同的(key, value)对时，字典才会比较相等。

5.8.1. 字典视图对象

dict.viewkeys()，dict.viewvalues()和dict.viewitems()返回的对象是* view objects *。它们提供了字典条目的动态视图，这意味着当字典更改时，该视图会反映这些更改。

字典视图可以迭代生成各自的数据，并支持成员资格测试：

• len(dictview)

  • 返回字典中的条目数。

• iter(dictview)

  • 在字典中的键，值或项(表示为(key, value)的 Tuples)上返回一个迭代器。

键和值以任意 Sequences 进行迭代，该 Sequences 是非随机的，在 Python 实现中会有所不同，并且取决于字典的插入和删除历史。如果对键，值和项视图进行了迭代，而对字典没有任何中间修改，则项的 Sequences 将直接对应。这允许使用zip()：pairs = zip(d.values(), d.keys())创建(value, key)对。创建相同列表的另一种方法是pairs = [(v, k) for (k, v) in d.items()]。

在字典中添加或删除条目时迭代视图可能会引发RuntimeError或无法迭代所有条目。

• x in dictview

  • 如果* x 在基础字典的键，值或项目中，则返回True(在后一种情况下， x *应该是(key, value)Tuples)。

键视图是集合式的，因为它们的条目是唯一且可哈希的。如果所有值都是可哈希的，因此(键，值)对是唯一且可哈希的，则项目视图也将类似于集合。 (由于条目通常不是唯一的，因此值视图不会被视为类似集合的对象.)然后可以使用这些集合操作(“其他”是指另一个视图或集合)：

• dictview & other

  • 返回 dictview 和另一个对象的交集作为新集合。

• dictview | other

  • 返回 dictview 和另一个对象的并集作为新集合。

• dictview - other

  • 作为新集合，返回 dictview 和其他对象(* dictview 中的所有元素不在 other *中)之间的差异。

• dictview ^ other

  • 返回 dictview 和另一个对象的对称差(所有元素在* dictview 或 other *中，但不在两个元素中)作为新集合。

字典视图用法的一个示例：

>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.viewkeys()
>>> values = dishes.viewvalues()

>>> # iteration
>>> n = 0
>>> for val in values:
...     n += val
>>> print(n)
504

>>> # keys and values are iterated over in the same order
>>> list(keys)
['eggs', 'bacon', 'sausage', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['spam', 'bacon']

>>> # set operations
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}

5.9. 文件对象

文件对象是使用 C 的stdio包实现的，并且可以使用内置的open()函数创建。文件对象还由其他一些内置函数和方法返回，例如os.popen()和os.fdopen()以及套接字对象的makefile()方法。可以使用tempfile模块创建临时文件，并且可以使用shutil模块实现高级文件操作，例如复制，移动和删除文件和目录。

当文件操作由于与 I/O 相关的原因而失败时，将引发异常IOError。这包括由于某种原因未定义操作的情况，例如 tty 设备上的seek()或写入已打开以供读取的文件。

文件具有以下方法：

• file. close ( )
  • 关闭文件。关闭的文件无法再读取或写入。关闭文件后，任何需要打开文件的操作都将引发ValueError。允许多次呼叫close()。

从 Python 2.5 开始，如果使用with语句，则可以避免显式调用此方法。例如，当退出with块时，以下代码将自动关闭* f *：

from __future__ import with_statement # This isn't required in Python 2.6

with open("hello.txt") as f:
    for line in f:
        print line,

在旧版本的 Python 中，您需要执行以下操作才能获得相同的效果：

f = open("hello.txt")
try:
    for line in f:
        print line,
finally:
    f.close()

• file. flush ( )
  • 刷新内部缓冲区，例如stdio的fflush()。在某些类似文件的对象上，这可能是个禁忌。

• file. fileno ( )
  • 返回整数“文件 Descriptors”，基础实现使用该整数来从 os 请求 I/O 操作。这对于使用文件 Descriptors 的其他较低级别的接口(例如fcntl模块或os.read()和朋友)很有用。

• file. isatty ( )
  • 如果文件已连接到 tty(-like)设备，则返回True，否则返回False。

• file. next ( )
  • 文件对象是其自己的迭代器，例如iter(f)返回* f (除非 f *关闭)。当文件用作迭代器时，通常在for循环(例如for line in f: print line.strip())中，将重复调用next()方法。此方法返回下一个 Importing 行，或者在打开文件进行读取时(如果打开文件则为 EOF)(在打开文件进行写入时，行为未定义)。为了使for循环成为遍历文件行的最有效方法(一种非常常见的操作)，next()方法使用了隐藏的预读缓冲区。由于使用了预读缓冲区，因此无法将next()与其他文件方法(例如readline())结合使用。但是，使用seek()将文件重新定位到绝对位置将刷新预读缓冲区。

2.3 版的新Function。

• file. read([* size *])
  • 从文件中读取最多* size 个字节(如果读取在获得 size 个字节之前达到 EOF，则更少)。如果 size 参数为负或Ellipsis，请读取所有数据，直到达到 EOF。字节作为字符串对象返回。立即遇到 EOF 时，将返回一个空字符串。 (对于某些文件，例如 ttys，在命中 EOF 之后 continue 读取是有意义的.)请注意，此方法可能多次调用基础 C 函数fread()，以获取尽可能接近 size 的字节。另请注意，在非阻塞模式下，即使未指定 size *参数，返回的数据也可能少于请求的数据。

• file. readline([* size *])
  • 从文件中读取整行。字符串中保留尾随换行符(但是，如果文件以不完整的行结尾，则可能不存在)。 [6]如果存在* size 参数且该参数非负数，则它是最大字节数(包括结尾的换行符)，并且可能返回不完整的行。当 size 不为 0 时，当立即遇到 EOF 时，仅返回一个空字符串。

• file. readlines([* sizehint *])

  • 使用readline()读取直到 EOF，然后返回包含已读取行的列表。如果存在可选的* sizehint 参数，则读取的总行数大约为 sizehint 字节(可能在四舍五入为内部缓冲区大小之后)，而不是读取 EOF。如果无法实现或无法高效实现，则实现类似文件的接口的对象可以选择忽略 sizehint *。

• file. xreadlines ( )

  • 此方法返回与iter(f)相同的东西。

2.1 版中的新Function。

从 2.3 版开始不推荐使用：改为使用for line in file。

• file. seek(* offset * [，* whence *])
  • 设置文件的当前位置，例如stdio的fseek()。 * whence *参数是可选的，默认为os.SEEK_SET或0(绝对文件定位)；其他值为os.SEEK_CUR或1(相对于当前位置搜索)和os.SEEK_END或2(相对于文件末尾搜索)。没有返回值。

例如，f.seek(2, os.SEEK_CUR)将位置前进 2，而f.seek(-3, os.SEEK_END)将位置排在最后一位。

请注意，如果打开文件进行追加(模式'a'或'a+')，则在下一次写入时将撤消任何seek()操作。如果仅打开文件以在追加模式('a')下进行写入，则此方法本质上是无操作的，但是对于在启用了读取的追加模式('a+')下打开的文件仍然有用。如果以文本模式(不带'b')打开文件，则仅tell()返回的偏移量是合法的。使用其他偏移量会导致未定义的行为。

请注意，并非所有文件对象都是可搜索的。

在 2.6 版中进行了更改：不建议使用将 float 值作为 offset 传递。

• file. tell ( )
  • 返回文件的当前位置，例如stdio的ftell()。

• file. truncate([* size *])

  • 截断文件的大小。如果存在可选的* size *参数，则文件将被截断为(最多)该大小。尺寸默认为当前位置。当前文件位置未更改。请注意，如果指定的大小超过文件的当前大小，则结果取决于平台：可能的情况包括文件可能保持不变，增大为指定大小(好像是零填充的)或使用未定义的新内容增大为指定的大小。可用性：Windows，许多 Unix 变体。

• file. write(* str *)

  • 将字符串写入文件。没有返回值。由于缓冲的原因，在调用flush()或close()方法之前，字符串实际上可能不会显示在文件中。

• file. writelines(序列)

  • 将字符串序列写入文件。该序列可以是产生字符串的任何可迭代对象，通常是字符串列表。没有返回值。 (该名称旨在匹配readlines()； writelines()不添加行分隔符。)

文件支持迭代器协议。每次迭代返回与readline()相同的结果，并且当readline()方法返回空字符串时，迭代结束。

文件对象还提供了许多其他有趣的属性。这些对于类文件的对象不是必需的，但是如果它们对特定对象有意义，则应实现它们。

• file. closed

  • bool 指示文件对象的当前状态。这是一个只读属性； close()方法会更改值。它可能并非在所有类似文件的对象上都可用。

• file. encoding

  • 该文件使用的编码。将 Unicode 字符串写入文件时，将使用此编码将它们转换为字节字符串。另外，当文件连接到终端时，该属性给出该终端可能使用的编码(如果用户错误配置了该终端，则该信息可能不正确)。该属性是只读的，可能不会出现在所有类似文件的对象上。它也可以是None，在这种情况下，文件使用系统默认编码来转换 Unicode 字符串。

2.3 版的新Function。

• file. errors
  • 与编码一起使用的 Unicode 错误处理程序。

2.6 版的新Function。

• file. mode

  • 文件的 I/O 模式。如果文件是使用open()内置函数创建的，则该参数将为* mode *参数的值。这是一个只读属性，可能不会出现在所有类似文件的对象上。

• file. name

  • 如果文件对象是使用open()创建的，则为文件名。否则，某些字符串以<...>的形式指示文件对象的来源。这是一个只读属性，可能不会出现在所有类似文件的对象上。

• file. newlines

  • 如果 Python 是在启用universal newlines的情况下构建的(默认设置)，则此只读属性存在，并且对于以通用换行读取模式打开的文件，它会跟踪读取文件时遇到的换行类型。它可以采用的值是'\r'，'\n'，'\r\n'，None(未知，尚无换行符)或包含看到的所有换行符类型的 Tuples，以表示遇到了多个换行符约定。对于未以通用换行符读取模式打开的文件，此属性的值为None。

• file. softspace

  • 布尔值，指示使用print语句时是否需要在另一个值之前打印空格字符。试图模拟文件对象的类也应具有可写的softspace属性，该属性应初始化为零。对于大多数用 Python 实现的类，这将是自动的(重写属性访问的对象可能需要小心)；用 C 实现的类型必须提供可写的softspace属性。

5.10. memoryview 类型

2.7 版的新Function。

memoryview对象允许 Python 代码无需复制即可访问支持缓冲区协议的对象的内部数据。内存通常被解释为简单字节。

• 类别 memoryview(* obj *)
  • 创建一个引用* obj *的memoryview。 * obj *必须支持缓冲区协议。支持缓冲区协议的内置对象包括str和bytearray(但不包括unicode)。

memoryview具有* element 的概念，它是由原始对象 obj *处理的原子存储单元。对于许多简单类型，例如str和bytearray，元素是一个字节，但是其他第三方类型可能会公开较大的元素。

len(view)返回 memoryview 中的元素总数* view *。 itemsize属性将为您提供单个元素中的字节数。

memoryview支持切片以公开其数据。取得单个索引将返回单个元素作为str对象。完整切片将产生一个子视图：

>>> v = memoryview('abcefg')
>>> v[1]
'b'
>>> v[-1]
'g'
>>> v[1:4]
<memory at 0x77ab28>
>>> v[1:4].tobytes()
'bce'

如果 memoryview 结束的对象支持更改其数据，则 memoryview 支持切片分配：

>>> data = bytearray('abcefg')
>>> v = memoryview(data)
>>> v.readonly
False
>>> v[0] = 'z'
>>> data
bytearray(b'zbcefg')
>>> v[1:4] = '123'
>>> data
bytearray(b'z123fg')
>>> v[2] = 'spam'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: cannot modify size of memoryview object

请注意如何无法更改 memoryview 对象的大小。

memoryview有两种方法：

• tobytes ( )
  • 以字节串形式返回缓冲区中的数据(类str的对象)。

>>> m = memoryview("abc")
>>> m.tobytes()
'abc'

• tolist ( )
  • 以整数列表形式返回缓冲区中的数据。

>>> memoryview("abc").tolist()
[97, 98, 99]

还有一些可用的只读属性：

• format

  • 一个字符串，其中包含视图中每个元素的格式(struct模块样式)。默认为'B'(一个简单的字节串)。

• itemsize

  • memoryview 的每个元素的大小(以字节为单位)。

• shape

  • 长度为ndim的整数 Tuples，将内存的形状表示为 N 维数组。

• ndim

  • 一个整数，指示内存代表多维数组的多少维。

• strides

  • 长度为ndim的整数 Tuples，以字节为单位给出访问数组每个维度的每个元素的大小。

• readonly

  • 一个布尔值，指示存储器是否为只读。

5.11. 上下文 Management 器类型

2.5 版的新Function。

Python 的with语句支持上下文 Management 器定义的运行时上下文的概念。这使用两种单独的方法实现，这些方法允许用户定义的类定义运行时上下文，该上下文在执行语句主体之前 Importing，在语句结束时退出。

上下文 Management 协议由Pair方法组成，它们需要为上下文 Management 器对象提供以定义运行时上下文：

• contextmanager. __enter__ ( )
  • Importing 运行时上下文，然后返回该对象或与运行时上下文相关的另一个对象。使用此上下文 Management 器，此方法返回的值绑定到with语句的as子句中的标识符。

返回自身的上下文 Management 器的一个示例是文件对象。文件对象从__enter __()返回自身，以允许open()用作with语句中的上下文表达式。

返回相关对象的上下文 Management 器的一个示例是decimal.localcontext()返回的对象。这些 Management 器将活动的十进制上下文设置为原始十进制上下文的副本，然后返回该副本。这允许对with语句主体中的当前十进制上下文进行更改，而不会影响with语句外部的代码。

• contextmanager. __exit__(* exc_type ， exc_val ， exc_tb *)
  • 退出运行时上下文，并返回一个布尔值标志，指示是否应禁止发生的任何异常。如果在执行with语句的主体时发生异常，则参数包含异常类型，值和回溯信息。否则，所有三个参数均为None。

从此方法返回 true 值将导致with语句抑制该异常，并 continue 在with语句之后立即使用该语句执行。否则，异常将在此方法执行完后 continue 传播。执行此方法期间发生的异常将替换with语句主体中发生的任何异常。

传入的异常永远不应显式引发-相反，此方法应返回 false 值，以指示该方法已成功完成并且不想抑制所引发的异常。这使上下文 Management 代码(例如contextlib.nested)可以轻松检测exit()方法是否实际上已失败。

Python 定义了多个上下文 Management 器，以支持轻松的线程同步，迅速关闭文件或其他对象以及对活动的十进制算术上下文进行更简单的操作。除了特定类型的上下文 Management 协议的实现以外，不对它们进行特殊处理。有关一些示例，请参见contextlib模块。

Python 的generator和contextlib.contextmanager decorator提供了实现这些协议的便捷方法。如果生成器函数用contextlib.contextmanager装饰器装饰，它将返回实现必需的enter()和exit()方法的上下文 Management 器，而不是由未修饰的生成器函数生成的迭代器。

请注意，在 Python/C API 中，Python 对象的类型结构中没有任何针对这些方法的特定插槽。想要定义这些方法的扩展类型必须提供它们作为普通的 Python 可访问方法。与设置运行时上下文的开销相比，单个类字典查找的开销可以忽略不计。

5.12. 其他内置类型

解释器支持其他几种对象。其中大多数仅支持一两个操作。

5.12.1. Modules

模块上唯一的特殊操作是属性访问：m.name，其中* m 是模块，而 name 访问 m 的符号表中定义的名称。可以分配模块属性。 (请注意，严格地说，import语句不是对模块对象的操作； import foo不需要存在名为 foo 的模块对象，而是需要对名为 foo 的模块进行(外部) definition *某处。)

每个模块的特殊属性是dict。这是包含模块符号表的字典。修改此字典实际上会更改模块的符号表，但是无法直接分配给dict属性(您可以编写m.__dict__['a'] = 1，它将m.a定义为1，但不能编写m.__dict__ = {})。不建议直接修改dict。

解释器中内置的模块的编写方式如下：<module 'sys' (built-in)>。如果从文件加载，它们将被写为<module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>。

5.12.2. 类和类实例

有关这些信息，请参见对象，值和类型和Class definitions。

5.12.3. Functions

Function对象由Function定义创建。对Function对象的唯一操作是调用它：func(argument-list)。

函数对象实际上有两种类型：内置函数和用户定义函数。两者都支持相同的操作(以调用函数)，但是实现方式不同，因此对象类型也不同。

有关更多信息，请参见Function definitions。

5.12.4. Methods

方法是使用属性符号调用的函数。有两种类型：内置方法(例如列表上的append())和类实例方法。描述了内置方法及其支持的类型。

该实现向类实例方法添加了两个特殊的只读属性：m.im_self是该方法在其上操作的对象，而m.im_func是实现该方法的函数。调用m(arg-1, arg-2, ..., arg-n)完全等效于调用m.im_func(m.im_self, arg-1, arg-2, ..., arg-n)。

类实例方法是* bound 或 unbound *，分别表示该方法是pass实例还是pass类访问的。当方法未绑定时，其im_self属性将为None，如果调用此方法，则必须将显式self对象作为第一个参数传递。在这种情况下，self必须是未绑定方法的类(或该类的子类)的实例，否则引发TypeError。

像函数对象一样，方法对象也支持获取任意属性。但是，由于方法属性实际上存储在基础函数对象(meth.im_func)上，因此不允许在绑定方法或未绑定方法上设置方法属性。try在方法上设置属性会引发AttributeError。为了设置方法属性，您需要在基础函数对象上显式设置它：

>>> class C:
...     def method(self):
...         pass
...
>>> c = C()
>>> c.method.whoami = 'my name is method'  # can't set on the method
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'instancemethod' object has no attribute 'whoami'
>>> c.method.im_func.whoami = 'my name is method'
>>> c.method.whoami
'my name is method'

有关更多信息，请参见标准类型层次结构。

5.12.5. 代码对象

该实现使用代码对象表示“伪编译的”可执行 Python 代码，例如函数体。它们与函数对象不同，因为它们不包含对其全局执行环境的引用。内置compile()函数返回代码对象，并且可以pass它们的func_code属性从代码对象中提取代码对象。另请参见code模块。

pass将代码对象(而不是源字符串)传递给exec语句或内置eval()函数，可以执行或评估代码对象。

有关更多信息，请参见标准类型层次结构。

5.12.6. 类型对象

类型对象代表各种对象类型。内置函数type()可访问对象的类型。类型上没有特殊的操作。标准模块types为所有标准内置类型定义名称。

类型是这样写的：<type 'int'>。

5.12.7. 空对象

该对象由未显式返回值的函数返回。它不支持任何特殊操作。只有一个空对象，名为None(内置名称)。

它写为None。

5.12.8. Ellipsis对象

扩展的切片符号使用此对象(请参见Slicings)。它不支持任何特殊操作。恰好有一个Ellipsis号对象，名为Ellipsis(内置名称)。

它写为Ellipsis。在下标中时，也可以写为...，例如seq[...]。

5.12.9. 未实现的对象

当要求它们对不支持的类型进行操作时，该对象将从比较和二进制操作返回。有关更多信息，请参见Comparisons。

它写为NotImplemented。

5.12.10. 布尔值

布尔值是两个常量对象False和True。它们用于表示真值(尽管其他值也可以视为假或真)。在数字上下文中(例如，用作算术运算符的参数时)，它们的行为分别类似于整数 0 和 1.如果该值可以解释为真值，则可以使用内置函数bool()将任何值转换为布尔值(请参见上面的真值测试部分)。

它们分别写为False和True。

5.12.11. 内部对象

有关此信息，请参见标准类型层次结构。它描述了堆栈框架对象，回溯对象和切片对象。

5.13. 特殊属性

该实现向与它们相关的几种对象类型添加了一些特殊的只读属性。 dir()内置函数未报告其中的一些。

• object. __dict__

  • 用于存储对象(可写)属性的字典或其他 Map 对象。

• object. __methods__

  • 从 2.2 版开始不推荐使用：使用内置函数dir()获取对象属性的列表。该属性不再可用。

• object. __members__

  • 从 2.2 版开始不推荐使用：使用内置函数dir()获取对象属性的列表。该属性不再可用。

• instance. __class__

  • 类实例所属的类。

• class. __bases__

  • 类对象的 Base Class 的 Tuples。

• definition. __name__

  • 类，类型，函数，方法，Descriptors 或生成器实例的名称。

new-style class es 仅支持以下属性。

• class. __mro__

  • 此属性是在方法解析期间寻找 Base Class 时要考虑的类的 Tuples。

• class. mro ( )

  • 元类可以覆盖此方法，以为其实例自定义方法解析 Sequences。在类实例化时调用它，其结果存储在mro中。

• class. __subclasses__ ( )

  • 每个新样式类均保留对其直接子类的弱引用列表。此方法返回所有这些引用仍然存在的列表。例：

>>> int.__subclasses__()
[<type 'bool'>]

Footnotes

• [1]

  • 有关这些特殊方法的更多信息，请参见《 Python 参考手册》(Basic customization)。

• [2]

  • 结果，列表[1, 2]被认为等于[1.0, 2.0]，并且对于 Tuples 类似。

• [3]

  • 因为解析器无法分辨操作数的类型，所以它们必须具有。

• 4 (1,2,3,4)

  • 大小写字符是那些具有常规类别属性的字符，它们是“ Lu”(字母大写)，“ Ll”(字母小写)或“ Lt”(字母大写)之一。

• [5]

  • 因此，仅格式化一个 Tuples，您应该提供一个单例 Tuples，其唯一元素是要格式化的 Tuples。

• [6]

  • 保留换行符的好处是返回空字符串才是明确的 EOF 指示。也有可能(例如，在您可能想要在扫描文件的行时精确复制文件的情况下)判断文件的最后一行是否以换行符结尾(是的， ！)。