Built-in Types

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

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

一些收集类是可变的。用于在适当位置添加，减去或重新排列其成员，并且不返回特定项目的方法，永远不要返回集合实例本身，而要返回None。

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

真值测试

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

默认情况下，除非对象的类定义了返回False的bool()方法或返回零的len()方法，否则将其视为 true。 [1]以下是被认为是错误的大多数内置对象：

• 定义为 false 的常量：None和False。

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

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

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

布尔运算-和(或)不

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

Notes:

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

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

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

Comparisons

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

下表总结了比较操作：

除不同的数字类型外，不同类型的对象永远不会比较相等。始终定义==运算符，但对于某些对象类型(例如，类对象)等效于is。 <，<=，>和>=运算符仅在有意义的地方定义；例如，当参数之一为复数时，它们会引发TypeError异常。

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

一个类的实例不能相对于同一类的其他实例或其他类型的对象进行排序，除非该类定义了足够的方法lt()，le()，gt()和ge()(通常，lt()和eq()就足够了)您需要比较运算符的常规含义)。

无法自定义is和is not运算符的行为；它们也可以应用于任何两个对象，并且永远不会引发异常。

iterable或实现contains()方法的类型支持另外两个具有相同语法优先级的操作in和not in。

数字类型-int，float，complex

共有三种不同的数字类型：整数，浮点数和复数。另外，布尔值是整数的子类型。整数具有无限精度。浮点数通常在 C 中使用double来实现； sys.float_info中提供了有关运行程序的计算机的浮点数的精度和内部表示形式的信息。复数具有实部和虚部，每个均是浮点数。要从复数* z *中提取这些部分，请使用z.real和z.imag。 (标准库包含附加数字类型fractions.Fraction(用于有理数)和decimal.Decimal(用于浮点数)(具有用户可定义的精度)。)

数字是pass数字 Literals 或内置函数和运算符创建的。未经修饰的整数 Literals(包括十六进制，八进制和二进制数字)产生整数。包含小数点或指数符号的数字 Literals 会产生浮点数。将'j'或'J'附加到数字 Literals 会产生虚数(实数为零的复数)，您可以将其加到整数或浮点数以获得具有实数和虚数的复数。

Python 完全支持混合算术：当二进制算术运算符具有不同数值类型的操作数时，具有“较窄”类型的操作数将扩展为另一种，其中整数比浮点数窄，比浮点数窄。不同类型数字之间的比较就像是在比较这些数字的确切值。 [2]

构造函数int()，float()和complex()可用于生成特定类型的数字。

所有数字类型(复数除外)都支持以下操作(有关操作的优先级，请参见Operator precedence)：

Notes:

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

• 不适用于复数。如果合适，请使用abs()转换为浮点数。

• 从浮点到整数的转换可能会像 C 中那样舍入或截断；否则，可能会截断。请参见函数math.floor()和math.ceil()中定义明确的转换。

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

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

• 接受的数字 Literals 包括数字0到9或任何等效的 Unicode(具有Nd属性的代码点)。

有关Nd属性的代码点的完整列表，请参见http://www.unicode.org/Public/12.1.0/ucd/extracted/DerivedNumericType.txt。

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

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

整数类型的按位运算

按位运算仅对整数有意义。按位运算的结果就像是用无数个符号位的二进制补码执行的。

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

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

Notes:

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

• 向左移位* n *位等效于与pow(2, n)相乘。

• 向右移位* n *位等效于将地板除以pow(2, n)。

• 用有限的二进制补码表示形式(工作位宽度为1 + max(x.bit_length(), y.bit_length())或更大)中的至少一个额外的符号扩展位执行这些计算，就足以获得与符号位无限大相同的结果。

整数类型的其他方法

int 类型实现numbers.Integral 抽象 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。

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

3.1 版中的新Function。

• 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'

整数使用* length *个字节表示。如果整数不能用给定的字节数表示，则引发OverflowError。

• byteorder 参数确定用于表示整数的字节 Sequences。如果 byteorder 为"big"，则最高有效字节在字节数组的开头。如果 byteorder *为"little"，则最高有效字节在字节数组的末尾。要请求主机系统的本机字节 Sequences，请使用sys.byteorder作为字节 Sequences 值。

• signed 参数确定是否使用二进制补码表示整数。如果 signed *为False且给出负整数，则引发OverflowError。 * signed *的默认值为False。

3.2 版中的新Function。

• • 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 *必须为bytes-like object或可迭代的生成字节。

• byteorder 参数确定用于表示整数的字节 Sequences。如果 byteorder 为"big"，则最高有效字节在字节数组的开头。如果 byteorder *为"little"，则最高有效字节在字节数组的末尾。要请求主机系统的本机字节 Sequences，请使用sys.byteorder作为字节 Sequences 值。

• signed *参数指示是否使用二进制补码表示整数。

3.2 版中的新Function。

• int. as_integer_ratio ( )
  • 返回Pair整数，其比率与原始整数完全相同，并且带有一个正分母。整数(整数)的整数比始终是作为分子的整数和作为分母的1。

3.8 版的新Function。

Float 的其他方法

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

• float. as_integer_ratio ( )

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

• float. is_integer ( )

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

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

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

• float. hex ( )

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

• 类方法 float. fromhex(* s *)

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

请注意，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'

散列数字类型

对于数字x和y，可能是不同类型的数字，要求hash(x) == hash(y)每当x == y(有关更多详细信息，请参见hash()方法文档)。为了简化各种数字类型(包括int，float，decimal.Decimal和fractions.Fraction)的实现和效率，Python 针对数字类型的哈希基于为任何有理数定义的单个 math 函数，因此适用于int和fractions.Fraction，以及float和decimal.Decimal的所有有限实例。本质上，此Function由固定素数P的模P的归约模给出。 P的值可作为sys.hash_info的modulus属性提供给 Python。

