内置类型

以下部分描述了内置在解释器中的标准类型。

主要的内置类型是数字、序列、映射、类、实例和异常。

某些集合类是可变的。在适当的位置添加、减去或重新排列成员，并且不返回特定项的方法，从不返回集合实例本身，但 None .

一些操作由多个对象类型支持；特别是，几乎所有对象都可以进行相等比较、测试真值并转换为字符串（使用 repr() 功能还是稍有不同 str() 函数）。当对象由 print() 功能。

真值检验

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

默认情况下，除非对象的类定义了 __bool__() 返回的方法 False 或A __len__() 当用对象调用时返回零的方法。 1 以下是大多数被认为是错误的内置对象：

• 定义为假的常量： None 和 False .

• 任何数字类型的零： 0 ， 0.0 ， 0j ， Decimal(0) ， Fraction(0, 1)

• 空序列和集合： '' ， () ， [] ， {{}} ， set() ， range(0)

具有布尔结果的操作和内置函数始终返回 0 或 False 为假的 1 或 True 除非另有说明，否则为真。（重要例外：布尔运算 or 和 and 总是返回其中一个操作数。）

布尔运算--- and ， or ， not

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

操作	结果	笔记
x or y	如果 x 是假的，那么 y ，否则 x	(1)
x and y	如果 x 是假的，那么 x ，否则 y	(2)
not x	如果 x 是假的，那么 True ，否则 False	(3)

笔记：

1. 这是一个短路运算符，因此仅当第一个参数为假时才计算第二个参数。

2. 这是一个短路运算符，因此仅当第一个参数为真时才计算第二个参数。

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

比较

在python中有八个比较操作。它们都具有相同的优先级（高于布尔运算的优先级）。比较可以任意链接；例如， x < y <= z 等于 x < y and y <= z 除了 y 只评估一次（但在这两种情况下 z 当 x < y 被发现是错误的）。

下表总结了比较操作：

操作	意义
<	严格小于
<=	小于或等于
>	严格大于
>=	大于或等于
==	平等的
!=	不等
is	对象标识
is not	否定的对象标识

不同类型的对象（不同的数字类型除外）永远不会比较相等。这个 == 运算符总是被定义的，但对于某些对象类型（例如类对象），它等价于 is . 这个 < ， <= ， > 和 >= 只在有意义的地方定义运算符；例如，它们引发 TypeError 当其中一个参数是复数时出现异常。

类的不相同实例通常比较为不相等，除非类定义了 __eq__() 方法。

类的实例不能相对于同一类的其他实例或其他类型的对象排序，除非类定义了足够的方法 __lt__() ， __le__() ， __gt__() 和 __ge__() （一般而言， __lt__() 和 __eq__() 如果需要比较运算符的常规含义，就足够了）。

的行为 is 和 is not 不能自定义运算符；也可以将它们应用于任意两个对象，并且从不引发异常。

另外两个具有相同语法优先级的操作， in 和 not in ，由以下类型支持 iterable 或者执行 __contains__() 方法。

数字类型--- int ， float ， complex

有三种不同的数字类型： integers ， floating point numbers 和 complex numbers . 此外，布尔值是整数的子类型。整数具有无限的精度。浮点数通常使用 double 在C语言中，有关运行程序的机器的浮点数的精度和内部表示的信息，请参阅 sys.float_info . 复数有实部和虚部，它们都是浮点数。从复数中提取这些部分 z 使用 z.real 和 z.imag . （标准库包括其他数字类型 fractions.Fraction ，对于理性，以及 decimal.Decimal ，对于具有用户可定义精度的浮点数字。）

数字是由数字文字或内置函数和运算符创建的。未加修饰的整型文字（包括十六进制、八进制和二进制）生成整数。包含小数点或指数符号的数字文本产生浮点数。追加 'j' 或 'J' 对于数值文本，生成一个虚数（实数部分为零的复数），可以将其添加到整数或浮点数中，以获得具有实数和虚数部分的复数。

Python完全支持混合运算：当一个二进制算术运算符有不同数值类型的操作数时，具有“窄”类型的操作数将被加宽到另一个操作数，其中整数比浮点窄，浮点比复数窄。对不同类型的数字进行比较，就好像正在比较这些数字的确切值一样。 2

施工人员 int() ， float() 和 complex() 可用于生成特定类型的数字。

所有数值类型（复杂类型除外）都支持以下操作（有关操作的优先级，请参见 运算符优先级 ）：

操作	结果	笔记	完整文档
x + y	总和 x 和 y
x - y	差异性 x 和 y
x * y	产品 x 和 y
x / y	商 x 和 y
x // y	地板商 x 和 y	(1)
x % y	余下的 x / y	(2)
-x	x 否定的
+x	x 不变
abs(x)	绝对值或绝对量 x		abs()
int(x)	x 已转换为整数	(3)(6)	int()
float(x)	x 转换为浮点	(4)(6)	float()
complex(re, im)	实部复数 re ，虚部 im . im 默认为零。	(6)	complex()
c.conjugate()	复数的共轭 c
divmod(x, y)	这对 (x // y, x % y)	(2)	divmod()
pow(x, y)	x*的幂*y	(5)	pow()
x ** y	x*的幂*y	(5)

笔记：

1. 也称为整数除法。结果值是一个整数，尽管结果的类型不一定是int。结果总是四舍五入到负无穷大： 1//2 是 0 ， (-1)//2 是 -1 ， 1//(-2) 是 -1 和 (-1)//(-2) 是 0 .

2. 不适用于复数。而是使用 abs() 如果合适的话。

3. 从浮点到整数的转换可以像C中那样进行舍入或截断；请参见函数 math.floor() 和 math.ceil() 对于定义明确的转换。

4. float还接受带有可选前缀“+”或“-”的字符串“nan”和“inf”，而不是数字（nan）和正无穷大或负无穷大。

5. Python定义 pow(0, 0) 和 0 ** 0 成为 1 和编程语言一样。

6. 接受的数字文字包括数字 0 到 9 或任何Unicode等价物（代码点 Nd 属性）。

   见https://www.unicode.org/Public/13.0.0/ucd/extracted/DerivedNumericType.txt对于完整的代码点列表 Nd 财产。

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

操作	结果
math.trunc(x)	x 截断到 Integral
round(x[, n])	x 四舍五入 n 数字，四舍五入到偶数。如果 n 省略，默认为0。
math.floor(x)	最伟大的 Integral <= x
math.ceil(x)	最少的 Integral > x

有关其他数字操作，请参见 math 和 cmath 模块。

整数类型的位运算

位运算只对整数有意义。计算按位运算的结果，就好像用无限个符号位对二进行补一样。

二元按位运算的优先级都低于数值运算，高于比较运算；一元运算 ~ 与其他一元数值运算具有相同的优先级 (+ 和 - ）

此表列出按升序优先级排序的按位操作：

操作	结果	笔记
x | y	按位 or 属于 x 和 y	(4)
x ^ y	按位 exclusive or 属于 x 和 y	(4)
x & y	按位 and 属于 x 和 y	(4)
x << n	x 左移 n 位	(1)(2)
x >> n	x 右移了 n 位	(1)(3)
~x	比特 x 倒转

笔记：

1. 负移位计数是非法的，会导致 ValueError 被引发。

2. 左移 n 位等于乘 pow(2, n) .

3. 右移 n bits等于floor除法 pow(2, n) .

4. 在有限的二补表示中使用至少一个额外的符号扩展位（工作位宽度为 1 + max(x.bit_length(), y.bit_length()) 或者更多）足以得到相同的结果，就好像符号位的数目是无限的一样。

整数类型的其他方法

int类型实现 numbers.Integral abstract base class . 此外，它还提供了一些其他方法：

int.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 .

等同于：

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

3.1 新版功能.

int.bit_count()

返回整数绝对值的二进制表示形式中的个数。这也被称为人口统计。例子：：

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3

等同于：

def bit_count(self):
    return bin(self).count("1")

3.10 新版功能.

int.to_bytes(length, byteorder, *, signed=False)

返回表示整数的字节数组。

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'

整数表示为 长度 字节。安 OverflowError 如果整数不能用给定的字节数表示，则引发。

这个 字节顺序 参数确定用于表示整数的字节顺序。如果 字节顺序 是 "big" ，最重要的字节位于字节数组的开头。如果 字节顺序 是 "little" ，最重要的字节位于字节数组的末尾。要请求主机系统的本机字节顺序，请使用 sys.byteorder 作为字节顺序值。

这个 签署 参数确定二的补码是否用于表示整数。如果 签署 是 False 并给出一个负整数，即 OverflowError 提高了。的默认值 签署 是 False .

3.2 新版功能.

classmethod int.from_bytes(bytes, byteorder, *, signed=False)

返回由给定字节数组表示的整数。

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

参数 字节 必须是 bytes-like object 或者一个不可重复的产生字节。

这个 字节顺序 参数确定用于表示整数的字节顺序。如果 字节顺序 是 "big" ，最重要的字节位于字节数组的开头。如果 字节顺序 是 "little" ，最重要的字节位于字节数组的末尾。要请求主机系统的本机字节顺序，请使用 sys.byteorder 作为字节顺序值。

这个 签署 参数指示二的补码是否用于表示整数。

3.2 新版功能.

int.as_integer_ratio()

返回一对整数，其比率正好等于原始整数，且具有正分母。整数（整数）的整数比始终是作为分子的整数，并且 1 作为分母。

3.8 新版功能.

浮动的附加方法

float类型实现 numbers.Real abstract base class . float还具有以下附加方法。

float.as_integer_ratio()

返回一对整数，该整数的比率正好等于原始浮点数，并且具有正分母。引发 OverflowError 关于无穷大和 ValueError 关于NANS。

float.is_integer()

返回 True 如果浮点实例是具有整数值的有限实例，并且 False 否则：：

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

两种方法支持十六进制字符串之间的转换。由于python的float在内部存储为二进制数，因此将float与 十进制的 字符串通常包含一个小的舍入误差。相反，十六进制字符串允许精确表示和指定浮点数字。这在调试和数值计算时很有用。

float.hex()

以十六进制字符串形式返回浮点数的表示形式。对于有限的浮点数，此表示形式将始终包括一个前导 0x 拖尾 p 和指数。

classmethod float.fromhex(s)

类方法返回由十六进制字符串表示的浮点 s . 弦 s 可能有前导空格和尾随空格。

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

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

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

其中可选 sign 五月之一 + 或 - ， integer 和 fraction 是十六进制数字的字符串，并且 exponent 是带可选前导符号的十进制整数。大小写不重要，整数或分数中必须至少有一个十六进制数字。此语法类似于C99标准的第4.4.4.2节中所指定的语法，也与Java 1.5中使用的语法类似。尤其是 float.hex() 可作为C或Java代码中的十六进制浮点文字，以及C生成的十六进制字符串。 %a 格式化字符或Java Double.toHexString 被接受 float.fromhex() .

请注意，指数是用十进制而不是十六进制来表示的，它给出乘以系数的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'

数值类型的散列

对于数字 x 和 y 可能是不同类型的，要求 hash(x) == hash(y) 无论何时 x == y （见 __hash__() 方法文档了解更多详细信息）。以便于在各种数字类型（包括 int ， float ， decimal.Decimal 和 fractions.Fraction ）针对数值类型的python散列基于为任何有理数定义的单个数学函数，因此适用于 int 和 fractions.Fraction 以及 float 和 decimal.Decimal .本质上，这个函数是由约简模给出的。 P 对于固定素数 P . 价值 P 可作为 modulus 属性 sys.hash_info .

CPython implementation detail: 目前，使用的主要是 P = 2**31 - 1 在具有32位C长和 P = 2**61 - 1 在64位C长的机器上。

具体规则如下：

• 如果 x = m / n 是非负有理数，并且 n 不能被除 P 定义 hash(x) 作为 m * invmod(n, P) % P 在哪里 invmod(n, P) 给出 n 模 P .

• 如果 x = m / n 是非负有理数，并且 n 可分为 P （但是 m 则不是） n 没有反模 P 上面的规则不适用；在这种情况下，定义 hash(x) 定值 sys.hash_info.inf .

• 如果 x = m / n 是一个负的有理数定义 hash(x) 作为 -hash(-x) . 如果结果hash为 -1 ，替换为 -2 .

• 特定的价值观 sys.hash_info.inf ， -sys.hash_info.inf 和 sys.hash_info.nan 分别用作正无穷大、负无穷大或Nans的hash值。（所有可hash的nan具有相同的hash值。）

• 对于一个 complex 数 z ，通过计算将实部和虚部的散列值组合在一起。 hash(z.real) + sys.hash_info.imag * hash(z.imag) ，约化模 2**sys.hash_info.width 所以它就在 range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)) .如果结果是 -1 ，替换为 -2 .

为了澄清上述规则，下面是一些示例python代码，相当于内置hash，用于计算有理数的hash， float 或 complex ：：

import sys, math

def hash_fraction(m, n):
    """Compute the hash of a rational number m / n.

    Assumes m and n are integers, with n positive.
    Equivalent to hash(fractions.Fraction(m, n)).

    """
    P = sys.hash_info.modulus
    # Remove common factors of P.  (Unnecessary if m and n already coprime.)
    while m % P == n % P == 0:
        m, n = m // P, n // P

    if n % P == 0:
        hash_value = sys.hash_info.inf
    else:
        # Fermat's Little Theorem: pow(n, P-1, P) is 1, so
        # pow(n, P-2, P) gives the inverse of n modulo P.
        hash_value = (abs(m) % P) * pow(n, P - 2, P) % P
    if m < 0:
        hash_value = -hash_value
    if hash_value == -1:
        hash_value = -2
    return hash_value

def hash_float(x):
    """Compute the hash of a float x."""

    if math.isnan(x):
        return sys.hash_info.nan
    elif math.isinf(x):
        return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
    else:
        return hash_fraction(*x.as_integer_ratio())

def hash_complex(z):
    """Compute the hash of a complex number z."""

    hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
    # do a signed reduction modulo 2**sys.hash_info.width
    M = 2**(sys.hash_info.width - 1)
    hash_value = (hash_value & (M - 1)) - (hash_value & M)
    if hash_value == -1:
        hash_value = -2
    return hash_value

迭代器类型

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

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

container.__iter__()

返回迭代器对象。对象需要支持下面描述的迭代器协议。如果容器支持不同类型的迭代，则可以提供其他方法来专门为这些迭代类型请求迭代器。（支持多种迭代形式的对象的一个例子是支持宽度优先和深度优先遍历的树结构。）此方法对应于 tp_iter python/c api中python对象的类型结构的槽。

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