CPython 实现细节： 当前，使用的主要是在 32 位 C 长的机器上为P = 2**31 - 1，在 64 位 C 长的机器上为P = 2**61 - 1。

以下是详细的规则：

• 如果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)。如果生成的哈希为-1，则将其替换为-2。

• 特定值sys.hash_info.inf，-sys.hash_info.inf和sys.hash_info.nan分别用作正无穷大，负无穷大或 Nans 的哈希值。 (所有可哈希的 nan 都具有相同的哈希值.)

• 对于complex数字z，实部和虚部的哈希值pass计算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 代码，等效于内置哈希，用于计算有理数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

Iterator Types

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 这样做。不遵守此属性的实现被视为已损坏。

Generator Types

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

序列类型-列表，Tuples，范围

共有三种基本序列类型：列表，Tuples 和范围对象。在专用部分中介绍了为处理binary data和text strings而定制的其他序列类型。

通用序列操作

下表中的操作受可变和不可变的大多数序列类型支持。提供collections.abc.Sequence ABC 可以更轻松地在自定义序列类型上正确实现这些操作。

下表列出了按优先级升序排列的序列操作。在表中，* s 和 t 是相同类型的序列， n ， i ， j 和 k 是整数，而 x 是满足任何类型和值限制的任意对象由 s *强加。

in和not in操作具有与比较操作相同的优先级。 +(串联)和*(重复)运算与相应的数字运算具有相同的优先级。 [3]

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

Notes:

• 虽然in和not in操作通常仅用于简单的容器测试，但某些专用序列(例如str，bytes和bytearray)也将它们用于子序列测试：

>>> "gg" in "eggs"
True

• • 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。

• 连接不可变序列总是会产生一个新对象。这意味着pass重复级联构建序列将在序列总长度中带来二次运行时成本。为了获得线性运行时成本，您必须切换到以下替代方法之一：

• 如果串联str个对象，则可以构建一个列表并在末尾使用str.join()，或者写入io.StringIO实例并在完成后检索其值

• 如果要串联bytes对象，则可以类似地使用bytes.join()或io.BytesIO，也可以对bytearray对象进行就地串联。 bytearray个对象是可变的，并且具有有效的过度分配机制

• 如果串联tuple个对象，请扩展list

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

• 某些序列类型(例如range)仅支持遵循特定模式的项目序列，因此不支持序列连接或重复。

• 如果在* s 中找不到 x ，则index加注ValueError。并非所有实现都支持传递附加参数 i 和 j *。这些参数允许有效地搜索序列的各个部分。传递额外的参数大致等于使用s[i:j].index(x)，只是不复制任何数据，并且返回的索引相对于序列的开始而不是切片的开始。

不可变序列类型

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

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

try对包含不可哈希值的不可变序列进行哈希将导致TypeError。

可变序列类型

下表中的操作是在可变序列类型上定义的。提供collections.abc.MutableSequence ABC 可以更轻松地在自定义序列类型上正确实现这些操作。

在表中* s 是可变序列类型的实例， t 是任何可迭代对象， x 是满足 s *施加的任何类型和值限制的任意对象(例如bytearray仅接受整数符合值限制0 <= x <= 255)。

Notes:

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

• 可选参数* i *默认为-1，因此默认情况下将删除并返回最后一项。

• 如果在* s 中找不到 x *，则remove()加注ValueError。

• reverse()方法在反转大序列时会修改序列，以节省空间。为了提醒用户它是有副作用的，它不会返回相反的 Sequences。

• 包含clear()和copy()是为了与不支持切片操作的可变容器(例如dict和set)的接口保持一致。 copy()不是collections.abc.MutableSequence ABC 的一部分，但是大多数具体的可变序列类都提供了它。

版本 3.3 中的新Function：clear()和copy()方法。

• 值* n *是整数，或者是实现index()的对象。 * n *的零值和负值将清除序列。序列中的项目不会被复制；如通用序列运算下针对s * n所述，它们被多次引用。

Lists

列表是可变的序列，通常用于存储同类项目的集合(精确的相似程度会因应用程序而异)。

• 类别 list([可迭代])

  • 列表可以pass几种方式构造：

• 使用Pair方括号表示空白列表：[]

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

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

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

构造函数生成一个列表，该列表的项与* iterable *的项相同且 Sequences 相同。 * iterable 可以是序列，支持迭代的容器或迭代器对象。如果 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()Util 可用于将 2.x 样式* cmp 函数转换为 key *函数。

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

当对大型序列进行排序时，此方法会修改序列以节省空间。为了提醒用户它是有副作用的，它不会返回排序后的序列(使用sorted()显式请求一个新的排序后的列表实例)。

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

有关排序示例和简短的排序教程，请参见排序方式。

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

Tuples

Tuples 是不可变的序列，通常用于存储异构数据的集合(例如enumerate()内置生成的 2Tuples)。Tuples 还用于需要不变的同类数据序列的情况(例如允许存储在set或dict实例中)。

• 类别 tuple([可迭代])

  • Tuples 可以pass多种方式构造：

• 使用Pair圆括号表示空 Tuples：()

• 对单例 Tuples 使用尾随逗号：a,或(a,)

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

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

构造函数将构建一个 Tuples，其项与* iterable *的项相同且 Sequences 相同。 * iterable 可以是序列，支持迭代的容器或迭代器对象。如果 iterable *已经是一个 Tuples，则将其保持不变。例如，tuple('abc')返回('a', 'b', 'c')，tuple( [1, 2, 3] )返回(1, 2, 3)。如果未提供任何参数，则构造函数将创建一个新的空 Tuples()。

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

Tuples 实现所有common序列操作。

对于异类数据集合，其中按名称进行的访问比按索引进行的访问更清晰，因此collections.namedtuple()可能是比简单 Tuples 对象更合适的选择。

Ranges

range类型表示数字的不变序列，通常用于for循环中特定次数的循环。

• 类别 range(停止)

• • class * range(* start ， stop * [，* step *])
  • 范围构造函数的参数必须为整数(内置int或实现__index__特殊方法的任何对象)。如果Ellipsis* step 参数，则默认为1。如果Ellipsis start 参数，则默认为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的范围，但某些Function(例如len())可能会提高OverflowError。

Range examples:

>>> 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序列操作(由于范围对象只能表示遵循严格模式的序列，而重复和连接通常会违反该模式)。

• start

  • • start *参数的值(如果未提供该参数，则返回0)

• stop

  • • stop *参数的值

• step

  • • step *参数的值(如果未提供该参数，则返回1)

range类型优于常规list或tuple的优势在于，无论range对象表示的范围大小如何，它都将始终占用相同(少量)的内存(因为它仅存储start，stop和step值) ，根据需要计算单个项目和子范围)。

范围对象实现collections.abc.Sequence ABC，并提供诸如包含测试，元素索引查找，切片和对负索引的支持等Function(请参阅序列类型-列表，Tuples，范围)：

>>> 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 中的新Function：start，stop和step属性。

文本序列类型— str

Python 中的文本数据使用str对象或* strings *处理。字符串是 Unicode 代码点的sequences不变。字符串 Literals 以多种方式编写：

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

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

• 三引号：'''Three single quotes'''，"""Three double quotes"""

用三引号引起来的字符串可能会跨越多行-所有关联的空格都将包含在字符串 Literals 中。

作为单个表达式的一部分且字符串之间只有空格的字符串 Literals 将被隐式转换为单个字符串 Literals。即("spam " "eggs") == "spam eggs"。

有关各种形式的字符串 Literals 的更多信息，请参见字符串和字节 Literals，包括受支持的转义序列，以及禁用大多数转义序列处理的r(“ raw”)前缀。

也可以使用str构造函数从其他对象创建字符串。

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

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

在版本 3.3 中进行了更改：为了与 Python 2 系列向后兼容，再次在字符串 Literals 上允许使用u前缀。它对字符串 Literals 的含义没有影响，并且不能与r前缀结合使用。

• • class * str(* object =''*)
• • class * str(* object = b''， encoding ='utf-8'， errors ='strict'*)
  • 返回**的string版本。如果未提供* 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()之前获取缓冲区对象基础的字节对象。有关缓冲区对象的信息，请参见二进制序列类型-字节，字节数组，memoryview和Buffer Protocol。

在没有返回* encoding 或 errors *参数的情况下将bytes对象传递给str()属于返回非正式字符串表示形式的第一种情况(另请参见 Python 的-b命令行选项)。例如：

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

有关str类及其方法的更多信息，请参见下面的Literals 序列类型-str和String Methods部分。要输出格式化的字符串，请参见格式化的字符串 Literals和格式字符串语法部分。此外，请参见Literals 处理服务部分。

String Methods

字符串实现所有common序列操作以及下面介绍的其他方法。

字符串还支持两种样式的字符串格式，一种提供高度的灵 Active 和自定义性(请参见str.format()，格式字符串语法和自定义字符串格式)，另一种基于 C printf样式格式，可处理较小范围的类型，并且难以正确使用，但通常可以处理的情况(printf 样式的字符串格式)更快。

标准库的Literals 处理服务部分涵盖了许多其他模块，这些模块提供了各种与文本相关的 Util(包括re模块中的正则表达式支持)。

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

在 3.8 版中进行了更改：第一个字符现在放入标题大写而不是大写。这意味着像字母图这样的字符只会将其首字母大写，而不是完整字符。

• str. casefold ( )
  • 返回字符串的 casefolded 副本。折叠的字符串可用于无大小写的匹配。

大小写折叠类似于小写字母，但是更具攻击性，因为它旨在删除字符串中的所有大小写区别。例如，德语小写字母'ß'等效于"ss"。由于它已经是小写字母，因此lower()对'ß'无效。 casefold()将其转换为"ss"。

案例折叠算法在 Unicode 标准的 3.13 节中进行了描述。

版本 3.3 中的新Function。

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

  • 返回以长* width 的字符串为中心。使用指定的 fillchar (默认为 ASCII 空间)完成填充。如果 width *小于或等于len(s)，则返回原始字符串。

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

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

• str. encode(* encoding =“ utf-8” ， errors =“ strict” *)

  • 返回字符串的编码版本作为字节对象。默认编码为'utf-8'。 * errors *可以用来设置不同的错误处理方案。 * errors *的默认值为'strict'，这意味着编码错误会引发UnicodeError。其他可能的值是'ignore'，'replace'，'xmlcharrefreplace'，'backslashreplace'以及passcodecs.register_error()注册的任何其他名称，请参见Error Handlers部分。有关可能的编码的列表，请参见Standard Encodings部分。

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

• str. endswith(后缀 [，开始 [，结束]])

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

• str. expandtabs(* tabsize = 8 *)

  • 返回字符串的副本，其中所有制表符都被一个或多个空格替换，具体取决于当前列和给定的制表符大小。制表符位置每隔* 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'

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

在 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 版中的新Function。

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

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

• str. isalnum ( )

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

• str. isalpha ( )

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

• str. isascii ( )

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

3.7 版中的新Function。

• str. isdecimal ( )

  • 如果字符串中的所有字符均为十进制字符且至少有一个字符，则返回True，否则返回False。十进制字符是可用于以 10 为基数的数字的字符，例如 U 0660，阿拉伯文-印度数字零。十进制字符在形式上是 Unicode 常规类别“ Nd”中的字符。

• str. isdigit ( )

  • 如果字符串中的所有字符都是数字并且至少有一个字符，则返回True，否则返回False。数字包括需要特殊处理的十进制字符和数字，例如兼容性上标数字。它涵盖了不能用于以 10 为底的数字的数字，例如 Kharosthi 数字。形式上，数字是具有属性值 Numeric_Type =数字或 Numeric_Type =十进制的字符。

• str. isidentifier ( )

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

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

Example:

>>> from keyword import iskeyword

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