iterator.__iter__()

返回迭代器对象本身。这是允许容器和迭代器与 for 和 in 声明。此方法对应于 tp_iter python/c api中python对象的类型结构的槽。

iterator.__next__()

从容器中返回下一项。如果没有其他项目，请提高 StopIteration 例外。此方法对应于 tp_iternext python/c api中python对象的类型结构的槽。

python定义了几个迭代器对象，以支持对常规和特定序列类型、字典和其他更专业的表单进行迭代。除了迭代器协议的实现之外，特定类型并不重要。

一次迭代器 __next__() 方法抬高 StopIteration ，它必须在随后的调用中继续这样做。不遵守此属性的实现被视为已损坏。

生成器类型

Python 的 generator 为实现迭代器协议提供了一种方便的方法。如果容器对象的 __iter__() 方法被实现为一个生成器，它将自动返回一个迭代器对象（从技术上讲，是一个生成器对象），提供 __iter__() 和 __next__() 方法。有关生成器的更多信息，请参见 the documentation for the yield expression .

序列类型--- list ， tuple ， range

有三种基本序列类型：列表、元组和范围对象。为处理而定制的附加序列类型 binary data 和 text strings 在专用章节中描述。

公共序列操作

下表中的操作受大多数序列类型（可变和不可变）的支持。这个 collections.abc.Sequence 提供ABC是为了更容易在自定义序列类型上正确地实现这些操作。

此表列出按升序优先级排序的序列操作。在表格里， s 和 t 是同一类型的序列， n ， i ， j 和 k 是整数和 x 是满足任何类型和值限制的任意对象 s .

这个 in 和 not in 操作与比较操作具有相同的优先级。这个 + （串联）和 * （重复）操作与相应的数字操作具有相同的优先级。 3

操作	结果	笔记
x in s	True if an item of s is equal to x, else False	(1)
x not in s	False if an item of s is equal to x, else True	(1)
s + t	连接 s 和 t	(6)(7)
s * n or n * s	相当于添加 s 对自身 n 次	(2)(7)
s[i]	i 第9项 s origin 0	(3)
s[i:j]	切片 s 从 i 到 j	(3)(4)
s[i:j:k]	切片 s 从 i 到 j 随步 k	(3)(5)
len(s)	长度 s
min(s)	最小项 s
max(s)	最大项目 s
s.index(x[, i[, j]])	第一次出现的索引 x 在里面 s （在索引处或索引后） i 在索引之前 j ）	(8)
s.count(x)	发生的总次数 x 在里面 s

相同类型的序列也支持比较。尤其是，通过比较相应的元素，从词典的角度比较元组和列表。这意味着要比较相等，每个元素都必须比较相等，并且两个序列的类型和长度必须相同。（有关详细信息，请参阅 比较 在语言参考中。）

笔记：

1. 而 in 和 not in 操作仅用于一般情况下的简单安全壳测试，一些专门的序列（例如 str ， bytes 和 bytearray ）也可将其用于后续测试：

   >>> "gg" in "eggs"
   True
   

2. 价值观 n 小于 0 被视为 0 （生成与相同类型的空序列 s ）注意顺序中的项目 s 不被复制；它们被多次引用。这经常困扰着新的Python程序员；请考虑：

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

   发生了什么事 [[]] 是一个包含空列表的元素列表，因此 [[]] * 3 是对此单个空列表的引用。修改的任何元素 lists 修改此单个列表。您可以通过以下方式创建不同列表的列表：

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

   在FAQ条目中提供了进一步的解释。 如何创建多维列表？ .

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

4. 切片 s 从 i 到 j 定义为具有索引的项序列 k 这样的话 i <= k < j . 如果 i 或 j 大于 len(s) 使用 len(s) . 如果 i 被省略或 None 使用 0 . 如果 j 被省略或 None 使用 len(s) . 如果 i 大于或等于 j ，切片为空。

5. 切片 s 从 i 到 j 随步 k 定义为具有索引的项序列 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 如果它们更大。如果 i 或 j 被省略或 None ，它们成为“结束”值（哪一个结束取决于 k ）注： k 不能为零。如果 k 是 None ，就像对待 1 .

6. 连接不可变序列总是会产生一个新的对象。这意味着通过重复的连接构建序列将在总序列长度上具有二次运行时成本。要获得线性运行时成本，必须切换到以下选项之一：

   • 如果连接 str 对象，您可以构建一个列表并使用 str.join() 在结尾处，或者写信给 io.StringIO 实例并在完成时检索其值

   • 如果连接 bytes 对象，可以类似地使用 bytes.join() 或 io.BytesIO 或者您可以使用 bytearray 对象。 bytearray 对象是可变的，并且具有有效的过度分配机制

   • 如果连接 tuple 对象，扩展 list 相反

   • 对于其他类型，调查相关的类文档

7. 一些序列类型（例如 range ）只支持遵循特定模式的项目序列，因此不支持序列串联或重复。

8. index 引发 ValueError 什么时候？ x 在中未找到 s . 并非所有实现都支持传递附加参数 i 和 j . 这些参数允许有效地搜索序列的子部分。传递额外的参数大致等同于使用 s[i:j].index(x) 仅在不复制任何数据的情况下，并且返回的索引相对于序列的开始而不是切片的开始。

不可变序列类型

不可变序列类型通常实现的唯一操作不是也由可变序列类型实现的，而是支持 hash() 内置的。

这种支持允许不可变的序列，例如 tuple 实例，用作 dict 并存储在 set 和 frozenset 实例。

尝试hash包含不可hash值的不可变序列将导致 TypeError .

可变序列类型

下表中的操作是针对可变序列类型定义的。这个 collections.abc.MutableSequence 提供ABC是为了更容易在自定义序列类型上正确地实现这些操作。

在表格上 s 是可变序列类型的实例， t 是任何无法识别的对象 x 是满足任何类型和值限制的任意对象 s （例如， bytearray 只接受满足值限制的整数 0 <= x <= 255 ）

操作	结果	笔记
s[i] = x	项目 i 属于 s 被替换 x
s[i:j] = t	切片 s 从 i 到 j 替换为iterable的内容 t
del s[i:j]	等同于 s[i:j] = []
s[i:j:k] = t	元素 s[i:j:k] 替换为 t	(1)
del s[i:j:k]	删除的元素 s[i:j:k] 从名单上
s.append(x)	追加 x 到序列的结尾（与 s[len(s):len(s)] = [x] ）
s.clear()	从中删除所有项 s （同） del s[:] ）	(5)
s.copy()	创建的浅副本 s （同） s[:] ）	(5)
s.extend(t) or s += t	延伸 s 内容如下： t （大部分与 s[len(s):len(s)] = t ）
s *= n	更新 s 内容重复 n 次	(6)
s.insert(i, x)	插入物 x 进入之内 s 在给出的索引处 i （同） s[i:i] = [x] ）
s.pop([i])	在处检索项 i 同时也将其从 s	(2)
s.remove(x)	从中删除第一项 s 在哪里？ s[i] 等于 x	(3)
s.reverse()	反转的项 s 就位	(4)

笔记：

1. t 必须与要替换的切片的长度相同。

2. 可选参数 i 默认为 -1 ，以便默认情况下删除并返回最后一个项。

3. remove() 加薪 ValueError 什么时候？ x 在中未找到 s .

4. 这个 reverse() 方法在反转大序列时，为节省空间，对序列进行适当的修改。为了提醒用户它是由副作用操作的，它不会返回相反的序列。

5. clear() 和 copy() 为了与不支持切片操作的可变容器（例如 dict 和 set ） copy() 不是 collections.abc.MutableSequence 但是大多数具体的可变序列类都提供了它。

   3.3 新版功能: clear() 和 copy() 方法。

6. 价值 n 是一个整数，或者是一个实现 __index__() . 的零值和负值 n 清除序列。序列中的项目不被复制；它们被多次引用，如 s * n 在下面 公共序列操作 .

列表

列表是可变序列，通常用于存储同构项的集合（其中，精确的相似程度因应用而异）。

class list([iterable])

列表可以用多种方式构建：

• 使用一对方括号表示空列表： []

• 使用方括号，用逗号分隔项目： [a] ， [a, b, c]

• 使用列表理解： [x for x in iterable]

• 使用类型构造函数： list() 或 list(iterable)

构造函数构建一个列表，其项与 可迭代的 的项目。 可迭代的 可以是序列、支持迭代的容器或迭代器对象。如果 可迭代的 已经是一个列表，将生成并返回一个副本，类似于 iterable[:] . 例如， list('abc') 返回 ['a', 'b', 'c'] 和 list( (1, 2, 3) ) 返回 [1, 2, 3] . 如果没有给出参数，则构造函数将创建一个新的空列表， [] .

许多其他操作也会生成列表，包括 sorted() 内置的。

列表实现所有 common 和 mutable 顺序操作。列表还提供以下附加方法：

sort(*, key=None, reverse=False)

此方法只使用 < 项目之间的比较。异常不会被抑制-如果任何比较操作失败，整个排序操作都将失败（并且列表可能保持在部分修改状态）。

sort() 接受只能由关键字传递的两个参数 (keyword-only arguments ）：

key 指定一个参数的函数，该参数用于从每个列表元素中提取比较键（例如， key=str.lower ）列表中每个项目对应的键计算一次，然后用于整个排序过程。默认值为 None 表示列表项直接排序，而不计算单独的键值。

这个 functools.cmp_to_key() 实用程序可用于转换2.x样式 cmp 函数到 key 功能。

reverse 是布尔值。如果设置为 True ，然后对列表元素进行排序，就好像每个比较都是相反的。

该方法在对大序列进行排序时，为了节省空间，对序列进行了适当的修改。为了提醒用户它是由副作用操作的，它不会返回排序的序列（使用 sorted() 显式请求新的排序列表实例）。

这个 sort() 保证方法稳定。如果一个排序保证不改变比较相等的元素的相对顺序，那么它是稳定的——这有助于在多个过程中排序（例如，按部门排序，然后按薪等）。

有关排序示例和简短的排序教程，请参见 如何排序 .

CPython implementation detail: 当一个列表被排序时，试图改变甚至检查的效果是未定义的。python的C实现使列表在持续时间内显示为空，并引发 ValueError 如果它能够检测到列表在排序过程中发生了变化。

多元组

元组是不可变的序列，通常用于存储异构数据的集合（例如由 enumerate() 内置）。元组也用于需要不可变的同构数据序列的情况（例如允许在 set 或 dict 实例）。

class tuple([iterable])

元组可以通过多种方式构造：

• 使用一对括号表示空元组： ()

• 对单元组使用尾随逗号： a, 或 (a,)

• 用逗号分隔项目： a, b, c 或 (a, b, c)

• 使用 tuple() 内置的： tuple() 或 tuple(iterable)

构造函数生成一个元组，其项与 可迭代的 的项目。 可迭代的 可以是序列、支持迭代的容器或迭代器对象。如果 可迭代的 已经是一个元组，返回时不变。例如， tuple('abc') 返回 ('a', 'b', 'c') 和 tuple( [1, 2, 3] ) 返回 (1, 2, 3) .如果没有给出参数，则构造函数将创建一个新的空元组， () .

注意，实际上是逗号构成了一个元组，而不是括号。括号是可选的，除了在空元组的情况下，或者当需要括号来避免语法上的歧义时。例如， f(a, b, c) 是带有三个参数的函数调用，而 f((a, b, c)) 是以3元组作为唯一参数的函数调用。

元组实现所有 common 顺序操作。

对于按名称访问比按索引访问更清晰的异构数据集合， collections.namedtuple() 可能是比简单的元组对象更合适的选择。

范围

这个 range 类型表示不可变的数字序列，通常用于在 for 循环。

class range(stop)

class range(start, stop[, step])

范围构造函数的参数必须是整数（内置 int 或任何实现 __index__ 特殊方法）。如果 step 参数被省略，默认为 1 . 如果 开始 参数被省略，默认为 0 .如果 step 是零， ValueError 提高了。

为正 step ，范围的内容 r 由公式确定 r[i] = start + step*i 在哪里？ i >= 0 和 r[i] < stop .

否定的 step ，范围的内容仍由公式确定。 r[i] = start + step*i 但是约束条件是 i >= 0 和 r[i] > stop .

如果 r[0] 不满足值约束。范围确实支持负指数，但这些指数被解释为从正指数确定的序列末尾开始的索引。

包含绝对值的范围大于 sys.maxsize 允许但某些功能（如 len() 可以提高 OverflowError .

范围示例：

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]

范围实现所有 common 序列操作，除了串联和重复（由于range对象只能表示遵循严格模式的序列，重复和串联通常会违反该模式）。

start

的值 开始 参数（或） 0 如果未提供参数）

stop

的值 stop 参数

step

的值 step 参数（或） 1 如果未提供参数）

的优势 range 键入常规的 list 或 tuple 那是 range 无论对象所代表的范围大小（因为它只存储 start ， stop 和 step 值，根据需要计算单个项和子范围）。

范围对象实现 collections.abc.Sequence 并提供包含测试、元素索引查找、切片和对负索引的支持等功能（请参见 序列类型--- list ， tuple ， range ）：

>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18

测试范围对象是否与 == 和 != 将它们作为序列进行比较。也就是说，如果两个范围对象表示相同的值序列，则认为它们是相等的。（请注意，比较相等的两个范围对象可能具有不同的 start ， stop 和 step 例如，属性 range(0) == range(2, 1, 3) 或 range(0, 3, 2) == range(0, 4, 2) ）

在 3.2 版更改: 执行顺序ABC。支持切片和负索引。试验 int 对象以固定时间作为成员身份，而不是遍历所有项。

在 3.3 版更改: 定义“==”和“！='根据定义的值序列比较范围对象（而不是根据对象标识进行比较）。

3.3 新版功能: 这个 start ， stop 和 step 属性。

参见

• 这个 linspace recipe 演示如何实现适用于浮点应用程序的范围的延迟版本。

文本序列类型--- str

python中的文本数据是用 str 对象，或 strings . 字符串是不可变的 sequences Unicode码位。字符串文本的编写方式多种多样：

• 单引号： 'allows embedded "double" quotes'

• 双引号： "allows embedded 'single' quotes" .

• 三重引文： '''Three single quotes''' ， """Three double quotes"""

三重引号的字符串可以跨多行-所有关联的空白将包含在字符串文本中。

作为单个表达式的一部分且只有空格的字符串文本将隐式转换为单个字符串文本。也就是说， ("spam " "eggs") == "spam eggs" .