• str. islower ( )

  • 如果字符串中所有大小写的字符[4]均为小写且至少有一个大小写的字符，则返回True，否则返回False。

• str. isnumeric ( )

  • 如果字符串中的所有字符均为数字字符，并且至少包含一个字符，则返回True，否则返回False。数字字符包括数字字符，以及所有具有 Unicode 数值属性的字符，例如 U 2155，粗俗分数五分之一。形式上，数字字符是具有属性值 Numeric_Type =数字，Numeric_Type =十进制或 Numeric_Type =数字的字符。

• 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 ( )

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

• str. join(可迭代)

  • 返回一个字符串，该字符串是* iterable 中字符串的串联。如果 iterable *中包含任何非字符串值(包括bytes个对象)，则将引发TypeError。元素之间的分隔符是提供此方法的字符串。

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

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

• str. lower ( )

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

所使用的小写算法在 Unicode 标准的 3.13 节中进行了描述。

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

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

• 静态 str. maketrans(* x * [，* y * [，* z *]])
  • 此静态方法返回可用于str.translate()的转换表。

如果只有一个参数，则它必须是将 Unicode 序数(整数)或字符(长度为 1 的字符串)Map 到 Unicode 序数，任意长度的字符串或None的字典。然后，字符键将转换为普通字符。

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

• str. partition(* sep *)

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

• 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 (默认为 ASCII 空间)完成填充。如果 width *小于或等于len(s)，则返回原始字符串。

• str. rpartition(* sep *)

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

• str. rsplit(* sep = None ， maxsplit = -1 *)

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

• str. rstrip([字符])

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

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

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

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

For example:

>>> '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分隔符拆分空字符串或仅包含空格的字符串将返回[]。

For example:

>>> '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 *])
  • 返回字符串中的行列表，在行边界处break。除非给出* keepends *并且为 true，否则换行符不包含在结果列表中。

此方法在以下行边界上分割。特别是，边界是universal newlines的超集。

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

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(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(前缀 [，开始 [，结束]])

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

• str. strip([字符])

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

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

最外面的* chars 前导和结尾参数值从字符串中删除。从前端删除字符，直到到达 chars *中的字符集中未包含的字符串字符。在尾端发生类似的动作。例如：

>>> 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 ( )

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

For example:

>>> '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(表格)
  • 返回字符串的副本，其中每个字符都已pass给定的转换表进行 Map。该表必须是passgetitem()(通常是mapping或sequence)实现索引的对象。当用 Unicode 序数(整数)构建索引时，表对象可以执行以下任一操作：返回 Unicode 序数或字符串，以将字符 Map 到一个或多个其他字符； return None，从返回字符串中删除字符；或引发LookupError异常，以将角色 Map 到自身。

您可以使用str.maketrans()从不同格式的字符到字符 Map 创建翻译 Map。

另请参见codecs模块，以获取更灵活的自定义字符 Map 方法。

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

Unicode 标准的第 3.13 节描述了使用的大写算法。

• str. zfill(* width *)
  • 返回以 ASCII '0'数字填充的字符串的副本，以形成长度为* width 的字符串。前导符号前缀('+'/'-')pass在符号字符后而不是之前插入填充符来处理。如果* width *小于或等于len(s)，则返回原始字符串。

For example:

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

printf 样式的字符串格式

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

如果* 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:

• 备用格式导致在第一个数字之前插入前导八进制说明符('0o')。

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

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

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

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

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

• 如果 precision 为N，则输出将被截断为N个字符。

• See PEP 237.

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

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

二进制序列类型-字节，字节数组，memoryview

用于处理二进制数据的核心内置类型为bytes和bytearray。 memoryview支持它们，而memoryview使用buffer protocol来访问其他二进制对象的内存，而无需进行复制。

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

Bytes Objects

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

• • class * bytes([源 [，编码 [，错误]]])
  • 首先，字节字面量的语法与字符串字面量的语法基本相同，只是添加了b前缀：

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

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

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

字节 Literals 中仅允许使用 ASCII 字符(无论语句的源代码编码如何)。必须使用适当的转义序列将大于 127 的任何二进制值 Importing 到字节文本中。

与字符串 Literals 一样，字节 Literals 也可以使用r前缀来禁用转义序列的处理。有关各种形式的字节文本(包括受支持的转义序列)的更多信息，请参见字符串和字节 Literals。

尽管字节 Literals 和表示形式是基于 ASCII 文本的，但字节对象实际上的行为就像不可变的整数序列，该序列中的每个值都受到限制，以使0 <= x < 256(试图违反此限制将触发ValueError)。故意这样做是为了强调，尽管许多二进制格式都包含基于 ASCII 的元素，并且可以pass某些面向文本的算法进行有用的操作，但对于任意二进制数据通常不是这种情况(盲目地将文本处理算法应用于不是二进制格式的二进制数据格式)。 ASCII 兼容通常会导致数据损坏。

除了 Literals 形式，还可以pass许多其他方式创建字节对象：

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

• 从整数的迭代中：bytes(range(20))

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

另请参阅内置的bytes。

由于 2 个十六进制数字正好对应于一个字节，因此十六进制数字是描述二进制数据的常用格式。因此，字节类型具有附加的类方法来读取该格式的数据：

• 类方法 fromhex(字符串)
  • 此bytes类方法返回一个字节对象，对给定的字符串对象进行解码。该字符串每个字节必须包含两个十六进制数字，而 ASCII 空格将被忽略。

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

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

存在反向转换Function，可以将字节对象转换为其十六进制表示形式。

• 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 版中的新Function。

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

由于 bytes 对象是整数序列(类似于 Tuples)，因此对于 bytes 对象* b *，b[0]将是一个整数，而b[0:1]将是一个长度为 1 的 bytes 对象。(这与文本字符串形成对比，索引和切片将产生长度为 1 的字符串)

字节对象的表示使用 Literals 格式(b'...')，因为它通常比例如bytes([46, 46, 46])。您始终可以使用list(b)将字节对象转换为整数列表。

Bytearray Objects

bytearray个对象是bytes个对象的可变对象。

• • class * bytearray([源 [，编码 [，错误]]])
  • 字节数组对象没有专用的 Literals 语法，而是始终pass调用构造函数来创建它们：

• 创建一个空实例：bytearray()

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

• 从整数的迭代中：bytearray(range(20))

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

由于字节数组对象是可变的，因此除了字节和字节数组操作中描述的公共字节和字节数组操作外，它们还支持mutable序列操作。

另请参阅内置的bytearray。

由于 2 个十六进制数字正好对应于一个字节，因此十六进制数字是描述二进制数据的常用格式。因此，字节数组类型还有一个附加的类方法来读取该格式的数据：

• 类方法 fromhex(字符串)
  • 这个bytearray类方法返回 bytearray 对象，对给定的字符串对象进行解码。该字符串每个字节必须包含两个十六进制数字，而 ASCII 空格将被忽略。

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

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

存在反向转换Function，可将字节数组对象转换为其十六进制表示形式。

• hex([* * sep * [，* bytes_per_sep *]])
  • 对于实例中的每个字节，返回一个包含两个十六进制数字的字符串对象。

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

3.5 版中的新Function。

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

由于字节数组对象是整数序列(类似于列表)，因此对于字节数组对象* b *，b[0]将是整数，而b[0:1]将是长度为 1 的字节数组对象。(这与文本字符串不同，在文本字符串中，索引和切片将产生长度为 1 的字符串)

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

字节和字节数组操作

字节和字节数组对象都支持common序列操作。它们不仅可以与相同类型的操作数互操作，还可以与任何bytes-like object互操作。由于这种灵 Active，它们可以在操作中自由混合而不会引起错误。但是，结果的返回类型可能取决于操作数的 Sequences。

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

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

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

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

• bytes. count(* sub * [，* start * [，* end *]])
• bytearray. count(* sub * [，* start * [，* end *]])
  • 返回范围为[* start ， end *]的子序列* sub 的非重叠出现次数。可选参数 start 和 end *的解释方式为切片符号。

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

在版本 3.3 中更改：还接受范围为 0 到 255 之间的整数作为子序列。

• bytes. decode(* encoding =“ utf-8” ， errors =“ strict” *)
• bytearray. decode(* encoding =“ utf-8” ， errors =“ strict” *)
  • 返回从给定字节解码的字符串。默认编码为'utf-8'。 * errors *可以用来设置不同的错误处理方案。 * errors *的默认值为'strict'，这意味着编码错误会引发UnicodeError。其他可能的值为'ignore'，'replace'以及passcodecs.register_error()注册的任何其他名称，请参见Error Handlers部分。有关可能的编码的列表，请参见Standard Encodings部分。

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

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

要搜索的后缀可以是任何bytes-like object。

• bytes. find(* sub * [，* start * [，* end *]])
• bytearray. find(* sub * [，* start * [，* end *]])
  • 返回找到子序列* sub 的数据中的最低索引，从而使 sub 包含在切片s[start:end]中。可选参数 start 和 end 的解释方式为切片符号。如果未找到 sub *，则返回-1。

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

>>> 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(可迭代)

• bytearray. join(可迭代)

  • 返回一个字节或字节数组对象，该对象是* iterable 中二进制数据序列的串联。如果 iterable *中有任何不是bytes-like objects的值，包括str对象，则将引发TypeError。元素之间的分隔符是提供此方法的字节或字节数组对象的内容。

• 静态 bytes. maketrans(从，到)

• 静态 bytearray. maketrans(从，到)

  • 此静态方法返回可用于bytes.translate()的转换表，该转换表会将* from 中的每个字符 Map 到 to *中相同位置的字符； * from 和 to *必须都为bytes-like objects并且长度相同。

3.1 版中的新Function。

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

要搜索的分隔符可以是任何bytes-like object。

• bytes. replace(* old ， new * [，* count *])
• bytearray. replace(* old ， new * [，* count *])
  • 返回该序列的副本，并将所有出现的子序列* old 替换为 new 。如果给出了可选参数 count ，则仅替换第一个 count *项。

要搜索和替换的子序列可以是任何bytes-like object。

• bytes. rfind(* sub * [，* start * [，* end *]])
• bytearray. rfind(* sub * [，* start * [，* end *]])
  • 返回找到子序列* sub 的序列中的最高索引，以便 sub 包含在s[start:end]中。可选参数 start 和 end *的解释方式为切片符号。失败时返回-1。

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

在版本 3.3 中更改：还接受范围为 0 到 255 之间的整数作为子序列。

• bytes. rindex(* sub * [，* start * [，* end *]])
• bytearray. rindex(* sub * [，* start * [，* end *]])
  • 类似于rfind()，但是在未找到子序列* sub *时引发ValueError。

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

在版本 3.3 中更改：还接受范围为 0 到 255 之间的整数作为子序列。

• bytes. rpartition(* sep *)
• bytearray. rpartition(* sep *)
  • 在最后一次出现* sep *的情况下拆分序列，并返回一个三 Tuples，其中包含分隔符之前的部分，分隔符本身或其字节数组副本以及分隔符之后的部分。如果找不到分隔符，则返回一个包含两个空字节或字节数组对象的 3Tuples，后跟原始序列的副本。

要搜索的分隔符可以是任何bytes-like object。

• bytes. startswith(前缀 [，开始 [，结束]])
• bytearray. startswith(前缀 [，开始 [，结束]])
  • 如果二进制数据以指定的* prefix *开头，则返回True，否则返回False。 * prefix 也可以是要查找的前缀的 Tuples。使用可选的 start ，从该位置开始测试。使用可选的 end *，在该位置停止比较。

要搜索的前缀可以是任何bytes-like object。

• bytes. translate(* table ，/， delete = b''*)
• bytearray. translate(* table ，/， delete = b''*)
  • 返回字节或 bytearray 对象的副本，其中删除了可选参数* delete *中出现的所有字节，并且其余字节已pass给定的转换表进行 Map，该转换表必须是长度为 256 的字节对象。

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

对于仅删除字符的翻译，将* table *参数设置为None：

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

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

字节和字节数组对象上的以下方法具有默认行为，这些行为假定使用兼容 ASCII 的二进制格式，但仍可以pass传递适当的参数来与任意二进制数据一起使用。请注意，本节中的所有字节数组方法都不会在原地操作，而是产生新的对象。

• bytes. center(* width * [，* fillbyte *])
• bytearray. center(* width * [，* fillbyte *])
  • 返回以 length * width 序列为中心的对象的副本。使用指定的 fillbyte (默认为 ASCII 空间)完成填充。对于bytes个对象，如果 width *小于或等于len(s)，则返回原始序列。

• bytes. ljust(* width * [，* fillbyte *])
• bytearray. ljust(* width * [，* fillbyte *])
  • 返回以长度* width 的 Sequences 对齐的对象的副本。使用指定的 fillbyte (默认为 ASCII 空间)完成填充。对于bytes个对象，如果 width *小于或等于len(s)，则返回原始序列。

• bytes. lstrip([字符])
• bytearray. lstrip([字符])
  • 返回除去指定前导字节的序列的副本。 * chars 参数是一个二进制序列，指定要删除的一组字节值-名称是指此方法通常与 ASCII 字符一起使用的事实。如果Ellipsis或None，则 chars *参数默认为删除 ASCII 空格。 * chars *参数不是前缀；而是删除其值的所有组合：

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

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

• bytes. rjust(* width * [，* fillbyte *])
• bytearray. rjust(* width * [，* fillbyte *])
  • 返回长度正确的对象的副本，序列长度为 length * width 。使用指定的 fillbyte (默认为 ASCII 空间)完成填充。对于bytes个对象，如果 width *小于或等于len(s)，则返回原始序列。

• bytes. rsplit(* sep = None ， maxsplit = -1 *)

• bytearray. rsplit(* sep = None ， maxsplit = -1 *)

  • 使用* sep 作为分隔符字符串，将二进制序列拆分为相同类型的子序列。如果给出了 maxsplit ，最多完成 maxsplit 个分割，最右边的分割。如果未指定 sep *或None，则仅由 ASCII 空格组成的任何子序列都是分隔符。除了从右侧拆分外，rsplit()的行为与split()相似，下面将对其进行详细说明。

• bytes. rstrip([字符])

• bytearray. rstrip([字符])

  • 返回删除指定尾部字节的序列的副本。 * chars 参数是一个二进制序列，指定要删除的一组字节值-名称是指此方法通常与 ASCII 字符一起使用的事实。如果Ellipsis或None，则 chars *参数默认为删除 ASCII 空格。 * chars *参数不是后缀；而是删除其值的所有组合：

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

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

• bytes. split(* sep = None ， maxsplit = -1 *)
• bytearray. split(* sep = None ， maxsplit = -1 *)
  • 使用* sep 作为分隔符字符串，将二进制序列拆分为相同类型的子序列。如果给定 maxsplit 且非负数，则最多完成 maxsplit 个拆分(因此，列表最多包含maxsplit+1个元素)。如果未指定 maxsplit *或-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。

For example:

>>> 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 空格组成的序列将返回[]。

For example:

>>> 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([字符])
• bytearray. strip([字符])
  • 返回除去指定的前导字节和尾随字节的序列的副本。 * chars 参数是一个二进制序列，指定要删除的一组字节值-名称是指此方法通常与 ASCII 字符一起使用的事实。如果Ellipsis或None，则 chars *参数默认为删除 ASCII 空格。 * chars *参数不是前缀或后缀；而是删除其值的所有组合：

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

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

字节和字节数组对象上的以下方法假定使用 ASCII 兼容二进制格式，并且不应应用于任意二进制数据。请注意，本节中的所有字节数组方法都不会在原地操作，而是产生新的对象。

• bytes. capitalize ( )
• bytearray. capitalize ( )
  • 返回序列的副本，每个字节均解释为 ASCII 字符，第一个字节首字母大写，其余首字母小写。非 ASCII 字节值将不变地传递。

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

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

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

For example:

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

• bytes. isalpha ( )
• bytearray. isalpha ( )
  • 如果序列中的所有字节均为字母 ASCII 字符且序列不为空，则返回True，否则返回False。字母 ASCII 字符是序列b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'中的那些字节值。

For example:

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

• bytes. isascii ( )
• bytearray. isascii ( )
  • 如果序列为空或序列中的所有字节均为 ASCII，则返回True，否则返回False。 ASCII 字节的范围是 0-0x7F。

3.7 版中的新Function。

• bytes. isdigit ( )
• bytearray. isdigit ( )
  • 如果序列中的所有字节均为 ASCII 十进制数字且序列不为空，则返回True，否则返回False。 ASCII 十进制数字是序列b'0123456789'中的那些字节值。

For example:

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

• bytes. islower ( )
• bytearray. islower ( )
  • 如果序列中至少有一个小写 ASCII 字符且没有大写 ASCII 字符，则返回True，否则返回False。

For example:

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

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

• bytes. isspace ( )

• bytearray. isspace ( )

  • 如果序列中的所有字节均为 ASCII 空格且序列不为空，则返回True，否则返回False。 ASCII 空格字符是序列b' \t\n\r\x0b\f'中的那些字节值(空格，制表符，换行符，回车，垂直制表符，换页)。

• bytes. istitle ( )

• bytearray. istitle ( )

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

For example:

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

• bytes. isupper ( )
• bytearray. isupper ( )
  • 如果序列中至少有一个大写字母 ASCII 字符且没有小写 ASCII 字符，则返回True，否则返回False。

For example:

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

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

• bytes. lower ( )
• bytearray. lower ( )
  • 返回序列的副本，其中所有大写 ASCII 字符均转换为相应的小写字母。

For example:

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

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

• bytes. splitlines(* keepends = False *)
• bytearray. splitlines(* keepends = False *)
  • 返回二进制序列中的行列表，在 ASCII 行边界处break。此方法使用universal newlines方法分割线。除非给出* keepends *并且为 true，否则换行符不包含在结果列表中。

For example:

>>> 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 字符均转换为相应的大写字母，反之亦然。

For example:

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

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

与str.swapcase()不同，二进制版本始终是bin.swapcase().swapcase() == bin。大小写转换是 ASCII 对称的，即使对于任意 Unicode 代码点通常也不是这样。

• bytes. title ( )
• bytearray. title ( )
  • 返回二进制序列的带标题的版本，其中单词以大写 ASCII 字符开头，其余字符为小写。无大小写的字节值保持不变。

For example:

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

• bytes. upper ( )
• bytearray. upper ( )
  • 返回序列的副本，其中所有小写 ASCII 字符均转换为对应的大写字母。

For example:

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

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

• bytes. zfill(* width *)
• bytearray. zfill(* width *)
  • 返回保留有 ASCII b'0'数字的序列的副本，以形成长度* width 的序列。前导符号前缀(b'+'/b'-')pass在符号字符后而不是之前插入填充符来处理。对于bytes个对象，如果* width *小于或等于len(seq)，则返回原始序列。

For example:

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

printf 样式的字节格式

字节对象(bytes/bytearray)具有一个独特的内置操作：%运算符(模)。这也称为字节* formatting 或 interpolation 运算符。给定format % values(其中 format 是字节对象)，将 format 中的%转换规范替换为 values *的零个或多个元素。效果类似于在 C 语言中使用sprintf()。

如果* format 需要单个参数，则 values *可以是单个非 Tuples 对象。 [5]否则，“值”必须是一个 Tuples，且其元数必须与格式字节对象或单个 Map 对象(例如，字典)指定的数量完全相同。

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

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

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

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

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

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

• 长度修改器(可选)。

• Conversion type.

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

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

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

转换标志字符为：

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

转换类型为：

Notes:

• 备用格式导致在第一个数字之前插入前导八进制说明符('0o')。

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

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

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

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

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

• 如果 precision 为N，则输出将被截断为N个字符。

• b'%s'已过时，但在 3.x 系列中不会删除。

• b'%r'已过时，但在 3.x 系列中不会删除。

• See PEP 237.

3.5 版中的新Function。

Memory Views

memoryview对象允许 Python 代码无需复制即可访问支持buffer protocol的对象的内部数据。

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

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

len(view)等于tolist的长度。如果view.ndim = 0，则长度为 1.如果view.ndim = 1，则长度等于视图中元素的数量。对于较大的尺寸，长度等于视图的嵌套列表表示形式的长度。 itemsize属性将为您提供单个元素中的字节数。

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模块中的本机格式说明符之一，则还支持使用整数或整数 Tuples 构建索引，并返回具有正确类型的单个* element 。一维 memoryview 可以用整数或一整数 Tuples 构建索引。多维 memoryview 可以使用正好为 ndim 整数的 Tuples 构建索引，其中 ndim *为维数。零维 memoryview 可以用空 Tuples 构建索引。

这是一个非字节格式的示例：

>>> 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”的可散列(只读)类型的一维 memoryview 也可散列。哈希定义为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 中更改：现在可以切片一维 memoryview。格式为“ B”，“ b”或“ c”的一维 memoryview 现在可哈希化。

在版本 3.4 中进行了更改：现在已经自动向collections.abc.Sequence注册了 memoryview

在版本 3.5 中进行了更改：现在可以使用整数 Tuples 对 memoryviews 进行索引。

memoryview有几种方法：

• __eq__(Export 商)
  • 如果使用struct语法解释操作数的相应格式代码，则如果它们的形状相等并且所有对应的值都相等，则 memoryview 和 PEP 3118导出器将相等。

对于tolist()当前支持的struct格式字符串的子集，如果v.tolist() == w.tolist()则v和w相等：

>>> 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并不**暗示v == w用于 memoryview 对象。

在版本 3.3 中进行了更改：以前的版本比较了原始内存，而不管项目格式和逻辑数组结构。

• tobytes(* order = None *)
  • 以字节串形式返回缓冲区中的数据。这等效于在 memoryview 上调用bytes构造函数。

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

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

3.8 版中的新Function：* order 可以为\ {'C', 'F', 'A'}。当 order *为'C'或'F'时，原始数组的数据将转换为 C 或 FortranSequences。对于连续视图，“ A”返回物理内存的精确副本。特别是，保留了内存中的 FortranSequences。对于非连续视图，数据首先转换为 C。 * order = None 与 order ='C'*相同。

• hex([* * sep * [，* bytes_per_sep *]])
  • 对于缓冲区中的每个字节，返回一个包含两个十六进制数字的字符串对象。

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

3.5 版中的新Function。

在 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 版的新Function。

• 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语句将上下文 Management 协议用于类似的效果：

>>> 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 版中的新Function。

• cast(* format * [，* shape *])
  • 将 memoryview 强制转换为新的格式或形状。 * shape *默认为[byte_length//new_itemsize]，这意味着结果视图将是一维的。返回值是一个新的 memoryview，但是缓冲区本身未复制。支持的转换为 1D-> C- contiguous和 C-contiguous-> 1D。

目标格式被限制为struct语法中的单个元素本机格式。格式之一必须是字节格式(“ B”，“ b”或“ c”)。结果的字节长度必须与原始长度相同。

将 1D/long 转换为 1D/unsigned 字节：

>>> 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/char：

>>> 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/bytes 转换为 3D/ints 转换为 1D/signed char：

>>> 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 中的新Function。

在版本 3.5 中更改：转换为字节视图时，源格式不再受限制。

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

• obj
  • memoryview 的基础对象：

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

版本 3.3 中的新Function。

• 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

Multi-dimensional arrays:

>>> 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 中的新Function。

• readonly

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

• format

  • 一个字符串，其中包含视图中每个元素的格式(struct模块样式)。可以使用任意格式的字符串从导出程序创建 memoryview，但是某些方法(例如tolist())仅限于本机单元素格式。

在版本 3.3 中更改：现在根据 struct 模块语法处理格式'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的整数 Tuples，将内存的形状表示为 N 维数组。

在版本 3.3 中进行了更改：当 ndim = 0 时，一个空的 Tuples 而不是None。

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

在版本 3.3 中进行了更改：当 ndim = 0 时，一个空的 Tuples 而不是None。

• suboffsets

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

• c_contiguous

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

版本 3.3 中的新Function。

• f_contiguous
  • 指示内存是否为 Fortran contiguous的布尔值。

版本 3.3 中的新Function。

• contiguous
  • 指示内存是否为contiguous的布尔值。

版本 3.3 中的新Function。

集合类型-集合，冻结集合

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

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

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

可以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。当且仅当它们的交集为空集时，集才是不相交的。

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

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

• intersection(*其他)

  • set & other & ...

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

• difference(*其他)

  • set - other - ...

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

• 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。

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

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

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

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

• update(*其他)

  • set |= other | ...

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

• intersection_update(*其他)

  • set &= other & ...

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

• difference_update(*其他)

  • set -= other | ...

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

• 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 *创建了一个临时集。

Map 类型—字典

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 标识符的键。否则，可以使用任何有效的密钥。

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

• list(d)

  • 返回字典* d *中使用的所有键的列表。

• 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__方法。

• d[key] = value

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

• del d[key]

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

• key in d

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

• key not in d

  • 等效于not key in d。

• iter(d)

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

• clear ( )

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

• copy ( )

  • 返回字典的浅表副本。
• • classmethod * fromkeys(* iterable * [，* value *])
    • 使用* iterable 中的键和将值设置为 value *来创建新字典。

fromkeys()是返回新字典的类方法。 值默认为None。所有的值都只引用一个实例，因此* value *成为可变对象(如空列表)通常没有意义。要获取不同的值，请改用dict comprehension。

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

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

• items ( )

  • 返回字典项的新视图((key, value)对)。参见视图对象的文档。

• keys ( )

  • 返回字典键的新视图。参见视图对象的文档。

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

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

• popitem ( )

  • 从字典中删除并返回Pair(key, value)。配对按 LIFOSequences 返回。

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

在版本 3.7 中进行了更改：现在保证了 LIFO 订单。在以前的版本中，popitem()将返回任意键/值对。

• reversed(d)

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

3.8 版的新Function。

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

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

• update([[* other *])

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

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

• values ( )
  • 返回字典值的新视图。参见视图对象的文档。

一个dict.values()视图与另一个视图之间的相等性比较将始终返回False。在将dict.values()与自身进行比较时，这也适用：

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

当且仅当字典具有相同的(key, value)对时，字典才会比较相等(无论 Sequences 如何)。订单比较('<', '<=', '> ='，'>')提高TypeError。

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

>>> 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 中更改：保证字典 Sequences 为插入 Sequences。此行为是 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 中进行了更改：词典现在是可逆的。

字典视图对象

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

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

• len(dictview)

  • 返回字典中的条目数。

• iter(dictview)

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

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

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

在版本 3.7 中更改：保证字典 Sequences 为插入 Sequences。

• x in dictview

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

• reversed(dictview)

  • 在字典的键，值或项目上返回反向迭代器。该视图将以与插入相反的 Sequences 进行迭代。

在 3.8 版中进行了更改：词典视图现在是可逆的。

键视图是集合式的，因为它们的条目是唯一且可哈希的。如果所有值都是可散列的，因此(key, value)对是唯一且可散列的，则项目视图也是类似集合的。 (由于条目通常不是唯一的，因此值视图不会被视为类集合.)对于类集合视图，为抽象 Base Classcollections.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'}

上下文 Management 器类型

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

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

返回自身的上下文 Management 器的一个示例是file object。文件对象从__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 代码可以轻松检测exit()方法是否实际上已失败。

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

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

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

其他内置类型

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

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'>。

类和类实例

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

Functions

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

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

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

Methods

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

如果pass实例访问方法(在类命名空间中定义的函数)，则会得到一个特殊的对象：一个* 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__)上，因此不允许在绑定方法上设置方法属性。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: 'method' object has no attribute 'whoami'
>>> c.method.__func__.whoami = 'my name is method'
>>> c.method.whoami
'my name is method'

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

Code Objects

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

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

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

Type Objects

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

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

空对象

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

它写为None。

Ellipsis号对象

切片通常使用此对象(请参见Slicings)。它不支持任何特殊操作。恰好有一个Ellipsis号对象，名为Ellipsis(内置名称)。 type(Ellipsis)()产生Ellipsis单例。

它写为Ellipsis或...。

未实现的对象

当要求它们对不支持的类型进行操作时，该对象将从比较和二进制操作返回。有关更多信息，请参见Comparisons。恰好有一个NotImplemented对象。 type(NotImplemented)()产生单例实例。

它写为NotImplemented。

Boolean Values

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

它们分别写为False和True。

Internal Objects

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

Special Attributes

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

• object. __dict__

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

• instance. __class__

  • 类实例所属的类。

• class. __bases__

  • 类对象的 Base Class 的 Tuples。

• definition. __name__

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

• definition. __qualname__

  • 类，函数，方法，Descriptors 或生成器实例的qualified name。

版本 3.3 中的新Function。

• class. __mro__

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

• class. mro ( )

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

• class. __subclasses__ ( )

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

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

Footnotes

• [1]

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

• [2]

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

• [3]

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

• 4 (1,2,3,4)

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

• 5 (1,2)

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