见 字符串与字节的字面值 有关字符串文字的各种形式（包括支持的转义序列）以及 r 禁用大多数转义序列处理的（“raw”）前缀。

也可以使用 str 构造函数。

由于没有单独的“character”类型，索引字符串将生成长度为1的字符串。也就是说，对于非空字符串 s ， s[0] == s[0:1] .

也没有可变的字符串类型，但是 str.join() 或 io.StringIO 可以用来有效地从多个片段构造字符串。

在 3.3 版更改: 为了向后兼容python 2系列， u 在字符串文本上再次允许使用前缀。它对字符串文本的含义没有影响，不能与 r 前缀。

class str(object='')

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

返回A string 版本 object . 如果 object 未提供，返回空字符串。否则，行为 str() 取决于 encoding 或 errors 如下所示。

如果既不 encoding 也不 errors 给出， str(object) 返回 object.__str__() ，这是“非正式”或可良好打印的字符串表示 object . 对于字符串对象，这是字符串本身。如果 object 没有一个 __str__() 方法，然后 str() 返回返回 repr(object) .

如果至少有一个 encoding 或 errors 给出， object 应该是 bytes-like object （例如） bytes 或 bytearray ）在这种情况下，如果 object 是一个 bytes （或） bytearray 对象，然后 str(bytes, encoding, errors) 等于 bytes.decode(encoding, errors) . 否则，在调用 bytes.decode() . 见 二进制序列类型--- bytes ， bytearray ， memoryview 和 缓冲协议 有关缓冲区对象的信息。

通过A bytes 对象到 str() 没有 encoding 或 errors 参数属于返回非正式字符串表示的第一种情况（另请参见 -b python的命令行选项）。例如：：

>>> str(b'Zoot!')
"b'Zoot!'"

有关 str 类及其方法，请参见 文本序列类型--- str 以及 字符串方法 以下部分。要输出格式化字符串，请参见 格式化字符串文本 和 格式字符串语法 部分。此外，请参见 文本处理服务 部分。

字符串方法

字符串实现所有 common 顺序操作，以及下面描述的其他方法。

字符串还支持两种类型的字符串格式，一种提供了很大的灵活性和自定义（请参见 str.format() ， 格式字符串语法 和 自定义字符串格式 ）另一个基于c printf 样式格式，它处理的类型范围较窄，并且稍微难以正确使用，但对于它可以处理的情况，通常更快。 (printf -样式字符串格式 ）

这个 文本处理服务 标准库的部分包含许多其他模块，这些模块提供各种与文本相关的实用程序（包括在 re 模块）。

str.capitalize()

返回字符串的副本，其中第一个字符大写，其余字符小写。

在 3.8 版更改: 第一个字符现在放在标题库中，而不是大写。这意味着像有向图这样的字符只能大写第一个字母，而不能大写整个字符。

str.casefold()

返回一个折叠的字符串副本。折叠的字符串可用于无大小写匹配。

折箱与低折相似，但更具侵略性，因为它旨在消除字符串中的所有大小写区别。例如，德语小写字母 'ß' 等于 "ss" . 因为它已经是小写的了， lower() 什么都不做 'ß' ； casefold() 将其转换为 "ss" .

Unicode标准第3.13节描述了案例折叠算法。

3.3 新版功能.

str.center(width[, fillchar])

返回以长度字符串为中心的值 宽度 . 填充是使用指定的 菲尔查尔 （默认为ASCII空间）。如果 宽度 小于或等于 len(s) .

str.count(sub[, start[, end]])

返回子字符串的不重叠出现次数 sub 在射程内 [start, end] . 可选参数 开始 和 end 被解释为切片符号。

str.encode(encoding='utf-8', errors='strict')

以字节对象的形式返回字符串的编码版本。默认编码为 'utf-8' . errors 可以设置不同的错误处理方案。默认值为 errors 是 'strict' ，表示编码错误导致 UnicodeError . 其他可能的值是 'ignore' ， 'replace' ， 'xmlcharrefreplace' ， 'backslashreplace' 以及通过 codecs.register_error() 见节 错误处理程序 . 有关可能的编码列表，请参见第节 标准编码 .

默认情况下， 错误 不检查参数的最佳性能，但只在第一个编码错误时使用。启用 Python Development Mode ，或使用调试生成来检查 错误 .

在 3.1 版更改: 添加了对关键字参数的支持。

在 3.9 版更改: 这个 错误 现在处于开发模式和调试模式。

str.endswith(suffix[, start[, end]])

返回 True 如果字符串以指定的 后缀 ，否则返回 False . 后缀 也可以是要查找的后缀的元组。任选 开始 ，从该位置开始测试。任选 end 在那个位置停止比较。

str.expandtabs(tabsize=8)

返回一个字符串的副本，根据当前列和给定的选项卡大小，所有选项卡字符都由一个或多个空格替换。制表位发生间隔 表格大小 字符（默认值为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]])

返回字符串中的最低索引，其中子字符串 sub 在切片中找到 s[start:end] . 可选参数 开始 和 end 被解释为切片符号。返回 -1 如果 sub 找不到。

注解

这个 find() 仅当需要知道 sub . 检查是否 sub 是否为子字符串，请使用 in 操作员：

>>> 'Py' in 'Python'
True

str.format(*args, **kwargs)

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

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

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

注解

设置数字格式时 (int ， float ， complex ， decimal.Decimal 和子类）。 n 类型（EX: '{{:n}}'.format(1234) ）函数临时设置 LC_CTYPE 本地化到 LC_NUMERIC 要解码的区域设置 decimal_point 和 thousands_sep 字段 localeconv() 如果它们不是ASCII码或大于1个字节，并且 LC_NUMERIC 区域设置与 LC_CTYPE locale。此临时更改会影响其他线程。

在 3.7 版更改: 当用 n 类型，函数临时设置 LC_CTYPE 本地化到 LC_NUMERIC 某些情况下的区域设置。

str.format_map(mapping)

类似 str.format(**mapping) 除了 mapping 直接使用而不是复制到 dict . 例如，如果 mapping 是dict子类：

>>> class Default(dict):
...     def __missing__(self, key):
...         return key
...
>>> '{name} was born in {country}'.format_map(Default(name='Guido'))
'Guido was born in country'

3.2 新版功能.

str.index(sub[, start[, end]])

类似于 find() 但提高 ValueError 当找不到子字符串时。

str.isalnum()

返回 True 如果字符串中的所有字符都是字母数字并且至少有一个字符， False 否则。角色 c 如果以下返回值之一，则为字母数字 True ： c.isalpha() ， c.isdecimal() ， c.isdigit() 或 c.isnumeric() .

str.isalpha()

返回 True 如果字符串中的所有字符都是字母，并且至少有一个字符， False 否则。字母字符是Unicode字符数据库中定义为“字母”的字符，即具有“Lm”、“Lt”、“Lu”、“Ll”或“Lo”中的“general category”属性的字符。请注意，这与Unicode标准中定义的“字母”属性不同。

str.isascii()

返回 True 如果字符串为空或字符串中的所有字符都是ASCII， False 否则。ASCII字符的代码点在U+0000-U+007F范围内。

3.7 新版功能.

str.isdecimal()

返回 True 如果字符串中的所有字符都是十进制字符，并且至少有一个字符， False 否则。十进制字符是那些可以用来形成以10为基数的数字的字符，例如U+0660，阿拉伯-印度数字零。形式上，十进制字符是Unicode通用类别“Nd”中的字符。

str.isdigit()

返回 True 如果字符串中的所有字符都是数字并且至少有一个字符， False 否则。数字包括十进制字符和需要特殊处理的数字，如兼容上标数字。这包括不能用以形成10进制数字的数字，如喀罗斯提数字。从形式上讲，数字是一个属性值Numeric_Type=digit或Numeric_Type=Decimal的字符。

str.isidentifier()

返回 True 如果字符串是根据语言定义的有效标识符，则 标识符和关键字 .

调用 keyword.iskeyword() 测试字符串 s 是保留标识符，例如 def 和 class .

例子：：

>>> from keyword import iskeyword

>>> 'hello'.isidentifier(), iskeyword('hello')
True, False
>>> 'def'.isidentifier(), iskeyword('def')
True, True

str.islower()

返回 True 如果所有大小写字符 4 在字符串中是小写的，并且至少有一个大小写字符， False 否则。

str.isnumeric()

返回 True 如果字符串中的所有字符都是数字字符，并且至少有一个字符， False 否则。数字字符包括数字字符和所有具有Unicode数值属性的字符，例如U+2155，普通分数五分之一。形式上，数字字符是指属性值numeric_Type=Digit、numeric_Type=Decimal或numeric_Type=numeric的字符。

str.isprintable()

返回 True 如果字符串中的所有字符都可打印或字符串为空， False 否则。不可打印字符是Unicode字符数据库中定义为“其他”或“分隔符”的字符，但被视为可打印的ASCII空格（0x20）除外。（注意，此上下文中的可打印字符是不应在以下情况下转义的字符： repr() 对字符串调用。它与处理写入的字符串无关 sys.stdout 或 sys.stderr ）

str.isspace()

返回 True 如果字符串中只有空白字符且至少有一个字符， False 否则。

一个角色是 空白区 如果在Unicode字符数据库中（请参见 unicodedata )，其一般类别为 Zs （“分隔符，空格”），或其双向类是 WS ， B 或 S .

str.istitle()

返回 True 如果字符串是基于标题的字符串并且至少有一个字符，例如大写字符只能跟在未基于标题的字符后面，小写字符只能跟在大写字符后面。返回 False 否则。

str.isupper()

返回 True 如果所有大小写字符 4 字符串是大写的，至少有一个大小写字符， False 否则。

>>> 'BANANA'.isupper()
True
>>> 'banana'.isupper()
False
>>> 'baNana'.isupper()
False
>>> ' '.isupper()
False

str.join(iterable)

返回一个字符串，该字符串是 可迭代的 . 一 TypeError 如果中有任何非字符串值，则将引发 可迭代的 包括 bytes 物体。元素之间的分隔符是提供此方法的字符串。

str.ljust(width[, fillchar])

返回以长度字符串左对齐的字符串 宽度 . 填充是使用指定的 菲尔查尔 （默认为ASCII空间）。如果 宽度 小于或等于 len(s) .

str.lower()

返回包含所有大小写字符的字符串副本 4 已转换为小写。

Unicode标准第3.13节描述了所用的低换行算法。

str.lstrip([chars])

返回删除了前导字符的字符串副本。这个 字符 参数是指定要删除的字符集的字符串。如果省略或 None , the 字符 参数默认为删除空白。这个 字符 参数不是前缀；相反，它的所有值组合都将被删除：：

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

见 str.removeprefix() 对于将删除单个前缀字符串而不是一组字符的方法。例如：：

>>> 'Arthur: three!'.lstrip('Arthur: ')
'ee!'
>>> 'Arthur: three!'.removeprefix('Arthur: ')
'three!'

static str.maketrans(x[, y[, z]])

此静态方法返回可用于 str.translate() .

如果只有一个参数，则必须是将Unicode序号（整数）或字符（长度为1的字符串）映射到Unicode序号、字符串（任意长度）或 None . 然后，字符键将转换为序数。

如果有两个参数，它们必须是长度相等的字符串，在生成的字典中，x中的每个字符都将映射到y中相同位置的字符。如果有第三个参数，则必须是字符串，其字符将映射到 None 在结果中。

str.partition(sep)

第一次出现时拆分字符串 sep ，并返回一个三元组，其中包含分隔符之前的部分、分隔符本身以及分隔符之后的部分。如果找不到分隔符，则返回一个包含字符串本身的3元组，后跟两个空字符串。

str.removeprefix(prefix, /)

如果字符串以 前缀 字符串，返回 string[len(prefix):] . 否则，返回原始字符串的副本：

>>> 'TestHook'.removeprefix('Test')
'Hook'
>>> 'BaseTestCase'.removeprefix('Test')
'BaseTestCase'

3.9 新版功能.

str.removesuffix(suffix, /)

如果字符串以 后缀 弦和那个 后缀 不为空，返回 string[:-len(suffix)] . 否则，返回原始字符串的副本：

>>> 'MiscTests'.removesuffix('Tests')
'Misc'
>>> 'TmpDirMixin'.removesuffix('Tests')
'TmpDirMixin'

3.9 新版功能.

str.replace(old, new[, count])

返回包含所有子字符串的字符串副本 old 替换为 new . 如果可选参数 计数 只有第一个 计数 出现的内容将被替换。

str.rfind(sub[, start[, end]])

返回字符串中的最高索引，其中子字符串 sub 被发现，这样 sub 包含在 s[start:end] . 可选参数 开始 和 end 被解释为切片符号。返回 -1 失败论。

str.rindex(sub[, start[, end]])

类似于 rfind() 但提高 ValueError 当子字符串 sub 找不到。

str.rjust(width[, fillchar])

返回以长度字符串右对齐的字符串 宽度 . 填充是使用指定的 菲尔查尔 （默认为ASCII空间）。如果 宽度 小于或等于 len(s) .

str.rpartition(sep)

在最后一次出现的位置拆分字符串 sep ，并返回一个三元组，其中包含分隔符之前的部分、分隔符本身以及分隔符之后的部分。如果找不到分隔符，则返回一个包含两个空字符串的3元组，后跟字符串本身。

str.rsplit(sep=None, maxsplit=- 1)

返回字符串中的单词列表，使用 sep 作为分隔符字符串。如果 最大分割 最多是给的 最大分割 分割完成了， 最右边的 那些。如果 sep 未指定或 None ，任何空白字符串都是分隔符。除了从右边分开， rsplit() 表现得像 split() 具体描述如下。

str.rstrip([chars])

返回删除了尾随字符的字符串副本。这个 字符 参数是指定要删除的字符集的字符串。如果省略或 None , the 字符 参数默认为删除空白。这个 字符 参数不是后缀；相反，它的所有值组合都将被删除：：

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

见 str.removesuffix() 对于将删除单个后缀字符串而不是一组字符的方法。例如：：

>>> 'Monty Python'.rstrip(' Python')
'M'
>>> 'Monty Python'.removesuffix(' Python')
'Monty'

str.split(sep=None, maxsplit=- 1)

返回字符串中的单词列表，使用 sep 作为分隔符字符串。如果 最大分割 最多是给的 最大分割 分割完成（因此，列表最多 maxsplit+1 元素）。如果 最大分割 未指定或 -1 ，则对拆分的数目没有限制（所有可能的拆分都是进行的）。

如果 sep 如果给定，则连续分隔符不会组合在一起，并被视为分隔空字符串（例如， '1,,2'.split(',') 返回 ['1', '', '2'] ）这个 sep 参数可以由多个字符组成（例如， '1<>2<>3'.split('<>') 返回 ['1', '2', '3'] ）使用指定的分隔符拆分空字符串返回 [''] .

例如：：

>>> '1,2,3'.split(',')
['1', '2', '3']
>>> '1,2,3'.split(',', maxsplit=1)
['1', '2,3']
>>> '1,2,,3,'.split(',')
['1', '2', '', '3', '']

如果 sep 未指定或 None ，则应用不同的拆分算法：连续的空格将被视为单个分隔符，如果字符串具有前导或尾随空格，则结果在开始或结束时将不包含空字符串。因此，将空字符串或仅由空格组成的字符串拆分为 None 分隔符返回 [] .

例如：：

>>> '1 2 3'.split()
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> '   1   2   3   '.split()
['1', '2', '3']

str.splitlines([keepends])

返回字符串中行的列表，在行边界处中断。换行符不包括在结果列表中，除非 守护者 是给予和真实的。

此方法在以下行边界上拆分。特别是，边界是 universal newlines .

表现	描述
\n	换行
\r	回车
\r\n	回车+换行
\v or \x0b	行制表
\f or \x0c	表单馈送
\x1c	文件分隔符
\x1d	分组分隔符
\x1e	记录分隔符
\x85	下一行（C1控制代码）
\u2028	行分离器
\u2029	段落分隔符

在 3.2 版更改: \v 和 \f 添加到线条边界列表。

例如：：

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=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', '']

str.startswith(prefix[, start[, end]])

返回 True 如果字符串以 前缀 ，否则返回 False . 前缀 也可以是要查找的前缀元组。任选 开始 ，从该位置开始测试字符串。任选 end ，停止在该位置比较字符串。

str.strip([chars])

返回删除了前导和尾随字符的字符串副本。这个 字符 参数是指定要删除的字符集的字符串。如果省略或 None , the 字符 参数默认为删除空白。这个 字符 参数不是前缀或后缀；相反，它的所有值组合都将被删除：：

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

最外层的前导和尾随 字符 参数值从字符串中剥离。在到达不包含在字符集中的字符串之前，将从前端删除字符。 字符 . 尾端也会发生类似的动作。例如：：

>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32'

str.swapcase()

返回字符串的副本，其中大写字符转换为小写，反之亦然。注意，这并不一定是真的 s.swapcase().swapcase() == s .

str.title()

返回字符串的基于标题的版本，其中单词以大写字符开头，其余字符为小写。

例如：：

>>> 'Hello world'.title()
'Hello World'

该算法使用一个简单的独立于语言的单词定义作为连续字母组。这个定义在许多上下文中都有效，但它意味着在收缩和所有物中的撇号形成了单词边界，这可能不是所期望的结果：

>>> "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).capitalize(),
...                   s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."

str.translate(table)

返回字符串的副本，其中每个字符都已通过给定的转换表映射。表必须是通过以下方式实现索引的对象 __getitem__() ，通常是 mapping 或 sequence . 当使用Unicode序号（整数）编制索引时，表对象可以执行以下任何操作：返回Unicode序号或字符串，将字符映射到一个或多个其他字符；返回 None ，从返回字符串中删除字符；或引发 LookupError 异常，将字符映射到自身。

你可以使用 str.maketrans() 以不同格式创建从字符到字符的转换映射。

也见 codecs 模块，用于更灵活的自定义字符映射方法。

str.upper()

返回包含所有大小写字符的字符串副本 4 已转换为大写。注意 s.upper().isupper() 可能是 False 如果 s 包含未装箱字符，或者结果字符的Unicode类别不是“lu”（字母，大写），而是“lt”（字母，标题大小写）。

使用的大写字母算法在Unicode标准第3.13节中进行了描述。

str.zfill(width)

返回用ASCII填充的字符串的副本 '0' digits to make a string of length width. A leading sign prefix ('+'/'-' ）通过插入填充来处理 之后 符号字符，而不是之前。如果 宽度 小于或等于 len(s) .

例如：：

>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'

printf -样式字符串格式

注解

这里描述的格式化操作显示了导致许多常见错误（例如未能正确显示元组和字典）的各种异常。使用新的 formatted string literals , the str.format() 接口，或 template strings 可能有助于避免这些错误。这些备选方案中的每一个都提供了它们自己的权衡，以及简单性、灵活性和/或可扩展性的好处。

字符串对象有一个独特的内置操作： % 运算符（modulo）。这也称为字符串 格式化 或 interpolation 操作员。鉴于 format % values （何处） 格式 是一个字符串） % 转换规范 格式 被零个或多个元素替换 价值观 . 效果类似于使用 sprintf() 用C语言。

如果 格式 需要一个参数， 价值观 可以是单个非元组对象。 5 否则， 价值观 必须是一个具有格式字符串指定的项数的元组，或者是一个映射对象（例如字典）。

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

1. 这个 '%' 字符，标记说明符的开头。

2. 映射键（可选），由带括号的字符序列组成（例如， (somename) ）

3. 转换标志（可选），影响某些转换类型的结果。

4. 最小字段宽度（可选）。如果指定为 '*' （星号），从中的元组的下一个元素读取实际宽度。 价值观 ，要转换的对象在最小字段宽度和可选精度之后。

5. 精度（可选），作为 '.' （点），然后是精度。如果指定为 '*' （星号），实际精度从中的元组的下一个元素读取。 价值观 ，要转换的值在精度之后。

6. 长度修改器（可选）。

7. 转换类型。

如果正确的参数是字典（或其他映射类型），则字符串中的格式 must 在字典中包含一个插入括号的映射键 '%' 性格。映射键从映射中选择要格式化的值。例如：

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

在这种情况下，没有 * 说明符可能以一种格式出现（因为它们需要一个连续的参数列表）。

转换标志字符为：

旗	意义
'#'	值转换将使用“替代形式”（定义见下文）。
'0'	对于数值，转换将被零填充。
'-'	转换后的值进行左调整（覆盖 '0' 如果两者都给出，则转换）。
' '	（空格）在有符号转换产生的正数（或空字符串）之前应该留一个空白。
'+'	符号字符 ('+' 或 '-' ）将在转换之前（覆盖“空格”标志）。

长度修改器 (h ， l 或 L ）可能存在，但会被忽略，因为这对于Python来说是不必要的——例如。 %ld 相同 %d .

转换类型为：

转换	意义	笔记
'd'	有符号整数十进制。
'i'	有符号整数十进制。
'o'	有符号八进制值。	(1)
'u'	过时的类型--它与 'd' .	(6)
'x'	有符号十六进制（小写）。	(2)
'X'	有符号十六进制（大写）。	(2)
'e'	浮点指数格式（小写）。	(3)
'E'	浮点指数格式（大写）。	(3)
'f'	浮点十进制格式。	(3)
'F'	浮点十进制格式。	(3)
'g'	浮点格式。如果指数小于-4或不小于精度，则使用小写指数格式，否则使用十进制格式。	(4)
'G'	浮点格式。如果指数小于-4或不小于精度，则使用大写指数格式，否则使用十进制格式。	(4)
'c'	单字符（接受整数或单字符串）。
'r'	字符串（使用 repr() ）	(5)
's'	字符串（使用 str() ）	(5)
'a'	字符串（使用 ascii() ）	(5)
'%'	未转换任何参数，将导致 '%' 结果中的字符。

笔记：

1. 替代形式导致前导八进制说明符 ('0o' ）在第一个数字之前插入。

2. 替代形式导致前导 '0x' 或 '0X' （取决于 'x' 或 'X' 格式）插入第一个数字之前。

3. 替代形式使结果始终包含小数点，即使后面没有数字。

   精度决定小数点后的位数，默认为6。

4. 替代形式会导致结果始终包含小数点，并且尾随的零不会像原来那样被删除。

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

5. 如果精度是 N ，输出被截断为 N 字符。

6. 见 PEP 237 .

因为python字符串有明确的长度， %s 转换不假定 '\0' 是字符串的结尾。

在 3.1 版更改: %f 绝对值超过1E50的数字转换不再被替换为 %g 转换。

二进制序列类型--- bytes ， bytearray ， memoryview

用于操作二进制数据的核心内置类型是 bytes 和 bytearray . 他们得到了 memoryview 其中使用 buffer protocol 不需要复制就可以访问其他二进制对象的内存。

这个 array 模块支持有效存储基本数据类型，如32位整数和IEEE754双精度浮点值。

字节对象

字节对象是单字节的不可变序列。由于许多主要的二进制协议都基于ASCII文本编码，因此字节对象提供了几种方法，这些方法只有在处理与ASCII兼容的数据时才有效，并且以各种其他方式与字符串对象密切相关。

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

首先，字节文本的语法与字符串文本的语法基本相同，除了 b 添加前缀：

• 单引号： b'still allows embedded "double" quotes'

• 双引号： b"still allows embedded 'single' quotes" .

• 三重引文： b'''3 single quotes''' ， b"""3 double quotes"""

字节文本中只允许使用ASCII字符（不考虑声明的源代码编码）。超过127的任何二进制值都必须使用适当的转义序列输入字节文本。

与字符串文本一样，字节文本也可以使用 r 用于禁用转义序列处理的前缀。见 字符串与字节的字面值 有关各种形式的字节文本（包括支持的转义序列）的详细信息。

虽然字节文本和表示是基于ASCII文本的，但字节对象的行为实际上类似于不可变的整数序列，序列中的每个值都受到限制，因此 0 <= x < 256 （违反此限制的尝试将触发 ValueError ）这样做是为了强调，虽然许多二进制格式都包含基于ASCII的元素，并且可以用一些面向文本的算法有效地操作，但通常情况下，任意二进制数据并非如此（盲目地将文本处理算法应用于与ASCII不兼容的二进制数据格式通常会导致数据C敲击）

除了文字形式之外，还可以通过多种其他方式创建bytes对象：

• 指定长度的零填充字节对象： bytes(10)

• 从整数的不可数： bytes(range(20))

• 通过缓冲协议复制现有的二进制数据： bytes(obj)

也看到 bytes 内置的。

由于两个十六进制数字精确对应一个字节，十六进制数字是描述二进制数据的常用格式。相应地，bytes类型有一个额外的类方法来读取该格式的数据：

classmethod fromhex(string)

这个 bytes 类方法返回一个字节对象，对给定的字符串对象进行解码。字符串必须每个字节包含两个十六进制数字，忽略ASCII空白。

>>> bytes.fromhex('2Ef0 F1f2  ')
b'.\xf0\xf1\xf2'

在 3.7 版更改: bytes.fromhex() 现在跳过字符串中的所有ASCII空白，而不仅仅是空格。

存在一个反向转换函数，用于将字节对象转换为十六进制表示形式。

hex([sep[, bytes_per_sep]])

返回一个字符串对象，该对象包含实例中每个字节的两个十六进制数字。

>>> b'\xf0\xf1\xf2'.hex()
'f0f1f2'

如果要使十六进制字符串更易于读取，可以指定单个字符分隔符 sep 要包含在输出中的参数。默认情况下，在每个字节之间。第二个选项 bytes_per_sep 参数控制间距。正值从右侧计算分隔符位置，负值从左侧计算。

>>> value = b'\xf0\xf1\xf2'
>>> value.hex('-')
'f0-f1-f2'
>>> value.hex('_', 2)
'f0_f1f2'
>>> b'UUDDLRLRAB'.hex(' ', -4)
'55554444 4c524c52 4142'

3.5 新版功能.

在 3.8 版更改: bytes.hex() 现在支持可选 sep 和 bytes_per_sep 在十六进制输出的字节之间插入分隔符的参数。

因为bytes对象是bytes对象的整数序列（类似于元组）。 b ， b[0] 将是一个整数，而 b[0:1] 将是长度为1的字节对象。（这与文本字符串不同，在文本字符串中，索引和切片都将生成长度为1的字符串）

字节对象的表示使用文本格式 (b'...' ）因为它通常比例如 bytes([46, 46, 46]) . 始终可以使用 list(b) .

注解

对于python 2.x用户：在python 2.x系列中，允许在8位字符串（2.x提供的最接近内置二进制数据类型的内容）和unicode字符串之间进行各种隐式转换。这是一个向后兼容的解决方案，考虑到Python最初只支持8位文本，Unicode文本是后来添加的。在python 3.x中，那些隐式转换已经不存在了——8位二进制数据和Unicode文本之间的转换必须是显式的，字节和字符串对象之间的比较总是不相等的。

Bytearray对象

bytearray 对象是与 bytes 物体。

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

Bytearray对象没有专用的文本语法，而是始终通过调用构造函数来创建它们：

• 创建空实例： bytearray()

• 创建具有给定长度的零填充实例： bytearray(10)

• 从整数的不可数： bytearray(range(20))

• 通过缓冲协议复制现有的二进制数据： bytearray(b'Hi!')

由于bytearray对象是可变的，因此它们支持 mutable 除中描述的公用字节和字节数组操作之外的序列操作 字节和字节数组操作 .

也看到 bytearray 内置的。

由于两个十六进制数字精确对应一个字节，十六进制数字是描述二进制数据的常用格式。因此，bytearray类型有一个额外的类方法来读取该格式的数据：

classmethod fromhex(string)

这个 bytearray 类方法返回bytearray对象，对给定的字符串对象进行解码。字符串必须每个字节包含两个十六进制数字，忽略ASCII空白。

>>> bytearray.fromhex('2Ef0 F1f2  ')
bytearray(b'.\xf0\xf1\xf2')

在 3.7 版更改: bytearray.fromhex() 现在跳过字符串中的所有ASCII空白，而不仅仅是空格。

存在一个反向转换函数，用于将bytearray对象转换为其十六进制表示形式。

hex([sep[, bytes_per_sep]])

返回一个字符串对象，该对象包含实例中每个字节的两个十六进制数字。

>>> bytearray(b'\xf0\xf1\xf2').hex()
'f0f1f2'

3.5 新版功能.

在 3.8 版更改: 类似 bytes.hex() ， bytearray.hex() 现在支持可选 sep 和 bytes_per_sep 在十六进制输出的字节之间插入分隔符的参数。

因为bytearray对象是一个bytearray对象的整数序列（类似于列表）。 b ， b[0] 将是一个整数，而 b[0:1] 将是长度为1的bytearray对象。（这与文本字符串不同，在文本字符串中，索引和切片都将生成长度为1的字符串）

bytearray对象的表示使用bytes文本格式 (bytearray(b'...') ）因为它通常比例如 bytearray([46, 46, 46]) . 始终可以使用将Bytearray对象转换为整数列表 list(b) .

字节和字节数组操作

bytes和bytearray对象都支持 common 顺序操作。它们不仅与同一类型的操作数进行互操作，而且与任何类型的操作数进行互操作。 bytes-like object . 由于这种灵活性，它们可以在操作中自由混合，而不会导致错误。但是，结果的返回类型可能取决于操作数的顺序。

注解

字节和字节数组对象上的方法不接受字符串作为参数，就像字符串上的方法不接受字节作为参数一样。例如，你必须写：

a = "abc"
b = a.replace("a", "f")

和：

a = b"abc"
b = a.replace(b"a", b"f")

某些字节和字节数组操作假定使用与ASCII兼容的二进制格式，因此在处理任意二进制数据时应避免使用。这些限制包括在下面。

注解

使用这些基于ASCII的操作来操作没有以基于ASCII的格式存储的二进制数据可能会导致数据损坏。

字节和字节数组对象上的以下方法可用于任意二进制数据。

bytes.count(sub[, start[, end]])

bytearray.count(sub[, start[, end]])

返回子序列不重叠的出现次数 sub 在射程内 [start, end] . 可选参数 开始 和 end 被解释为切片符号。

搜索的子序列可以是 bytes-like object 或0到255之间的整数。

在 3.3 版更改: 还接受0到255范围内的整数作为子序列。

bytes.removeprefix(prefix, /)

bytearray.removeprefix(prefix, /)

如果二进制数据以 前缀 字符串，返回 bytes[len(prefix):] . 否则，返回原始二进制数据的副本：

>>> b'TestHook'.removeprefix(b'Test')
b'Hook'
>>> b'BaseTestCase'.removeprefix(b'Test')
b'BaseTestCase'

这个 前缀 可能是任何 bytes-like object .

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

3.9 新版功能.

bytes.removesuffix(suffix, /)

bytearray.removesuffix(suffix, /)

如果二进制数据以 后缀 弦和那个 后缀 不为空，返回 bytes[:-len(suffix)] . 否则，返回原始二进制数据的副本：

>>> b'MiscTests'.removesuffix(b'Tests')
b'Misc'
>>> b'TmpDirMixin'.removesuffix(b'Tests')
b'TmpDirMixin'

这个 后缀 可能是任何 bytes-like object .

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

3.9 新版功能.

bytes.decode(encoding='utf-8', errors='strict')

bytearray.decode(encoding='utf-8', errors='strict')

返回从给定字节解码的字符串。默认编码为 'utf-8' . errors 可以设置不同的错误处理方案。默认值为 errors 是 'strict' ，表示编码错误导致 UnicodeError . 其他可能的值是 'ignore' ， 'replace' 以及通过 codecs.register_error() 见节 错误处理程序 . 有关可能的编码列表，请参见第节 标准编码 .

默认情况下， 错误 不检查参数是否具有最佳性能，但只在第一个解码错误时使用。启用 Python Development Mode ，或使用调试生成来检查 错误 .

注解

路过 encoding 参数 str 允许解码任何 bytes-like object 直接，无需生成临时字节或bytearray对象。

在 3.1 版更改: 添加了对关键字参数的支持。

在 3.9 版更改: 这个 错误 现在处于开发模式和调试模式。

bytes.endswith(suffix[, start[, end]])

bytearray.endswith(suffix[, start[, end]])

返回 True 如果二进制数据以指定的 后缀 ，否则返回 False . 后缀 也可以是要查找的后缀的元组。任选 开始 ，从该位置开始测试。任选 end 在那个位置停止比较。

要搜索的后缀可以是 bytes-like object .

bytes.find(sub[, start[, end]])

bytearray.find(sub[, start[, end]])

返回数据中的最低索引，其中 sub 被发现，这样 sub 包含在切片中 s[start:end] . 可选参数 开始 和 end 被解释为切片符号。返回 -1 如果 sub 找不到。

搜索的子序列可以是 bytes-like object 或0到255之间的整数。

注解

这个 find() 仅当需要知道 sub . 检查是否 sub 是否为子字符串，请使用 in 操作员：

>>> b'Py' in b'Python'
True

在 3.3 版更改: 还接受0到255范围内的整数作为子序列。

bytes.index(sub[, start[, end]])

bytearray.index(sub[, start[, end]])

类似于 find() 但提高 ValueError 当没有找到子序列时。

搜索的子序列可以是 bytes-like object 或0到255之间的整数。

在 3.3 版更改: 还接受0到255范围内的整数作为子序列。

bytes.join(iterable)

bytearray.join(iterable)

返回字节或字节数组对象，该对象是中二进制数据序列的串联 可迭代的 . 一 TypeError 如果在 可迭代的 那不是 bytes-like objects 包括 str 物体。元素之间的分隔符是提供此方法的bytes或bytearray对象的内容。

static bytes.maketrans(from, to)

static bytearray.maketrans(from, to)

此静态方法返回可用于 bytes.translate() 它将映射每个字符 from 在角色的同一位置 to ； from 和 to 都必须 bytes-like objects 长度相同。

3.1 新版功能.

bytes.partition(sep)

bytearray.partition(sep)

在第一次出现 sep ，并返回一个三元组，其中包含分隔符之前的部分、分隔符本身或其字节数组副本，以及分隔符之后的部分。如果找不到分隔符，则返回一个包含原始序列副本的3元组，后跟两个空字节或bytearray对象。

要搜索的分隔符可以是 bytes-like object .

bytes.replace(old, new[, count])

bytearray.replace(old, new[, count])

返回序列的副本以及所有出现的子序列 old 替换为 new . 如果可选参数 计数 只有第一个 计数 出现的内容将被替换。

搜索和替换的子序列可以是 bytes-like object .

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

bytes.rfind(sub[, start[, end]])

bytearray.rfind(sub[, start[, end]])

返回序列中的最高索引，其中 sub 被发现，这样 sub 包含在 s[start:end] . 可选参数 开始 和 end 被解释为切片符号。返回 -1 失败论。

搜索的子序列可以是 bytes-like object 或0到255之间的整数。

在 3.3 版更改: 还接受0到255范围内的整数作为子序列。

bytes.rindex(sub[, start[, end]])

bytearray.rindex(sub[, start[, end]])

类似于 rfind() 但提高 ValueError 当子序列 sub 找不到。

搜索的子序列可以是 bytes-like object 或0到255之间的整数。

在 3.3 版更改: 还接受0到255范围内的整数作为子序列。

bytes.rpartition(sep)

bytearray.rpartition(sep)

在最后一次出现的 sep

要搜索的分隔符可以是 bytes-like object .

bytes.startswith(prefix[, start[, end]])

bytearray.startswith(prefix[, start[, end]])

返回 True 如果二进制数据以指定的 前缀 ，否则返回 False . 前缀 也可以是要查找的前缀元组。任选 开始 ，从该位置开始测试。任选 end 在那个位置停止比较。

要搜索的前缀可以是 bytes-like object .

bytes.translate(table, /, delete=b'')

bytearray.translate(table, /, delete=b'')

返回字节或bytearray对象的副本，其中所有字节都出现在可选参数中 删除 被删除，剩余的字节已通过给定的转换表映射，该表必须是长度为256的字节对象。

你可以使用 bytes.maketrans() 方法创建翻译表。

设置 表格 参数 None 对于只删除字符的翻译：

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

在 3.6 版更改: 删除 现在支持作为关键字参数。

字节和字节数组对象上的以下方法具有默认行为，这些默认行为假定使用与ASCII兼容的二进制格式，但通过传递适当的参数，仍然可以与任意二进制数据一起使用。请注意，本节中的所有bytearray方法都 not 就地操作，然后生成新对象。

bytes.center(width[, fillbyte])

bytearray.center(width[, fillbyte])

返回按长度顺序居中的对象的副本 宽度 . 填充是使用指定的 填充字节 （默认为ASCII空间）。为了 bytes 对象，如果 宽度 小于或等于 len(s) .

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

bytes.ljust(width[, fillbyte])

bytearray.ljust(width[, fillbyte])

返回按长度顺序左对齐的对象副本 宽度 . 填充是使用指定的 填充字节 （默认为ASCII空间）。为了 bytes 对象，如果 宽度 小于或等于 len(s) .

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

bytes.lstrip([chars])

bytearray.lstrip([chars])

返回删除指定前导字节的序列的副本。这个 字符 参数是指定要删除的字节值集的二进制序列-名称指的是此方法通常与ASCII字符一起使用的事实。如果省略或 None , the 字符 参数默认为删除ASCII空白。这个 字符 参数不是前缀；相反，它的所有值组合都将被删除：：

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

要删除的字节值的二进制序列可以是 bytes-like object . 见 removeprefix() 对于将删除单个前缀字符串而不是一组字符的方法。例如：：

>>> b'Arthur: three!'.lstrip(b'Arthur: ')
b'ee!'
>>> b'Arthur: three!'.removeprefix(b'Arthur: ')
b'three!'

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

bytes.rjust(width[, fillbyte])

bytearray.rjust(width[, fillbyte])

返回按长度顺序右对齐的对象副本 宽度 . 填充是使用指定的 填充字节 （默认为ASCII空间）。为了 bytes 对象，如果 宽度 小于或等于 len(s) .

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

bytes.rsplit(sep=None, maxsplit=- 1)

bytearray.rsplit(sep=None, maxsplit=- 1)

使用将二进制序列拆分为相同类型的子序列 sep 作为分隔符字符串。如果 最大分割 最多是给的 最大分割 分割完成了， 最右边的 那些。如果 sep 未指定或 None ，仅由ASCII空白组成的任何子序列都是分隔符。除了从右边分开， rsplit() 表现得像 split() 具体描述如下。

bytes.rstrip([chars])

bytearray.rstrip([chars])

返回删除指定尾随字节的序列的副本。这个 字符 参数是指定要删除的字节值集的二进制序列-名称指的是此方法通常与ASCII字符一起使用的事实。如果省略或 None , the 字符 参数默认为删除ASCII空白。这个 字符 参数不是后缀；相反，它的所有值组合都将被删除：：

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

要删除的字节值的二进制序列可以是 bytes-like object . 见 removesuffix() 对于将删除单个后缀字符串而不是一组字符的方法。例如：：

>>> b'Monty Python'.rstrip(b' Python')
b'M'
>>> b'Monty Python'.removesuffix(b' Python')
b'Monty'

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

bytes.split(sep=None, maxsplit=- 1)

bytearray.split(sep=None, maxsplit=- 1)

使用将二进制序列拆分为相同类型的子序列 sep 作为分隔符字符串。如果 最大分割 最多是给定的非负的 最大分割 分割完成（因此，列表最多 maxsplit+1 元素）。如果 最大分割 未指定或 -1 ，则对拆分的数目没有限制（所有可能的拆分都是进行的）。

如果 sep 如果给定，则连续分隔符不会组合在一起，并被视为分隔空子序列（例如， b'1,,2'.split(b',') 返回 [b'1', b'', b'2'] ）这个 sep 参数可以由多字节序列组成（例如， b'1<>2<>3'.split(b'<>') 返回 [b'1', b'2', b'3'] ）使用指定的分隔符拆分空序列返回 [b''] 或 [bytearray(b'')] 取决于要拆分的对象的类型。这个 sep 参数可以是任何 bytes-like object .

例如：：

>>> b'1,2,3'.split(b',')
[b'1', b'2', b'3']
>>> b'1,2,3'.split(b',', maxsplit=1)
[b'1', b'2,3']
>>> b'1,2,,3,'.split(b',')
[b'1', b'2', b'', b'3', b'']

如果 sep 未指定或 None ，则采用不同的拆分算法：连续运行的ASCII空格被视为单个分隔符，如果序列具有前导或尾随空格，则结果在开始或结束时将不包含空字符串。因此，在没有指定分隔符的情况下拆分空序列或仅由ASCII空白组成的序列将返回 [] .

例如：：

>>> b'1 2 3'.split()
[b'1', b'2', b'3']
>>> b'1 2 3'.split(maxsplit=1)
[b'1', b'2 3']
>>> b'   1   2   3   '.split()
[b'1', b'2', b'3']

bytes.strip([chars])

bytearray.strip([chars])

返回序列的副本，删除指定的前导和尾随字节。这个 字符 参数是指定要删除的字节值集的二进制序列-名称指的是此方法通常与ASCII字符一起使用的事实。如果省略或 None , the 字符 参数默认为删除ASCII空白。这个 字符 参数不是前缀或后缀；相反，它的所有值组合都将被删除：：

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

要删除的字节值的二进制序列可以是 bytes-like object .

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

字节和字节数组对象上的以下方法假定使用与ASCII兼容的二进制格式，不应应用于任意二进制数据。请注意，本节中的所有bytearray方法都 not 就地操作，然后生成新对象。

bytes.capitalize()

bytearray.capitalize()

返回序列的副本，每个字节解释为一个ASCII字符，第一个字节大写，其余字节小写。非ASCII字节值通过未更改的方式传递。

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

bytes.expandtabs(tabsize=8)

bytearray.expandtabs(tabsize=8)

根据当前列和给定的制表符大小，返回一个序列的副本，其中所有ASCII制表符替换为一个或多个ASCII空格。制表位发生间隔 表格大小 字节（默认值为8，在列0、8、16等处给出制表位）。要展开序列，当前列设置为零，并逐字节检查序列。如果字节是ASCII制表符 (b'\t' ）将在结果中插入一个或多个空格字符，直到当前列等于下一个选项卡位置。（不复制制表符本身。）如果当前字节是ASCII换行符 (b'\n' ）或回车 (b'\r' ，它被复制，当前列重置为零。复制的任何其他字节值不变，并且当前列的增量为1，而不管打印时如何表示字节值：：

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

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

bytes.isalnum()

bytearray.isalnum()

返回 True 如果序列中的所有字节都是字母ASCII字符或ASCII十进制数字，并且序列不是空的， False 否则。字母ASCII字符是序列中的字节值 b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' . ASCII十进制数字是序列中的字节值 b'0123456789' .

例如：：

>>> b'ABCabc1'.isalnum()
True
>>> b'ABC abc1'.isalnum()
False

bytes.isalpha()

bytearray.isalpha()

返回 True 如果序列中的所有字节都是字母ASCII字符，并且序列不是空的， False 否则。字母ASCII字符是序列中的字节值 b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' .

例如：：

>>> b'ABCabc'.isalpha()
True
>>> b'ABCabc1'.isalpha()
False

bytes.isascii()

bytearray.isascii()

返回 True 如果序列为空或序列中的所有字节都是ASCII， False 否则。ASCII字节在0-0x7F范围内。

3.7 新版功能.

bytes.isdigit()

bytearray.isdigit()

返回 True 如果序列中的所有字节都是ASCII十进制数字，并且序列不是空的， False 否则。ASCII十进制数字是序列中的字节值 b'0123456789' .

例如：：

>>> b'1234'.isdigit()
True
>>> b'1.23'.isdigit()
False

bytes.islower()

bytearray.islower()

返回 True 如果序列中至少有一个小写的ASCII字符，而没有大写的ASCII字符， False 否则。

例如：：

>>> b'hello world'.islower()
True
>>> b'Hello world'.islower()
False

小写ASCII字符是序列中的字节值 b'abcdefghijklmnopqrstuvwxyz' . 大写的ASCII字符是序列中的字节值 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' .

bytes.isspace()

bytearray.isspace()

返回 True 如果序列中的所有字节都是ASCII空白并且序列不是空的， False 否则。ASCII空白字符是序列中的字节值 b' \t\n\r\x0b\f' （空格、制表符、换行符、回车符、垂直制表符、换页符）。

bytes.istitle()

bytearray.istitle()

返回 True 如果序列是ASCII titlecase并且序列不是空的， False 否则。见 bytes.title() 有关“标题栏”定义的更多详细信息。

例如：：

>>> b'Hello World'.istitle()
True
>>> b'Hello world'.istitle()
False

bytes.isupper()

bytearray.isupper()

返回 True 如果序列中至少有一个大写字母ASCII字符，而没有小写ASCII字符， False 否则。

例如：：

>>> b'HELLO WORLD'.isupper()
True
>>> b'Hello world'.isupper()
False

小写ASCII字符是序列中的字节值 b'abcdefghijklmnopqrstuvwxyz' . 大写的ASCII字符是序列中的字节值 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' .

bytes.lower()

bytearray.lower()

返回序列的副本，将所有大写的ASCII字符转换为相应的小写对应字符。

例如：：

>>> b'Hello World'.lower()
b'hello world'

小写ASCII字符是序列中的字节值 b'abcdefghijklmnopqrstuvwxyz' . 大写的ASCII字符是序列中的字节值 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' .

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

bytes.splitlines(keepends=False)

bytearray.splitlines(keepends=False)

返回二进制序列中的行列表，在ASCII行边界处中断。此方法使用 universal newlines 接近分割线。换行符不包括在结果列表中，除非 守护者 是给予和真实的。

例如：：

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

不像 split() 当分隔符字符串 sep 如果给定，则此方法返回空字符串的空列表，并且终端换行不会导致额外的行：

>>> b"".split(b'\n'), b"Two lines\n".split(b'\n')
([b''], [b'Two lines', b''])
>>> b"".splitlines(), b"One line\n".splitlines()
([], [b'One line'])

bytes.swapcase()

bytearray.swapcase()

返回序列的副本，将所有小写的ASCII字符转换为相应的大写对应字符，反之亦然。

例如：：

>>> b'Hello World'.swapcase()
b'hELLO wORLD'

小写ASCII字符是序列中的字节值 b'abcdefghijklmnopqrstuvwxyz' . 大写的ASCII字符是序列中的字节值 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' .

不像 str.swapcase() 总是这样的 bin.swapcase().swapcase() == bin 对于二进制版本。大小写转换在ASCII中是对称的，即使对于任意Unicode代码点来说这通常不是正确的。

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

bytes.title()

bytearray.title()

返回二进制序列的基于标题的版本，其中单词以大写ASCII字符开头，其余字符为小写。未经修改的字节值保持不变。

例如：：

>>> b'Hello world'.title()
b'Hello World'

小写ASCII字符是序列中的字节值 b'abcdefghijklmnopqrstuvwxyz' . 大写的ASCII字符是序列中的字节值 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' . 所有其他的字节值都是未经编码的。

该算法使用一个简单的独立于语言的单词定义作为连续字母组。这个定义在许多上下文中都有效，但它意味着在收缩和所有物中的撇号形成了单词边界，这可能不是所期望的结果：

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

可以使用正则表达式构造撇号的解决方案：：

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

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

bytes.upper()

bytearray.upper()

返回序列的副本，将所有小写ASCII字符转换为相应的大写对应字符。

例如：：

>>> b'Hello World'.upper()
b'HELLO WORLD'

小写ASCII字符是序列中的字节值 b'abcdefghijklmnopqrstuvwxyz' . 大写的ASCII字符是序列中的字节值 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' .

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

bytes.zfill(width)

bytearray.zfill(width)

返回用ASCII填充的序列的副本 b'0' 数字组成一个长度序列 宽度 . 前导符号前缀 (b'+' / b'-' ）通过插入填充来处理 之后 符号字符，而不是之前。为了 bytes 对象，如果 宽度 小于或等于 len(seq) .

例如：：

>>> b"42".zfill(5)
b'00042'
>>> b"-42".zfill(5)
b'-0042'

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

printf -样式字节格式

注解

这里描述的格式化操作显示了导致许多常见错误（例如未能正确显示元组和字典）的各种异常。如果要打印的值可能是元组或字典，请将其封装为元组。

字节对象 (bytes /`` bytearray``）有一个独特的内置操作： % 运算符（modulo）。这也称为字节 格式化 或 interpolation 操作员。鉴于 format % values （何处） 格式 是字节对象）。 % 转换规范 格式 被零个或多个元素替换 价值观 . 效果类似于使用 sprintf() 用C语言。

如果 格式 需要一个参数， 价值观 可以是单个非元组对象。 5 否则， 价值观 必须是一个tuple，其值与format bytes对象指定的项数完全相同，或者是一个映射对象（例如，字典）。

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

1. 这个 '%' 字符，标记说明符的开头。

2. 映射键（可选），由带括号的字符序列组成（例如， (somename) ）

3. 转换标志（可选），影响某些转换类型的结果。

4. 最小字段宽度（可选）。如果指定为 '*' （星号），从中的元组的下一个元素读取实际宽度。 价值观 ，要转换的对象在最小字段宽度和可选精度之后。

5. 精度（可选），作为 '.' （点），然后是精度。如果指定为 '*' （星号），实际精度从中的元组的下一个元素读取。 价值观 ，要转换的值在精度之后。

6. 长度修改器（可选）。

7. 转换类型。

当右参数是字典（或其他映射类型）时，则字节对象中的格式 must 在字典中包含一个插入括号的映射键 '%' 性格。映射键从映射中选择要格式化的值。例如：

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

在这种情况下，没有 * 说明符可能以一种格式出现（因为它们需要一个连续的参数列表）。

转换标志字符为：

旗	意义
'#'	值转换将使用“替代形式”（定义见下文）。
'0'	对于数值，转换将被零填充。
'-'	转换后的值进行左调整（覆盖 '0' 如果两者都给出，则转换）。
' '	（空格）在有符号转换产生的正数（或空字符串）之前应该留一个空白。
'+'	符号字符 ('+' 或 '-' ）将在转换之前（覆盖“空格”标志）。

长度修改器 (h ， l 或 L ）可能存在，但会被忽略，因为这对于Python来说是不必要的——例如。 %ld 相同 %d .

转换类型为：

转换	意义	笔记
'd'	有符号整数十进制。
'i'	有符号整数十进制。
'o'	有符号八进制值。	(1)
'u'	过时的类型--它与 'd' .	(8)
'x'	有符号十六进制（小写）。	(2)
'X'	有符号十六进制（大写）。	(2)
'e'	浮点指数格式（小写）。	(3)
'E'	浮点指数格式（大写）。	(3)
'f'	浮点十进制格式。	(3)
'F'	浮点十进制格式。	(3)
'g'	浮点格式。如果指数小于-4或不小于精度，则使用小写指数格式，否则使用十进制格式。	(4)
'G'	浮点格式。如果指数小于-4或不小于精度，则使用大写指数格式，否则使用十进制格式。	(4)
'c'	单字节（接受整数或单字节对象）。
'b'	字节（跟随 buffer protocol 或有 __bytes__() ）	(5)
's'	's' 是一个别名 'b' 并且只能用于python2/3代码库。	(6)
'a'	字节（使用 repr(obj).encode('ascii','backslashreplace) ）	(5)
'r'	'r' 是一个别名 'a' 并且只能用于python2/3代码库。	(7)
'%'	未转换任何参数，将导致 '%' 结果中的字符。

笔记：

1. 替代形式导致前导八进制说明符 ('0o' ）在第一个数字之前插入。

2. 替代形式导致前导 '0x' 或 '0X' （取决于 'x' 或 'X' 格式）插入第一个数字之前。

3. 替代形式使结果始终包含小数点，即使后面没有数字。

   精度决定小数点后的位数，默认为6。

4. 替代形式会导致结果始终包含小数点，并且尾随的零不会像原来那样被删除。

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

5. 如果精度是 N ，输出被截断为 N 字符。

6. b'%s' 已弃用，但在3.x系列中不会删除。

7. b'%r' 已弃用，但在3.x系列中不会删除。

8. 见 PEP 237 .

注解

这个方法的bytearray版本 not 就地操作-它总是生成一个新对象，即使没有进行任何更改。

参见

PEP 461 -正在将%格式添加到字节和字节数组中

3.5 新版功能.

内存视图

memoryview 对象允许python代码访问支持 buffer protocol 不复制。

class memoryview(obj)

创建一个 memoryview 参考文献 obj . obj 必须支持缓冲区协议。支持缓冲区协议的内置对象包括 bytes 和 bytearray .

A memoryview 有一个概念 要素 ，它是由原始对象处理的原子内存单元 obj . 对于许多简单类型，例如 bytes 和 bytearray ，元素是单个字节，但其他类型如 array.array 可能有更大的元素。

len(view) 等于 tolist .如果 view.ndim = 0 ，长度为1。如果 view.ndim = 1 ，长度等于视图中的元素数。对于更高的维度，长度等于视图的嵌套列表表示的长度。这个 itemsize 属性将给出单个元素中的字节数。

A memoryview 支持切片和索引以公开其数据。一维切片将导致子视图：

>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
>>> v[1:4]
<memory at 0x7f3ddc9f4350>
>>> bytes(v[1:4])
b'bce'

如果 format 是中的本机格式说明符之一 struct 模块，也支持使用整数或整数元组进行索引，并返回单个 要素 类型正确。一维内存视图可以用一个整数或一个整数元组进行索引。多维内存视图可以用精确的元组索引 ndim 整数在哪里 ndim 是维度数。零维内存视图可以用空元组进行索引。

以下是非字节格式的示例：

>>> import array
>>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])
>>> m = memoryview(a)
>>> m[0]
-11111111
>>> m[-1]
44444444
>>> m[::2].tolist()
[-11111111, -33333333]

如果基础对象是可写的，则memoryView支持一维切片分配。不允许调整大小：：

>>> data = bytearray(b'abcefg')
>>> v = memoryview(data)
>>> v.readonly
False
>>> v[0] = ord(b'z')
>>> data
bytearray(b'zbcefg')
>>> v[1:4] = b'123'
>>> data
bytearray(b'z123fg')
>>> v[2:3] = b'spam'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: memoryview assignment: lvalue and rvalue have different structures
>>> v[2:6] = b'spam'
>>> data
bytearray(b'z1spam')

格式为“b”、“b”或“c”的可散列（只读）类型的一维内存视图也可以散列。hash定义为 hash(m) == hash(m.tobytes()) ：：

>>> v = memoryview(b'abcefg')
>>> hash(v) == hash(b'abcefg')
True
>>> hash(v[2:4]) == hash(b'ce')
True
>>> hash(v[::-2]) == hash(b'abcefg'[::-2])
True

在 3.3 版更改: 现在可以切片一维记忆视图。格式为“b”、“b”或“c”的一维内存视图现在可以散列。

在 3.4 版更改: MemoryView现在自动注册为 collections.abc.Sequence

在 3.5 版更改: 现在可以用整数元组为memoryview建立索引。

memoryview 有几种方法：

__eq__(exporter)

记忆视图和 PEP 3118 如果导出器的形状是等效的，并且当操作数各自的格式代码被解释为 struct 语法。

对于 struct 当前支持的格式字符串 tolist() ， v 和 w 是否相等 v.tolist() == w.tolist() ：：

>>> import array
>>> a = array.array('I', [1, 2, 3, 4, 5])
>>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])
>>> c = array.array('b', [5, 3, 1])
>>> x = memoryview(a)
>>> y = memoryview(b)
>>> x == a == y == b
True
>>> x.tolist() == a.tolist() == y.tolist() == b.tolist()
True
>>> z = y[::-2]
>>> z == c
True
>>> z.tolist() == c.tolist()
True

如果 struct 模块，则对象将始终比较为不相等（即使格式字符串和缓冲区内容相同）：：

>>> from ctypes import BigEndianStructure, c_long
>>> class BEPoint(BigEndianStructure):
...     _fields_ = [("x", c_long), ("y", c_long)]
...
>>> point = BEPoint(100, 200)
>>> a = memoryview(point)
>>> b = memoryview(point)
>>> a == point
False
>>> a == b
False

注意，和浮点数一样， v is w 做 not 意味着 v == w 对于MemoryView对象。

在 3.3 版更改: 以前的版本比较了原始内存，忽略了项格式和逻辑数组结构。

tobytes(order=None)

以字节串的形式返回缓冲区中的数据。这相当于调用 bytes memoryView上的构造函数。：：

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

对于非连续数组，结果等于将所有元素转换为字节的扁平列表表示形式。 tobytes() 支持所有格式字符串，包括不在 struct 模块语法。

3.8 新版功能: 秩序 可以是'C'、'F'、'A'。什么时候？ 秩序 为“c”或“f”，原始数组的数据转换为C或Fortran顺序。对于连续视图，“a”返回物理内存的精确副本。特别是，在内存中保留了FORTRAN顺序。对于非连续视图，首先将数据转换为C。 order=None 是一样的 order='C' .

hex([sep[, bytes_per_sep]])

返回一个字符串对象，该对象包含缓冲区中每个字节的两个十六进制数字。：：

>>> m = memoryview(b"abc")
>>> m.hex()
'616263'

3.5 新版功能.

在 3.8 版更改: 类似 bytes.hex() ， memoryview.hex() 现在支持可选 sep 和 bytes_per_sep 在十六进制输出的字节之间插入分隔符的参数。

tolist()

以元素列表的形式返回缓冲区中的数据。：：

>>> memoryview(b'abc').tolist()
[97, 98, 99]
>>> import array
>>> a = array.array('d', [1.1, 2.2, 3.3])
>>> m = memoryview(a)
>>> m.tolist()
[1.1, 2.2, 3.3]

在 3.3 版更改: tolist() 现在支持所有单字符本机格式 struct 模块语法以及多维表示。

toreadonly()

返回memoryView对象的只读版本。原始的memoryView对象不变。：：

>>> m = memoryview(bytearray(b'abc'))
>>> mm = m.toreadonly()
>>> mm.tolist()
[89, 98, 99]
>>> mm[0] = 42
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot modify read-only memory
>>> m[0] = 43
>>> mm.tolist()
[43, 98, 99]

3.8 新版功能.

release()

释放由memoryView对象公开的基础缓冲区。许多对象在其上保留视图时会采取特殊操作（例如， bytearray 会暂时禁止调整大小）；因此，调用release（）可以很方便地尽快删除这些限制（并释放任何悬空资源）。

调用此方法后，对视图的任何进一步操作都将引发 ValueError （除外） release() 自身，可多次调用）：：

>>> m = memoryview(b'abc')
>>> m.release()
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object

上下文管理协议可以用于类似的效果，使用 with 声明：

>>> with memoryview(b'abc') as m:
...     m[0]
...
97
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object

3.2 新版功能.

cast(format[, shape])

将MemoryView强制转换为新的格式或形状。 形状 默认为 [byte_length//new_itemsize] 这意味着结果视图将是一维的。返回值是一个新的memoryView，但不复制缓冲区本身。支持的强制转换为1d->c -contiguous 和c-连续->1d。

目标格式仅限于中的单个元素本机格式 struct 语法。其中一种格式必须是字节格式（“b”、“b”或“c”）。结果的字节长度必须与原始长度相同。

将1d/长转换为1d/无符号字节：：

>>> import array
>>> a = array.array('l', [1,2,3])
>>> x = memoryview(a)
>>> x.format
'l'
>>> x.itemsize
8
>>> len(x)
3
>>> x.nbytes
24
>>> y = x.cast('B')
>>> y.format
'B'
>>> y.itemsize
1
>>> len(y)
24
>>> y.nbytes
24

将1d/无符号字节强制转换为1d/字符：：

>>> b = bytearray(b'zyz')
>>> x = memoryview(b)
>>> x[0] = b'a'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: memoryview: invalid value for format "B"
>>> y = x.cast('c')
>>> y[0] = b'a'
>>> b
bytearray(b'ayz')

将1d/字节转换为3d/整数转换为1d/有符号字符：

>>> import struct
>>> buf = struct.pack("i"*12, *list(range(12)))
>>> x = memoryview(buf)
>>> y = x.cast('i', shape=[2,2,3])
>>> y.tolist()
[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
>>> y.format
'i'
>>> y.itemsize
4
>>> len(y)
2
>>> y.nbytes
48
>>> z = y.cast('b')
>>> z.format
'b'
>>> z.itemsize
1
>>> len(z)
48
>>> z.nbytes
48

将1d/无符号长转换为2d/无符号长：

>>> buf = struct.pack("L"*6, *list(range(6)))
>>> x = memoryview(buf)
>>> y = x.cast('L', shape=[2,3])
>>> len(y)
2
>>> y.nbytes
48
>>> y.tolist()
[[0, 1, 2], [3, 4, 5]]

3.3 新版功能.

在 3.5 版更改: 当强制转换为字节视图时，源格式不再受到限制。

还有几个只读属性可用：

obj

memoryView的基础对象：

>>> b  = bytearray(b'xyz')
>>> m = memoryview(b)
>>> m.obj is b
True

3.3 新版功能.

nbytes

nbytes == product(shape) * itemsize == len(m.tobytes()) . 这是数组将在连续表示中使用的字节空间量。它不一定等于 len(m) ：：

>>> import array
>>> a = array.array('i', [1,2,3,4,5])
>>> m = memoryview(a)
>>> len(m)
5
>>> m.nbytes
20
>>> y = m[::2]
>>> len(y)
3
>>> y.nbytes
12
>>> len(y.tobytes())
12

多维数组：

>>> import struct
>>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])
>>> x = memoryview(buf)
>>> y = x.cast('d', shape=[3,4])
>>> y.tolist()
[[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]]
>>> len(y)
3
>>> y.nbytes
96

3.3 新版功能.

readonly

指示内存是否为只读的布尔值。

format

包含格式的字符串（在 struct 模块样式）。可以从具有任意格式字符串的导出器创建memoryView，但某些方法（例如 tolist() ）仅限于本机单个元素格式。

在 3.3 版更改: 格式 'B' 现在根据结构模块语法处理。这意味着 memoryview(b'abc')[0] == b'abc'[0] == 97 .

itemsize

memoryView的每个元素的字节大小：

>>> import array, struct
>>> m = memoryview(array.array('H', [32000, 32001, 32002]))
>>> m.itemsize
2
>>> m[0]
32000
>>> struct.calcsize('H') == m.itemsize
True

ndim

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

shape

整数的一个元组，其长度为 ndim 以n维数组的形式给出存储器的形状。

在 3.3 版更改: 空元组而不是 None 当nDIM＝0时。

strides

整数的一个元组，其长度为 ndim 为数组的每个维度提供访问每个元素的字节大小。

在 3.3 版更改: 空元组而不是 None 当nDIM＝0时。

suboffsets

内部用于PIL样式数组。该值仅供参考。

c_contiguous

指示内存是否为C的布尔值。 -contiguous .

3.3 新版功能.

f_contiguous

指示内存是否为Fortran的布尔值 contiguous .

3.3 新版功能.

contiguous

指示内存是否为 contiguous .

3.3 新版功能.

集合类型 set ， frozenset

A set 对象是distinct的无序集合 hashable 物体。常见的用途包括成员资格测试、从序列中删除重复项以及计算数学运算，如交集、并集、差分和对称差分。（对于其他容器，请参见内置的 dict ， list 和 tuple 课程，以及 collections 模块。

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

目前有两种内置的集合类型， set 和 frozenset . 这个 set 类型是可变的---可以使用如下方法更改内容 add() 和 remove() . 因为它是可变的，所以它没有hash值，不能用作字典键或另一个集合的元素。这个 frozenset 类型不可变且 hashable ---其内容创建后不能更改，因此可以用作字典键或其他集合的元素。

非空集（非冻结集）可以通过在大括号内放置以逗号分隔的元素列表来创建，例如： {{'jack', 'sjoerd'}} ，除了 set 构造函数。

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

class set([iterable])

class frozenset([iterable])

返回其元素取自的新集合或冻结集合对象 可迭代的 . 集合的元素必须是 hashable . 要表示集合的集合，内部集合必须 frozenset 物体。如果 可迭代的 未指定，将返回新的空集。

可以通过多种方式创建集合：

• 在大括号内使用逗号分隔的元素列表： {{'jack', 'sjoerd'}}

• 使用一种固定的理解： {{c for c in 'abracadabra' if c not in 'abc'}}

• 使用类型构造函数： set() ， set('foobar') ， set(['a', 'b', 'foo'])

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

len(s)

返回集合中的元素数 s （基数） s ）

x in s

试验 x 会员资格 s .

x not in s

试验 x 对于非会员 s .

isdisjoint(other)

返回 True 如果集合中没有与 other . 当且仅当集合的交集为空集合时，集合才是不相交的。

issubset(other)

set <= other

测试集合中的每个元素是否都在 other .

set < other

测试集合是否为 other 也就是说， set <= other and set != other .

issuperset(other)

set >= other

测试中的每个元素 other 在集合中。

set > other

测试集合是否为 other 也就是说， set >= other and set != other .

union(*others)

set | other | ...

返回包含集合和所有其他元素的新集合。

intersection(*others)

set & other & ...

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

difference(*others)

set - other - ...

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

symmetric_difference(other)

set ^ other

返回包含集合或中元素的新集合 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')]) .

子集和相等比较不能概括为总排序函数。例如，任意两个非空的不相交集不相等，也不是彼此的子集，因此 all 以下返回的 False ： a<b ， a==b 或 a>b .

由于集合只定义部分排序（子集关系），因此 list.sort() 方法未定义集合列表。

集合元素（如字典键）必须 hashable .

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

下表列出了可用于 set 不适用于 frozenset ：

update(*others)

set |= other | ...

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

intersection_update(*others)

set &= other & ...

更新集合，只保留其中的元素和所有其他元素。

difference_update(*others)

set -= other | ...

更新集合，删除在其他集合中找到的元素。

symmetric_difference_update(other)

set ^= other

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

add(elem)

添加元素 elem 到集合。

remove(elem)

移除元素 elem 从集合。引发 KeyError 如果 elem 不包含在集合中。

discard(elem)

移除元素 elem 如果存在的话。

pop()

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

clear()

从集合中移除所有元素。

注意，非操作员版本的 update() ， intersection_update() ， difference_update() 和 symmetric_difference_update() 方法将接受任何ITerable作为参数。

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

映射类型--- dict

A mapping 对象映射 hashable 任意对象的值。映射是可变对象。当前只有一种标准映射类型，即 dictionary . （对于其他容器，请参见内置的 list ， set 和 tuple 课程，以及 collections 模块。

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

可以通过放置逗号分隔的 key: value 大括号内的对，例如： {{'jack': 4098, 'sjoerd': 4127}} 或 {{4098: 'jack', 4127: 'sjoerd'}} ，或由 dict 构造函数。

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

返回从可选位置参数和可能为空的关键字参数集初始化的新字典。

可以通过以下几种方式创建词典：

• 使用逗号分隔的列表 key: value 大括号内的对： {{'jack': 4098, 'sjoerd': 4127}} 或 {{4098: 'jack', 4127: 'sjoerd'}}

• 使用字典理解： {{}} ， {{x: x ** 2 for x in range(10)}}

• 使用类型构造函数： dict() ， dict([('foo', 100), ('bar', 200)]) ， dict(foo=100, bar=200)

如果没有指定位置参数，则创建空字典。如果给定了位置参数并且它是映射对象，则将使用与映射对象相同的键值对创建字典。否则，位置参数必须是 iterable 对象。iterable中的每个项本身必须是一个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})
>>> f = dict({'one': 1, 'three': 3}, two=2)
>>> a == b == c == d == e == f
True

如第一个示例所示，提供关键字参数只对有效的Python标识符的键有效。否则，可以使用任何有效密钥。

这些是字典支持的操作（因此，自定义映射类型也应该支持）：

list(d)

返回字典中使用的所有键的列表 d .

len(d)

返回字典中的项数 d .

d[key]

返回的项 d 带钥匙 key .提高 KeyError 如果 key 不在地图上。

如果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 . 另一个 __missing__ 方法由使用 collections.defaultdict .

d[key] = value

集合 d[key] 到 value .

del d[key]

去除 d[key] 从 d .提高 KeyError 如果 key 不在地图上。

key in d

返回 True 如果 d 有钥匙 key ，否则 False .

key not in d

相当于 not key in d .

iter(d)

返回对字典键的迭代器。这是一个快捷方式 iter(d.keys()) .

clear()

从字典中删除所有项。

copy()

返回字典的浅薄副本。

classmethod fromkeys(iterable[, value])

使用键从创建新词典 可迭代的 和值设置为 value .

fromkeys() 是返回新字典的类方法。 价值 默认为 None . 所有的值都只引用一个实例，因此对于 价值 是可变对象，如空列表。要获得不同的值，请使用 dict comprehension 相反。

get(key[, default])

返回的值 key 如果 key 在字典里，否则 default .如果 default 未给定，默认为 None ，以便此方法不会引发 KeyError .

items()

返回字典项的新视图 ((key, value) 对）。见 documentation of view objects .

keys()

返回字典键的新视图。查看 documentation of view objects .

pop(key[, default])

如果 key 在字典中，移除并返回其值，否则返回 default . 如果 default 没有给予和 key 不在字典中，a KeyError 提高了。

popitem()

移除并返回 (key, value) 从字典中配对。成对返回 LIFO 秩序。

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

在 3.7 版更改: 后进先出订单现已得到保证。在以前的版本中， popitem() 将返回任意键/值对。

reversed(d)

返回对字典键的反向迭代器。这是一个快捷方式 reversed(d.keys()) .

3.8 新版功能.

setdefault(key[, default])

如果 key 在字典中，返回其值。如果不是，插入 key 具有价值 default 然后返回 default . default 默认为 None .

update([other])

使用来自的键/值对更新字典 other ，覆盖现有密钥。返回 None .

update() 接受另一个字典对象或键/值对的iterable（作为元组或长度为2的其他iterable）。如果指定了关键字参数，则字典将使用这些键/值对进行更新： d.update(red=1, blue=2) .

values()

返回字典值的新视图。见 documentation of view objects .

平等比较 dict.values() 视图和另一个将始终返回 False . 这也适用于比较 dict.values() 对自己说：

>>> d = {'a': 1}
>>> d.values() == d.values()
False

d | other

使用合并的键和值创建新词典 d 和 其他 ，必须都是字典。价值观 其他 优先考虑 d 和 其他 共享密钥。

3.9 新版功能.

d |= other

更新字典 d 键和值来自 其他 ，可以是 mapping 或 iterable 键/值对的。价值观 其他 优先考虑 d 和 其他 共享密钥。

3.9 新版功能.

字典只有在具有相同的条件下才具有相等的比较 (key, value) 成对（不考虑顺序）。顺序比较（“<”、“<=”、“>=”、“>”）提升 TypeError .

词典保留插入顺序。请注意，更新密钥不会影响顺序。删除后添加的键将插入到末尾。：：

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(d)
['one', 'two', 'three', 'four']
>>> list(d.values())
[1, 2, 3, 4]
>>> d["one"] = 42
>>> d
{'one': 42, 'two': 2, 'three': 3, 'four': 4}
>>> del d["two"]
>>> d["two"] = None
>>> d
{'one': 42, 'three': 3, 'four': 4, 'two': None}

在 3.7 版更改: 字典顺序保证为插入顺序。这个行为是3.6中的cpython的一个实现细节。

字典和字典视图是可逆的。地址：

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(reversed(d))
['four', 'three', 'two', 'one']
>>> list(reversed(d.values()))
[4, 3, 2, 1]
>>> list(reversed(d.items()))
[('four', 4), ('three', 3), ('two', 2), ('one', 1)]

在 3.8 版更改: 字典现在是可逆的。

参见

types.MappingProxyType 可用于创建 dict .

字典视图对象

返回的对象 dict.keys() ， dict.values() 和 dict.items() 是 查看对象 . 它们提供字典条目的动态视图，这意味着当字典更改时，视图会反映这些更改。

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

len(dictview)

返回字典中的条目数。

iter(dictview)

返回键、值或项的迭代器（表示为 (key, value) ）在字典里。

键和值按插入顺序迭代。这允许创建 (value, key) 配对使用 zip() ： pairs = zip(d.values(), d.keys()) .创建相同列表的另一种方法是 pairs = [(v, k) for (k, v) in d.items()] .

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

在 3.7 版更改: 字典顺序保证为插入顺序。

x in dictview

返回 True 如果 x 在基础字典的键、值或项中（在后一种情况下， x 应该是 (key, value) 元组）

reversed(dictview)

对字典的键、值或项返回反向迭代器。视图将按插入的相反顺序进行迭代。

在 3.8 版更改: 字典视图现在是可逆的。

dictview.mapping

返回A types.MappingProxyType 它包装视图所引用的原始字典。

3.10 新版功能.

键视图的设置与之类似，因为它们的条目是唯一的，并且是可hash的。如果所有值都是可hash的，那么 (key, value) 对是唯一的和可hash的，那么items视图也设置为。（值视图不被视为集样视图，因为条目通常不唯一。）对于集样视图，为抽象基类定义的所有操作 collections.abc.Set 可用（例如， == ， < 或 ^ ）

字典视图用法示例：

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

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

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

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

>>> # set operations
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}
>>> keys ^ {'sausage', 'juice'}
{'juice', 'sausage', 'bacon', 'spam'}

>>> # get back a read-only proxy for the original dictionary
>>> values.mapping
mappingproxy({'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500})
>>> values.mapping['spam']
500

上下文管理器类型

Python 的 with 语句支持由上下文管理器定义的运行时上下文的概念。这是使用一对方法实现的，这些方法允许用户定义的类定义在执行语句体之前输入的运行时上下文，并在语句结束时退出：

contextmanager.__enter__()

输入运行时上下文并返回此对象或与运行时上下文相关的其他对象。此方法返回的值绑定到 as 条款 with 使用此上下文管理器的语句。

返回自身的上下文管理器的示例是 file object . 文件对象从回车返回到允许 open() 将用作 with 语句。

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

contextmanager.__exit__(exc_type, exc_val, exc_tb)

退出运行时上下文并返回一个布尔标志，指示是否应取消发生的任何异常。如果在执行 with 语句中，参数包含异常类型、值和回溯信息。否则，这三个参数都是 None .

从该方法返回真值将导致 with 语句来抑制异常并继续执行 with 语句。否则，在该方法完成执行后，异常将继续传播。在执行此方法期间发生的异常将替换在 with 语句。

传入的异常决不应显式重新引发-相反，此方法应返回一个错误值，以指示该方法已成功完成，并且不希望抑制引发的异常。这允许上下文管理代码轻松检测 __exit__() 方法实际上失败了。

python定义了几个上下文管理器，以支持简单的线程同步、文件或其他对象的快速关闭以及活动十进制算术上下文的简单操作。除了上下文管理协议的实现之外，不专门处理特定类型。见 contextlib 一些例子的模块。

Python 的 generator S和 contextlib.contextmanager decorator提供了实现这些协议的方便方法。如果生成器函数用 contextlib.contextmanager decorator，它将返回一个实现 __enter__() 和 __exit__() 方法，而不是由未修饰的生成器函数生成的迭代器。

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

类型注释类型 Generic Alias ， Union

的核心内置类型 type annotations 是 Generic Alias 和 Union 。

通用别名类型

GenericAlias 对象是通过为类(通常是容器)下标来创建的，例如 list[int] 。它们主要用于 type annotations 。

通常情况下， subscription 的容器对象调用该方法 __getitem__() 对象的。但是，某些容器的类的订阅可能会调用类方法 __class_getitem__() 取而代之的是班上的学生。类方法 __class_getitem__() 应返回一个 GenericAlias 对象。

注解

如果 __getitem__() 类的元类的属性，则它将优先于 __class_getitem__() 在类中定义(请参见 PEP 560 了解更多详细信息)。

这个 GenericAlias 对象充当 generic types ，实施 参数化泛型 -为容器元素提供类型的泛型的特定实例。

对象的用户公开类型。 GenericAlias 可以从以下位置访问对象 types.GenericAlias 并用于 isinstance() 支票。它还可以用于创建 GenericAlias 直接访问对象。

T[X, Y, ...]

创建一个 GenericAlias 表示一种类型 T 包含类型元素的 X ， Y ，以及更多内容，具体取决于 T 使用。例如，一个函数需要一个 list 包含 float 元素：：

def average(values: list[float]) -> float:
    return sum(values) / len(values)

另一个示例是 mapping 对象，使用 dict ，它是一个泛型类型，需要两个表示键类型和值类型的类型参数。在此示例中，该函数需要一个 dict 具有以下类型的键 str 和类型的值 int ：：

def send_post_request(url: str, body: dict[str, int]) -> None:
    ...

内置函数 isinstance() 和 issubclass() 不接受 GenericAlias 第二个参数的类型：：

>>> isinstance([1, 2], list[str])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: isinstance() argument 2 cannot be a parameterized generic

Python运行时不强制 type annotations 。这扩展到泛型类型及其类型参数。当从 GenericAlias ，则不对照其类型检查容器元素。例如，不建议使用以下代码，但运行时不会出现错误：

>>> t = list[str]
>>> t([1, 2, 3])
[1, 2, 3]

此外，参数化泛型会在对象创建过程中擦除类型参数：

>>> t = list[str]
>>> type(t)
<class 'types.GenericAlias'>

>>> l = t()
>>> type(l)
<class 'list'>

呼叫 repr() 或 str() 在泛型上显示参数化类型：：

>>> repr(list[int])
'list[int]'

>>> str(list[int])
'list[int]'

这个 __getitem__() 方法将引发一个异常，以禁止出现如下错误 dict[str][str] ：：

>>> dict[str][str]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: There are no type variables left in dict[str]

但是，此类表达式在以下情况下有效 type variables 都是用过的。索引中的类型变量项的数量必须与 GenericAlias 对象的 __args__ 。：：

>>> from typing import TypeVar
>>> Y = TypeVar('Y')
>>> dict[str, Y][int]
dict[str, int]

标准通用集合

这些标准库集合支持参数化泛型。

• tuple

• list

• dict

• set

• frozenset

• type

• collections.deque

• collections.defaultdict

• collections.OrderedDict

• collections.Counter

• collections.ChainMap

• collections.abc.Awaitable

• collections.abc.Coroutine

• collections.abc.AsyncIterable

• collections.abc.AsyncIterator

• collections.abc.AsyncGenerator

• collections.abc.Iterable

• collections.abc.Iterator

• collections.abc.Generator

• collections.abc.Reversible

• collections.abc.Container

• collections.abc.Collection

• collections.abc.Callable

• collections.abc.Set

• collections.abc.MutableSet

• collections.abc.Mapping

• collections.abc.MutableMapping

• collections.abc.Sequence

• collections.abc.MutableSequence

• collections.abc.ByteString

• collections.abc.MappingView

• collections.abc.KeysView

• collections.abc.ItemsView

• collections.abc.ValuesView

• contextlib.AbstractContextManager

• contextlib.AbstractAsyncContextManager

• re.Pattern

• re.Match

通用别名的特殊属性

所有参数化泛型都实现特殊的只读属性。

genericalias.__origin__

此属性指向非参数化泛型类：：

>>> list[int].__origin__
<class 'list'>

genericalias.__args__

此属性是一个 tuple (可能长度为1)传递给原始的泛型类型 __class_getitem__() 泛型容器的：：

>>> dict[str, list[int]].__args__
(<class 'str'>, list[int])

genericalias.__parameters__

此属性是在以下位置找到的唯一类型变量的延迟计算元组(可能为空 __args__ ：：

>>> from typing import TypeVar

>>> T = TypeVar('T')
>>> list[T].__parameters__
(~T,)

注解

A GenericAlias 具有以下内容的对象 typing.ParamSpec 参数可能不正确 __parameters__ 在替换之后，因为 typing.ParamSpec 主要用于静电类型检查。

参见

• PEP 585 --“标准集合中的类型提示泛型”

• __class_getitem__() --用于实现参数化泛型。

• 泛型 --中的泛型 typing 模块。

3.9 新版功能.

联合类型

联合对象保存 | (按位或)对多个 type objects 。这些类型主要用于 type annotations 。与相比，联合类型表达式支持更清晰的类型提示语法 typing.Union 。

X | Y | ...

定义包含类型的联合对象 X ， Y ，以此类推。 X | Y 表示X或Y。它等同于 typing.Union[X, Y] 。例如，以下函数需要类型为 int 或 float ：：

def square(number: int | float) -> int | float:
    return number ** 2

union_object == other

可以测试联合对象与其他联合对象是否相等。详细信息：

• 工会的工会是扁平化的：

  (int | str) | float == int | str | float
  

• 删除冗余类型：：

  int | str | int == int | str
  

• 比较并集时，忽略顺序：：

  int | str == str | int
  

• 它与 typing.Union ：：

  int | str == typing.Union[int, str]
  

• 可选类型可以拼写为与 None ：：

  str | None == typing.Optional[str]
  

isinstance(obj, union_object)

呼叫至 isinstance() 也受联合对象支持：：

>>> isinstance("", int | str)
True

但是，包含以下内容的联合对象 parameterized generics 不能使用：：

>>> isinstance(1, int | list[int])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: isinstance() argument 2 cannot contain a parameterized generic

issubclass(obj, union_object)

呼叫至 issubclass() 也受联合对象支持：：

>>> issubclass(bool, int | str)
True

但是，包含以下内容的联合对象 parameterized generics 不能使用：：

>>> issubclass(bool, bool | list[str])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: issubclass() argument 2 cannot contain a parameterized generic

可以从访问联合对象的用户公开类型 types.Union 并用于 isinstance() 支票。不能从类型：：实例化对象

>>> import types
>>> isinstance(int | str, types.Union)
True
>>> types.Union()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot create 'types.Union' instances

注解

这个 __or__() 添加了类型对象的方法以支持语法 X | Y 。如果元类实现了 __or__() ，工会可以覆盖它：：

>>> class M(type):
...     def __or__(self, other):
...         return "Hello"
...
>>> class C(metaclass=M):
...     pass
...
>>> C | int
'Hello'
>>> int | C
int | __main__.C

参见

PEP 604 -PEP建议 X | Y 语法和UNION类型。

3.10 新版功能.

其他内置类型

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

模块

模块上唯一的特殊操作是属性访问： m.name 在哪里 m 是一个模块 name 访问中定义的名称 m 的符号表。模块属性可以分配给。（注意 import 严格来说，语句不是对模块对象的操作； import foo 不需要名为的模块对象 foo 要生存，它需要一个（外部的） 定义 对于名为 foo 某处）

每个模块的一个特殊属性是 __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'> .

类和类实例

见 对象、值和类型 和 类定义 为了这些。

功能

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

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

见 函数定义 更多信息。

方法

方法是使用属性表示法调用的函数。有两种风格：内置方法（例如 append() 和类实例方法。使用支持它们的类型描述内置方法。

如果通过实例访问方法（类命名空间中定义的函数），则会得到一个特殊的对象：a bound method （也称为 instance method 对象。当调用时，它将添加 self 参数列表的参数。绑定方法有两个特殊的只读属性： m.__self__ 是方法操作的对象，并且 m.__func__ 是实现方法的函数。调用 m(arg-1, arg-2, ..., arg-n) 完全等同于调用 m.__func__(m.__self__, arg-1, arg-2, ..., arg-n) .

与函数对象一样，绑定方法对象支持获取任意属性。但是，由于方法属性实际上存储在基础函数对象上 (meth.__func__ ，不允许对绑定方法设置方法属性。尝试对方法设置属性会导致 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: 'method' object has no attribute 'whoami'
>>> c.method.__func__.whoami = 'my name is method'
>>> c.method.whoami
'my name is method'

见 标准类型层次结构 更多信息。

代码对象

代码对象被实现用来表示“伪编译”的可执行python代码，如函数体。它们不同于函数对象，因为它们不包含对全局执行环境的引用。代码对象由内置的 compile() 函数，可以通过函数对象 __code__ 属性。也见 code 模块。

通过将代码对象（而不是源字符串）传递给 exec() 或 eval() 内置功能。

见 标准类型层次结构 更多信息。

类型对象

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

类型编写如下： <class 'int'> .

空对象

此对象由不显式返回值的函数返回。它不支持特殊操作。只有一个空对象，名为 None （内置名称）。 type(None)() 生成相同的单例。

它被写为 None .

省略号对象

此对象通常由切片使用（请参见 切屑 ）它不支持特殊操作。只有一个省略号对象，名为 Ellipsis （内置名称）。 type(Ellipsis)() 产生 Ellipsis 单件。

它被写为 Ellipsis 或 ... .

NotImplemented对象

当要求对不支持的类型进行操作时，从比较和二进制操作返回此对象。见 比较 更多信息。只有一个 NotImplemented 对象。 type(NotImplemented)() 生成单例实例。

它被写为 NotImplemented .

布尔值

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

它们被写为 False 和 True ，分别。

内部对象

见 标准类型层次结构 关于这个信息。它描述堆栈帧对象、回溯对象和切片对象。

特殊属性

实现将一些特殊的只读属性添加到几个与之相关的对象类型中。其中一些不是由 dir() 内置功能。

object.__dict__

用于存储对象（可写）属性的字典或其他映射对象。

instance.__class__

类实例所属的类。

class.__bases__

类对象的基类的元组。

definition.__name__

类、函数、方法、描述符或生成器实例的名称。

definition.__qualname__

这个 qualified name 类、函数、方法、描述符或生成器实例的。

3.3 新版功能.

class.__mro__

此属性是在方法解析期间查找基类时考虑的类的元组。

class.mro()

此方法可以由元类重写，以自定义其实例的方法解析顺序。它在类实例化时调用，其结果存储在 __mro__ .

class.__subclasses__()

每个类都保留对其直接子类的弱引用列表。此方法返回所有仍处于活动状态的引用的列表。该列表按定义顺序排列。示例：：

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

脚注

1

关于这些特殊方法的更多信息可以在python参考手册中找到。 (基本定制 ）

2

因此，清单 [1, 2] 被认为等于 [1.0, 2.0] ，对于元组也是如此。

3

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

4(1,2,3,4)

带大小写的字符是那些具有“lu”（字母、大写）、“ll”（字母、小写）或“lt”（字母、标题大小写）的常规类别属性的字符。

5(1,2)

因此，要只格式化一个元组，您应该提供一个单例元组，它的唯一元素是要格式化的元组。