4.内建类型 ¶
以下部分描述了内置到解释器中的标准类型。
主要的内建类型有数字、序列、映射、类、实例和异常。
有些容器类是可变的。添加、删除或重新排列成员而不返回特定项的方法，不会返回容器实例本身而是返回None。
某些操作被几种对象类型支持；特别地，实际上所有对象都可以被比较，测试真值并转换为字符串（使用repr()函数或稍微不同的str()函数） 。当通过print()函数写入对象时，隐式使用后一个函数。
4.1.真值测试 ¶
任何对象都可以被测试真值、用于if或while条件中或作为下面的布尔操作的操作数。以下值被视为假：
NoneFalse任何数值类型的零，例如
0、0.0、0j。任何空序列，例如
''、()、[]。任何空映射，例如，
{}。用户定义的类的实例，如果该类定义一个
__bool__()或__len__()方法，当该方法返回布尔值False或整数零的时候 。 [1] T0>
所有其他值都被认为是真 —— 所以许多类型的对象总是为真。
结果为布尔值的操作和内建函数，总是返回0或False表示假，返回1或True表示真，除非另有说明。（重要的例外：布尔运算or和and总是返回其操作数之一。）
4.2.布尔运算 — and, or, not¶
下面是 Boolean 操作, 按照优先级升序排列
| 操作 | 结果 | 备注 |
|---|---|---|
x or y | 若 x 为 False, 则结果为 y, 否则结果为 x | （1） |
x and y | 若x 为 false, 则结果为 x, 否则结果为 y | （2） |
not x | 若 x 为 false, 则结果为True, 否则结果为 False | （3） |
备注:
4.3.比较 ¶
Python有8种比较运算符。他们的优先级都相同（同时都比布尔运算符的优先级高）。比较符可以任意地连接;比如，x < y <= z等价于x < y and y <= z, 除非 y 是需要计算一次的 (但在这种情况下z都是只需要计算一次，因为 x < y 的结果是false).
下表总结了比较运算符：
| 操作 | 含义 |
|---|---|
< | 严格小于 |
<= | 小于或等于 |
> | 严格大于 |
>= | 大于或等于 |
== | 等于 |
!= | 不等于 |
is | 对象身份 |
is not | 否定对象身份 |
不同类型（除了不同的数值类型），永远不会相等。此外，某些类型 （例如，函数对象） 支持只有退化比较，因为该类型的任何两个对象都是不相等的。以下的操作会使<, <=, > and >= 操作会抛出 TypeError 异常，1、使用一个复数类型与其他的内建的数值类型进行比较；2、使用那些不能与其他类型比较的对象进行比较；3、或者其他没有定义排序规则的情况。
同一个类中的不同对象，通常会被判定为不相等，除非该类定义了__eq__() 方法
Instances of a class cannot be ordered with respect to other instances of the same class, or other types of object, unless the class defines enough of the methods __lt__(), __le__(), __gt__(), and __ge__() (in general, __lt__() and __eq__() are sufficient, if you want the conventional meanings of the comparison operators).
4.4.数值类型 — int, float, complex¶
Python有以下三种的数值类型: 整型(integers), 浮点型（floating point numbers）, 以及 复数（complex numbers）.另外，布尔是一个整数的子类型。整型拥有准确的精度。浮点型一般是实现C中的double 类型;有关浮点型的精度信息以及其在具体机器中的内部特性信息，可在sys.float_info中获取。复数类型由一个实数部分（即实部）与一个虚数部分（即虚部）构成，而这两个部分都是浮点型。若要从复数 z 中提取这两个部分，请使用 z.real 和 z.imag。（标准库包括了额外的数值类型，如分数（fractions） （包含了有理数），和 小数（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的绝对值或x的大小 | abs() | |
int(x) | x 转换为整数 | （3）（6） | int() |
float(x) | x 转换为浮点数 | （4）（6） | float() |
complex（re， im） | 将参数转化为复数，re为复数的实部，Im为复数的虚部。im 默认为0 | （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） |
笔记：
也被称为整数除法。结果值是一个整数，虽然结果的类型不一定是int。整数除法的结果总是向下取整（负无穷小）:
1//2is0,(-1)//2is-1,1//(-2)is-1, and(-1)//(-2)is0.复数无法使用。如果合适的话，可以使用
abs()转换为浮点数。从浮点到整数的转换可能在C中舍入或截断；请参阅函数
math.floor()和math.ceil()以获得定义明确的转换。对于非数字（NaN）和正或负无穷，float还接受带有可选前缀“+”或“ - ”的字符串“nan”和“inf”。
Python defines
pow(0, 0)and0 ** 0to be1, as is common for programming languages.接受的数字字面值包括数字
0到9或任何Unicode等效字符（具有Nd属性的代码点）。请参阅http://www.unicode.org/Public/8.0.0/ucd/extracted/DerivedNumericType.txt以获取具有
Nd属性的完整代码点列表。
所有number.Real类型（int和float）还包括以下操作：
| 操作 | 结果 |
|---|---|
math.trunc(x) | x截断为Integral |
round(x[, n]) | 将x四舍五入为n数字，将一半舍入到偶数。如果省略n，则默认为0。 |
math.floor(x) | 最大的小于等于x的整数 |
math.ceil(x) | 最小的大于等于x的整数 |
4.4.1.整数类型的位运算¶
按位操作只对整数有意义。负数被视为其2的补码值（假设有足够的位，因此在操作期间不会发生溢出）。
二进制按位操作的优先级都低于数值运算，并高于比较运算；一元操作~具有与其他一元数字操作（+和-）相同的优先级。
此表列出按升序优先级排序的按位运算：
| 操作 | 结果 | 笔记 |
|---|---|---|
x | y | x和y的按位或 | |
x ^ y | x和y的按位异或 | |
x & y | x和y的按位和 | |
x << n | x向左移动n位 | （1）（2） |
x >> n | x右移了n位 | （1）（3） |
~x | x的位反转 |
笔记：
- 负移位计数是非法的，并会引发
ValueError。 - A left shift by n bits is equivalent to multiplication by
pow(2, n)without overflow check. - A right shift by n bits is equivalent to division by
pow(2, n)without overflow check.
4.4.2.整数类型的其他方法¶
int类型实现numbers.Integral abstract base class。此外，它还提供了几个方法：
int.bit_length()¶返回表示二进制整数所需的位数，不包括符号和前导零：
>>> n = -37 >>> bin(n) '-0b100101' >>> n.bit_length() 6
更确切的说, 如果
x的值非零, 那么x.bit_length()is the unique positive integerksuch that2**(k-1) <= abs(x) < 2**k. Equivalently, whenabs(x)is small enough to have a correctly rounded logarithm, thenk = 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.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() // 8) + 1, byteorder='little') b'\xe8\x03'
整数使用length字节表示。如果整数不能用给定的字节数表示，则会引发
OverflowError。byteorder参数确定用于表示整数的字节顺序。如果byteorder为
“big”，则最高有效字节位于字节数组的开头。如果byteorder为“little”，则最高有效字节位于字节数组的末尾。要请求主机系统的本机字节顺序，请使用sys.byteorder作为字节顺序值。signed参数确定二进制补码是否用于表示整数。如果signed是
False且给出了负整数，则会引发OverflowError。signed的默认值为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必须是类似字节的对象或产生字节的可迭代对象。
byteorder参数确定用于表示整数的字节顺序。如果byteorder为
“big”，则最高有效字节位于字节数组的开头。如果byteorder为“little”，则最高有效字节位于字节数组的末尾。要请求主机系统的本机字节顺序，请使用sys.byteorder作为字节顺序值。signed参数指示是否使用二进制补码表示整数。
版本3.2中的新功能。
4.4.3.其他方法浮动¶
float类型实现了numbers.Real abstract base class。float还有以下附加方法。
float.as_integer_ratio()¶返回一对整数（2元组），它们的比例准确地等于浮点数的原始值，且分母为正数。在无穷上引发
OverflowError和在NaN上引发ValueError。
float.is_integer()¶如果浮点数实例是整数值，则返回
True，否则返回False：>>> (-2.0).is_integer() True >>> (3.2).is_integer() False
两种方法支持与十六进制字符串的转换。由于Python的浮点数在内部存储为二进制数，所以将float转换为或来自十进制字符串通常会涉及一个小的舍入误差。相反，十六进制字符串允许精确表示和指定浮点数。这在调试和数值工作时非常有用。
float.hex()¶将浮点数的表示形式返回为十六进制字符串。对于有限的浮点数，这种表示形式总是包括一个前导的
0x和尾部的p及指数。
- classmethod
float.fromhex(s)¶ Class方法返回由十六进制字符串s表示的浮点数。字符串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代码中的十六进制浮点数字，而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'
4.4.4.数字类型的散列¶
对于可能是不同类型的数字x和y，当hash(x)==hash(y)时x==y，（有关更多详细信息，请参阅__hash__()方法文档）。For ease of implementation and efficiency across a variety of numeric types (including int, float, decimal.Decimal and fractions.Fraction) Python’s hash for numeric types is based on a single mathematical function that’s defined for any rational number, and hence applies to all instances of int and fractions.Fraction, and all finite instances of float and decimal.Decimal. 本质上，对于固定素数P，这个函数是通过对P进行模减行给出的。 P的值作为sys.hash_info的modulus属性提供给Python。
CPython implementation detail: Currently, the prime used is P = 2**31 - 1 on machines with 32-bit C longs and P = 2**61 - 1 on machines with 64-bit C longs.
详细规则如下：
- If
x = m / nis a nonnegative rational number andnis not divisible byP, definehash(x)asm * invmod(n, P) % P, whereinvmod(n, P)gives the inverse ofnmoduloP. - If
x = m / nis a nonnegative rational number andnis divisible byP(butmis not) thennhas no inverse moduloPand the rule above doesn’t apply; in this case definehash(x)to be the constant valuesys.hash_info.inf. - If
x = m / nis a negative rational number definehash(x)as-hash(-x). 如果结果散列是-1，则用-2替换它。 - 特定值
sys.hash_info.inf，-sys.hash_info.inf和sys.hash_info.nan用作正无限的散列值，负无穷或者nans（分别）。（所有可散列的nans具有相同的散列值。） - For a
complexnumberz, the hash values of the real and imaginary parts are combined by computinghash(z.real) + sys.hash_info.imag * hash(z.imag), reduced modulo2**sys.hash_info.widthso that it lies inrange(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)). 同样，如果结果是-1，它将被替换为-2。
为了澄清上述规则，下面是一些用于计算有理数，float或complex的哈希的Python代码示例，相当于内置哈希：
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
4.5. 迭代器类型¶
Python支持对容器进行迭代的概念。它使用两种不同的方法实现；它们用于允许用户定义的类支持迭代。序列总是支持迭代，更多细节后面描述。
容器对象若要提供迭代支持，需要定义一个方法：
container.__iter__()¶返回一个迭代器对象。该对象需要支持下面描述的迭代器协议。如果容器支持不同类型的迭代，可以提供其他方法来专门请求这些迭代类型的迭代器。（支持多种迭代形式的对象的一个例子是支持宽度优先和深度优先遍历的树结构。）此方法对应于Python/C API中Python对象的类型结构的
tp_iter槽。
迭代器对象本身需要支持以下两种方法，它们一起形成迭代器协议：
iterator.__iter__()¶返回迭代器对象本身。它是必需的，以允许容器和迭代器在
for和in语句中使用。此方法对应于Python/C API中Python对象的类型结构的tp_iter槽。
iterator.__next__()¶从容器中返回下一个项目。如果没有其他元素，则引发
StopIteration异常。此方法对应于Python/C API中Python对象的类型结构的tp_iternext槽。
Python定义了多个迭代器对象以支持对一般和特定序列类型、字典和其他更专门的形式的迭代。除了迭代器协议的实现之外，特定类型并不重要。
一旦迭代器的__next__方法引发StopIteration，它必须在后续调用中继续引发这个异常。不遵守此属性的实现视为不正确的。
4.5.1. 生成器类型¶
Python的生成器提供了一种方便的方法来实现迭代器协议。如果容器对象的__iter__()方法被实现为生成器，它将自动返回提供__iter__()和__next__()方法的迭代器对象（技术上是一个生成器对象）。有关生成器的更多信息，请参见yield表达式的文档。
4.6.序列 — list, tuple, range¶
以下是三个基本的序列类型: lists, tuples, 以及range.在专用章节中描述了为处理二进制数据和文本字符串而定制的其他序列类型。
4.6.1.通用序列操作¶
大多数序列类型（包括可变序列和不可变序列）都支持下面表个中的操作。提供了collections.abc.Sequence ABC，以便更容易在自定义序列类型上正确实现这些操作。
此表按照优先级升序列出了序列类型的操作。在表中，s和t是相同类型的序列，n，i，j 和k是整数，x是满足s强加的任何类型和值限制的任意对象。
The in and not in operations have the same priorities as the comparison operations. +（连接）和*（重复）操作具有与相应数值操作相同的优先级。
| 操作 | 结果 | 笔记 |
|---|---|---|
x in s | 如果s包含x，返回True，否则返回False | （1） |
x not in s | 如果s包含x，返回False，否则返回True | （1） |
s + t | s和t的连接操作 | （6）（7） |
s * n or n * s | 相当于将s添加到自身n次 | （2）（7） |
s[i] | s的第i项，从第0项开始 | （3） |
s[i:j] | s的从第i项到第j-1项 | （3）（4） |
s[i:j:k] | s的从第i项到第j-1项,间隔为k | （3）（5） |
len(s) | s的长度 | |
min(s) | 最小的项目s | |
max(s) | 最大的项目s | |
s.index（x [， i [， j]]） | index of the first occurrence of x in s (at or after index i and before index j) | （8） |
s.count(x) | s中出现x的总次数 |
相同类型的序列也支持比较。具体来说，元组和列表通过比较相应的元素按字典顺序进行比较。这意味着为了比较相等，每个元素必须相等并且两个序列必须是相同类型并具有相同长度。(For full details see Comparisons in the language reference.)
笔记：
虽然
in和not in操作仅用于一般情况下的简单遏制测试, some specialised sequences (such asstr,bytesandbytearray) also use them for subsequence testing:>>> "gg" in "eggs" True
n小于
0的值被视为0（产生与s ）。请注意，序列s中的项目不会被复制；它们被多次引用。这经常困扰着新的Python程序员；考虑：>>> lists = [[]] * 3 >>> lists [[], [], []] >>> lists[0].append(3) >>> lists [[3], [3], [3]]
发生的事情是
[[]]是包含空列表的单元素列表，所以[[]] * tt> 3是对单个空列表的引用。修改lists都会修改此单个列表。您可以通过以下方式创建不同列表的列表：>>> lists = [[] for i in range(3)] >>> lists[0].append(3) >>> lists[1].append(5) >>> lists[2].append(7) >>> lists [[3], [5], [7]]
有关详细说明，请参阅常见问题解答条目如何创建多维列表?。
If i or j is negative, the index is relative to the end of the string:
len(s) + iorlen(s) + jis substituted. 但请注意，-0仍然是0。The slice of s from i to j is defined as the sequence of items with index k such that
i <= k < j. 如果i或j大于len(s)，请使用len(s)。如果省略i或None，请使用0。如果省略j或None，请使用len(s)。如果i大于或等于j，则切片为空。The slice of s from i to j with step k is defined as the sequence of items with index
x = i + n*ksuch that0 <= n < (j-i)/k. In other words, the indices arei,i+k,i+2*k,i+3*kand so on, stopping when j is reached (but never including j). 如果i或j大于len(s)，请使用len(s)。如果省略i或j或None，它们将变成“结束”值（其结束取决于k < T4>）。请注意，k不能为零。如果k为None，则将其视为1。串联不可变序列总是会产生一个新对象。这意味着通过重复串联构建序列在总序列长度中将具有二次运行成本。要获得线性运行时成本，您必须切换到以下选项之一：
- 如果连接
str对象，则可以构建列表并在末尾使用str.join()，否则写入io.StringIO实例并在完成时检索其值 - if concatenating
bytesobjects, you can similarly usebytes.join()orio.BytesIO, or you can do in-place concatenation with abytearrayobject.bytearrayobjects are mutable and have an efficient overallocation mechanism - 如果串联
tuple对象，请改为扩展list - 对于其他类型，请查看相关的类文档
- 如果连接
一些序列类型（如
range）仅支持遵循特定模式的项目序列，因此不支持序列连接或重复。x在s中找不到
index会引发ValueError。支持时，index方法的附加参数允许有效地搜索序列的子部分。传递额外的参数大致相当于使用s[i:j].index(x)，只是不复制任何数据并且返回的索引是相对于序列的开始而不是开始切片。
4.6.2.不可变序列类型¶
对于不可变序列类型通常实现的唯一操作也不能通过可变序列类型实现，这是对hash()内置的支持。
此支持允许将不可变序列（如tuple实例）用作dict键并存储在set和frozenset
尝试散列包含不可取值的不可变序列将导致TypeError。
4.6.3.可变序列类型¶
下表中的操作定义在可变序列类型上。提供collections.abc.MutableSequence ABC是为了更容易在自定义序列类型上正确实现这些操作。
In the table s is an instance of a mutable sequence type, t is any iterable object and x is an arbitrary object that meets any type and value restrictions imposed by s (for example, bytearray only accepts integers that meet the value restriction 0 <= x <= 255).
| 操作 | 结果 | 笔记 |
|---|---|---|
s[i] = x | s的项目i被替换为x | |
s[i:j] = t | 从i到j的s片段被可迭代的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) 或 s += t | extends s with the contents of t (for the most part the same as s[len(s):len(s)] = t) | |
s *= n | 更新s，其内容重复n次 | （6） |
s.insert(i, x) | inserts x into s at the index given by i (same as s[i:i] = [x]) | |
s.pop([i]) | 在i中检索该项目，并将其从s中删除 | （2） |
s.remove(x) | remove the first item from s where s[i] == x | （3） |
s.reverse() | 反转s的项目 | （4） |
笔记：
t的长度必须与正在替换的切片长度相同。
可选参数i默认为
-1，因此默认情况下最后一项将被删除并返回。x在s中找不到
remove会引发ValueError。在逆向大序列时，
reverse()方法修改空间节约的序列。要提醒用户它是以副作用方式运行的，它不会返回相反的顺序。包括
clear()和copy()以便与不支持切片操作的可变容器（例如dict和set版本3.3新增：
clear()和copy()方法。值n是一个整数或实现
__index__()的对象。n的零和负值清除序列。序列中的项目不会被复制；它们被多次引用，如Common Sequence Operations中s * n>。
4.6.4.列表¶
列表是可变序列，通常用于存储同类项目的集合（其中精确的相似度因应用程序而异）。
- class
list([iterable])¶ 列表可以用几种方式构建：
- 用一对方括号表示空列表：
[] - 使用方括号，用逗号分隔项目
[a],[a, b, c] - 使用列表推导式：
[x for x in iterable] - 使用类型构造函数：
list()或list(iterable)
构造器会建立一个和iterable同样顺序和元素的列表.iterable可以是序列，支持迭代的容器或迭代器对象。如果iterable已经是一个列表，那么会创建并返回一个副本，类似于
iterable[:]。例如，list('abc')返回['a'， 'b'， 'c'] t>>和list （1，2，3） t11>）返回[1， 2， 3]。如果没有给出参数，构造函数会创建一个新的空列表[]。许多其他操作也会产生列表，包括
sorted()内置。列出所有的common和mutable序列操作。列表还提供了以下附加方法：
sort(*, key=None, reverse=None)¶此方法仅使用元素之间的
<比较对列表进行原地排序。异常不会被抑制 - 如果任何比较操作失败，整个排序操作将失败（并且列表可能会保持部分修改状态）。sort()接受只能通过关键字（仅限关键字的参数）传递的两个参数：key指定用于从每个列表元素（例如，
key=str.lower）提取比较键的一个参数的函数。与列表中的每个项目相对应的键将被计算一次，然后用于整个排序过程。None的默认值意味着列表项目直接排序而不计算单独的键值。functools.cmp_to_key()实用程序可用于将2.x样式的cmp函数转换为键函数。反向是一个布尔值。如果设置为
True，那么列表中元素反过来比较来排序。这种方法在排序大序列时修改空间经济的序列。为了提醒用户它以副作用的方式运行，它不会返回排序的序列（使用
sorted()显式请求一个新的排序列表实例）。sort()方法保证稳定。如果确保不会更改比较相等的元素的相对顺序，则排序是稳定的 - 这对于多次排序（例如，按部门排序，然后按薪级）进行排序很有帮助。CPython implementation detail: While a list is being sorted, the effect of attempting to mutate, or even inspect, the list is undefined. Python的C实现使得列表在持续时间内显示为空，并且如果它能够检测列表在排序过程中发生了变异，则会引发
ValueError。
- 用一对方括号表示空列表：
4.6.5.元组¶ T0>
元组是不变序列，通常用于存储异构数据的容器（例如由内置的枚举()生成的2元组）。元组还用于需要不变的同构数据序列（例如允许在set或dict实例中存储）的情况。
- class
tuple([iterable])¶ 元组可以通过多种方式构建：
- 使用一对括号来表示空元组：
() - 对单个元素的元组，结尾要有一个逗号：
a,或(a,) - 以逗号分隔元素：
a, b, cor(a, b, c) - 使用内建的
tuple()函数：tuple()或tuple(iterable)
构造函数构建一个元组，其元素与iterable的元素相同且顺序相同。iterable可以是序列，支持迭代的容器或迭代器对象。如果iterable已经是一个元组，它将不会被返回。For example,
tuple('abc')returns('a', 'b', 'c')andtuple( [1, 2, 3] )returns(1, 2, 3). 如果没有给出参数，构造函数会创建一个新的空元组()。请注意，它实际上是制作元组的逗号，而不是括号。括号是可选的，除了在空元组情况下，或者当需要避免句法歧义时。For example,
f(a, b, c)is a function call with three arguments, whilef((a, b, c))is a function call with a 3-tuple as the sole argument.元组实现了所有的common序列操作。
- 使用一对括号来表示空元组：
对于按名称访问比按索引访问更清晰的异构数据集合，collections.namedtuple()可能比简单的元组对象更合适。
4.6.6.Ranges¶
range类型表示不变的数字序列，通常用于在for循环中循环特定次数。
- class
range(stop)¶ - class
range(start, stop[, step]) 范围构造函数的参数必须是整数（内置
int或实现__ index __特殊方法的任何对象）。如果省略step参数，则默认为1。如果省略start参数，则默认为0。如果step为零，则会引发ValueError。对于正的step，range
r的内容由公式r[i] = start + step*i确定，其中i >= 0且r[i] < stop。For a negative step, the contents of the range are still determined by the formula
r[i] = start + step*i, but the constraints arei >= 0andr[i] > stop.如果
r[0]不符合值约束，范围对象将为空。范围确实支持负指数，但这些被解释为从正指数确定的序列末尾开始的索引。Range可以包含绝对值大于
sys.maxsize值，但某些函数（例如len()）可能引发OverflowError。Range示例：
>>> 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根据需要计算单个项目和子范围）。
Range对象实现了collections.abc.Sequence ABC，并提供了诸如包含测试，元素索引查找，切片和负指数支持等功能（请参阅Sequence Types — 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
使用==和!=测试范围对象是否与序列相同。也就是说，如果两个范围对象表示相同的值序列，则它们被认为是相等的。(Note that two range objects that compare equal might have different start, stop and step attributes, for example range(0) == range(2, 1, 3) or range(0, 3, 2) == range(0, 4, 2).)
在版本3.2中更改：实现序列ABC。支持切片和负指数。在恒定时间内测试int对象的成员资格，而不是迭代所有项目。
在版本3.3中更改：定义'=='和'！='以根据它们定义的值序列比较范围对象（而不是根据对象标识进行比较）。
4.7. 文本序列类型 — str¶
Python中的文本数据由str对象或strings进行处理。字符串是不可变的Unicode码点序列。字符串字面值的写法有多种方式：
- 单引号:
'允许 嵌入 "一对" 双引号'。 - 双引号:
"允许 嵌入 '一对' 单引号"。 - 三引号：
'''三个单引号'''，"""三个双引号"""。
三引号字符串可以跨越多行，引号内的空格也会包含在字符串中。
如果多个字符串字面值都是单个表达式的一个部分并且它们之间只有空格，那么它们将被隐式转换为单个字符串字面值。也就是说，("spam " "eggs") == "spam eggs"。
有关字符串面面值的各种形式，包括支持的转义序列和使大多数转义序列处理失效的r（“raw”）前缀的详细信息，请参见字符串和字节字面值。
字符串也可以使用str构造函数从其他对象创建。
由于没有单独的“字符”类型，索引字符串会生成长度为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') 返回object的字符串版本。如果未提供object，则返回空字符串。否则，
str()的行为取决于是否给出encoding或errors，如下所示。如果既不给出encoding也不给出errors，则
str(object)返回object.__str__()，即object“非正式”的或可打印字符串表示。对于字符串对象，这是字符串本身。如果object没有__str__()方法，则str()回退到返回repr(object)。如果给出encoding或errors中的至少一个，则object应该是类字节对象（即
bytes或bytearray）。在这种情况下，如果object是bytes（或bytearray）对象，则str(bytes, encoding, errors)等效于bytes.decode(encoding, errors)。否则，在调用bytes.decode()之前获取缓冲区对象下的字节对象。有关缓冲对象的信息，请参见字节序列类型 — bytes, bytearray, memoryview和Buffer Protocol。不带encoding或errors参数传递
bytes对象传递到str()属于第一种情况，即返回非正式的字符串表示（另请参阅Python的-b命令行选项）。例如：>>> str(b'Zoot!') "b'Zoot!'"
有关
str类及其方法的详细信息，请参见下面的文本序列类型 — str和字符串的方法部分。要输出格式化的字符串，请参阅Format String Syntax部分。另外，请参阅Text Processing Services部分。
4.7.1.字符串方法¶
字符串实现了所有的common序列操作，以及下面描述的其他方法。
Strings also support two styles of string formatting, one providing a large degree of flexibility and customization (see str.format(), Format String Syntax and Custom String Formatting) and the other based on C printf style formatting that handles a narrower range of types and is slightly harder to use correctly, but is often faster for the cases it can handle (printf-style String Formatting).
标准库的Text Processing Services部分涵盖了许多其他模块，这些模块提供各种文本相关实用程序（包括re模块中的正则表达式支持）。
str.capitalize()¶返回字符串的一个副本，其首字母大写，其余的小写。
str.casefold()¶返回字符串的casefolded副本。可折叠的字符串可用于无外壳匹配。
Casefolding与lowercasing类似，但更具侵略性，因为它旨在删除字符串中的所有大小写区别。例如，德语小写字母
'ß'等同于"ss"。Since it is already lowercase,lower()would do nothing to'ß';casefold()converts it to"ss".Unicode标准的第3.13节描述了casefolding算法。
版本3.3中的新功能。
str.center(width[, fillchar])¶返回以长度宽度的字符串为中心。填充是使用指定的fillchar完成的（默认是ASCII空间）。The original string is returned if width is less than or equal to
len(s).
-
str.count(sub[, start[, end]])¶ 返回范围[start，end]中子字符串sub的非重叠次数。可选参数start和end被解释为切片表示法。
-
str.encode(encoding="utf-8", errors="strict")¶ 以字节对象的形式返回字符串的编码版本。默认编码为
'utf-8'。可能会给出错误来设置不同的错误处理方案。错误的缺省值是'strict'，这意味着编码错误会引发一个UnicodeError。其他可能的值是'ignore'，'replace'，'xmlcharrefreplace'，'backslashreplace'以及其他任何可能的值通过codecs.register_error()注册的名称，请参见Error Handlers部分。有关可能的编码列表，请参见Standard Encodings部分。在版本3.1中更改：添加了对关键字参数的支持。
str.endswith(suffix[, start[, end]])¶如果字符串以指定的suffix结尾则返回
True，否则返回False。后缀也可以是要查找的后缀元组。使用可选的start，从该位置开始测试。使用可选的结束，停止在该位置进行比较。
str.expandtabs(tabsize=8)¶返回字符串的副本，其中所有制表符由一个或多个空格替换，具体取决于当前列和给定制表符大小。每个tabsize字符都会出现制表符位置（默认值为8，在列0,8,16等处提供制表位置）。要扩展字符串，当前列设置为零，字符串逐个检查。如果该字符是一个制表符（
\t），则在结果中插入一个或多个空格字符，直到当前列等于下一个制表符位置。（制表符本身不被复制。）如果该字符是换行符（\n）或返回（\r），则会将其复制并将当前列重置为零。任何其他字符都将被不变地复制，而当前列增加1，无论打印时字符如何表示。>>> '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。
str.format(*args, **kwargs)¶执行字符串格式化操作。调用此方法的字符串可以包含由大括号
{}分隔的文本文本或替换字段。每个替换字段包含位置参数的数字索引或关键字参数的名称。返回字符串的副本，其中每个替换字段将替换为相应参数的字符串值。>>> "The sum of 1 + 2 is {0}".format(1+2) 'The sum of 1 + 2 is 3'
有关可以在格式字符串中指定的各种格式选项的说明，请参阅Format String Syntax。
str.format_map(mapping)¶与
str.format(**mapping)类似，除了直接使用mapping并且不复制到dict。如果例如mapping是字典子类，这很有用：>>> 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。A character
cis alphanumeric if one of the following returnsTrue:c.isalpha(),c.isdecimal(),c.isdigit(), orc.isnumeric().
str.isalpha()¶如果字符串中的所有字符都是字母并且至少有一个字符，则返回true，否则返回false。字母字符是在Unicode字符数据库中定义为“Letter”的那些字符，即具有一般类别属性为“Lm”，“Lt”，“Lu”，“Ll”或“Lo”之一的那些字符。请注意，这与Unicode标准中定义的“字母”属性不同。
str.isdecimal()¶如果字符串中的所有字符都是十进制字符并且至少有一个字符，则返回true，否则返回false。十进制字符是来自一般类别“Nd”的字符。该类别包括数字字符和可用于形成十进制小数数字的所有字符，例如U + 0660，阿拉伯数字ZERO。
str.isdigit()¶如果字符串中的所有字符都是数字，并且至少有一个字符，则返回真，否则返回假。数字包含需要特殊处理的十进制字符和数字，例如兼容性上标数字。形式上，数字是具有属性值Numeric_Type = Digit或Numeric_Type = Decimal的字符。
str.isidentifier()¶根据语言定义Identifiers and keywords，如果字符串是有效标识符，则返回true。
使用
keyword.iskeyword()来测试保留的标识符，例如def和class。
str.isnumeric()¶如果字符串中的所有字符都是数字字符，并且此字符串至少有一个字符（译者注：非空），则返回true，否则返回false。数字字符包括数字字符和具有Unicode数字值属性的所有字符，例如U + 2155，VULGAR FRACTION ONE FIFTH。形式上，数字字符是具有属性值Numeric_Type = Digit，Numeric_Type = Decimal或Numeric_Type = Numeric的字符。
str.isprintable()¶如果字符串中的所有字符都可打印或字符串为空，则返回true，否则返回false。非可打印字符是在Unicode字符数据库中定义为“Other”或“Separator”的字符，但ASCII空格（0x20）被认为是可打印的。（请注意，在此上下文中的可打印字符是在字符串上调用
repr()时不应该转义的字符。它对写入sys.stdout或sys.stderr的字符串的处理没有任何影响。）
str.isspace()¶如果字符串中只有空格字符，并且至少有一个字符，则返回true，否则返回false。空格字符是在Unicode字符数据库中定义为“其他”或“分隔符”并且具有双向属性为“WS”、“B”或“S”之一的那些字符。
str.istitle()¶如果字符串是一个标题字符串并且至少有一个字符，则返回true，例如，大写字符只能跟在未写入的字符之后，而小写字母只能在已封装的字符之后。否则返回false。
str.join(iterable)¶返回一个字符串，它是iterable 可迭代中字符串的串联。如果iterable中包含
bytes对象中存在任何非字符串值，则会引发TypeError。元素之间的分隔符是提供此方法的字符串。
str.ljust(width[, fillchar])¶以长度宽度的字符串将字符串左对齐。填充是使用指定的fillchar完成的（默认是ASCII空间）。The original string is returned if width is less than or equal to
len(s).
str.lstrip([chars])¶返回删除前导字符的字符串的副本。chars参数是一个字符串，用于指定要删除的字符集。如果省略或
None，chars参数默认为删除空白。字符参数不是前缀；相反，其值的所有组合都被剥离：>>> ' spacious '.lstrip() 'spacious ' >>> 'www.example.com'.lstrip('cmowz.') 'example.com'
- static
str.maketrans(x[, y[, z]])¶ 这个静态方法返回一个可用于
str.translate()的转换表。如果只有一个参数，它必须是一个将Unicode序数（整数）或字符（长度为1的字符串）映射到Unicode序号，字符串（任意长度）或None的字典。字符键将被转换为序号。
如果有两个参数，它们必须是等长的字符串，并且在结果字典中，x中的每个字符将映射到y中相同位置的字符。如果有第三个参数，它必须是一个字符串，在结果中这些字符将被映射到“None”。
str.partition(sep)¶在第一次出现sep时分割字符串，并返回包含分隔符之前的部分，分隔符本身和分隔符之后的部分的3元组。如果未找到分隔符，则返回包含该字符串本身的三元组，然后返回两个空字符串。
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])¶以长度宽度的字符串返回右对齐的字符串。填充是使用指定的fillchar完成的（默认是ASCII空间）。The original string is returned if width is less than or equal to
len(s).
str.rpartition(sep)¶在最后出现的sep处拆分字符串，并返回包含分隔符之前的部分，分隔符本身和分隔符之后的部分的3元组。如果未找到分隔符，则返回包含两个空字符串的三元组，然后返回字符串本身。
str.rsplit(sep=None, maxsplit=-1)¶在字符串中，使用sep作为分隔符分割字符串，返回分割后的列表。如果给出maxsplit，则最多maxsplit分割完成，最右边个分割。如果未指定sep或
None，则任何空格字符串都是分隔符。除了从右边分割外，rsplit()的行为与split()的行为类似，下面详细介绍。
str.rstrip([chars])¶返回删除了尾随字符的字符串副本。chars参数是一个字符串，用于指定要删除的字符集。如果省略或
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']）。用指定的分隔符分割空字符串会返回['']。例如：
>>> '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])¶ 返回字符串中行的列表，在行边界处突破。换行符不包含在结果列表中，除非给出keepends且为true。
此方法分割在以下行边界上。特别是，边界是universal newlines的超集。
表示 描述 \n换行 \r回车 \r\n回车+换行 \v或\x0b线条制表 \f或\x0c表单Feed \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']
与给定分隔符字符串sep时的
split()不同，此方法返回空字符串的空列表，并且终端行分隔符不会导致额外的行：>>> "".splitlines() [] >>> "One line\n".splitlines() ['One line']
For comparison,
split('\n')gives:>>> ''.split('\n') [''] >>> 'Two lines\n'.split('\n') ['Two lines', '']
str.startswith(prefix[, start[, end]])¶如果字符串以prefix开头则返回
True，否则返回False。前缀也可以是要查找的前缀元组。使用可选的start，测试字符串从该位置开始。使用可选的结束，停止在该位置比较字符串。
-
str.strip([chars])¶ 返回删除前导字符和尾随字符的字符串副本。chars参数是一个字符串，用于指定要删除的字符集。如果省略或
None，chars参数默认为删除空白。chars参数不是前缀或后缀；相反，其值的所有组合都被剥离：>>> ' 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)[0].upper() + ... mo.group(0)[1:].lower(), ... 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]转换为大写字符。Note that
str.upper().isupper()might beFalseifscontains uncased characters or if the Unicode category of the resulting character(s) is not “Lu” (Letter, uppercase), but e.g. “Lt”（Letter，titlecase）。Unicode标准的第3.13节描述了使用的大写算法。
str.zfill(width)¶返回左侧填充有ASCII
'0'位的字符串的副本，以生成长度宽度的字符串。前导符号前缀（'+'/'-'）通过在符号字符后面插入填充符来处理，而不是在之前。The original string is returned if width is less than or equal tolen(s).例如：
>>> "42".zfill(5) '00042' >>> "-42".zfill(5) '-0042'
4.7.2. printf风格的字符串格式化¶
注意
这里描述的格式化操作表现出各种各样的怪癖，导致许多常见错误（如未能正确显示元组和字典）。使用新的str.format()接口有助于避免这些错误，并且还提供了一种通用的功能更强大，灵活且可扩展的文本格式化方法。
字符串对象有一个独特的内建操作：%操作符（取模）。这也被称为字符串formatting或插值运算符。给定format % values （其中format是一个字符串），format中的%转换说明被values的零个或多个元素替换。其效果与在C语言中使用sprintf()类似。
如果格式需要单个参数，则值可能是单个非元组对象。[5] Otherwise, values must be a tuple with exactly the number of items specified by the format string, or a single mapping object (for example, a dictionary).
转换说明符包含两个或多个字符，并具有以下组件，它们必须按以下顺序出现：
'%'字符表示说明符的开始。- 映射键（可选），由括号括起来的字符序列（例如，
(somename)）组成。 - 转换标志（可选），影响某些转换类型的结果。
- 最小字段宽度（可选）。如果指定为
'*'（星号），则实际宽度将从值中的元组的下一个元素中读取，并且要转换的对象位于最小字段宽度和可选精度。 - 精度（可选），作为
'.'给出（点），然后是精度。如果指定为'*'（星号），则从values中的元组的下一个元素读取实际精度，并且要转换的值在精度之后。 - 长度修饰符（可选）。
- 转换类型。
当右侧参数是一个字典（或其它映射类型）时，那么字符串中的formats必须包含一个圆括号括起来的映射到那个字典的键，并紧接在'%'字符之后。映射键从映射中选择要格式化的值。例如：
>>> print('%(language)s has %(number)03d quote types.' %
... {'language': "Python", "number": 2})
Python has 002 quote types.
在这种情况下format中不可以出现*指示符（因为它们需要一个序列参数的列表）。
转换标志字符是：
| 旗 | 含义 |
|---|---|
'#' | 值转换将使用“替代形式”（如下定义）。 |
'0' | 对于数值，转换将用零填充。 |
'-' | 转换的值被左调整（如果给出两者，则覆盖'0'转换标志）。 |
' ' | （空格）空白应留在由有符号转换产生的正数（或空字符串）之前。 |
'+' | 将在转换说明之前加上符号字符（'+'或'-'）（覆盖“空格”标志）。 |
长度修饰符（h，l或L）可能会出现，但会被忽略，因为它对Python不是必需的 - 例如，%ld与%d完全相同。
转换类型是：
| 转变 | 含义 | 笔记 |
|---|---|---|
'd' | 带符号的整数小数。 | |
'i' | 带符号的整数小数。 | |
'o' | 签署八进制值。 | （1） |
'u' | 已过时的类型 - 与'd'完全相同。 | （7） |
'x' | 签名的十六进制（小写）。 | （2） |
'X' | 签名的十六进制（大写）。 | （2） |
'e' | 浮点指数格式（小写）。 | （3） |
'e' | 浮点指数格式（大写）。 | （3） |
'f' | 浮点十进制格式。 | （3） |
'F' | 浮点十进制格式。 | （3） |
'g' | 浮点格式。如果指数小于-4或小于精度，则使用小写指数格式，否则使用小数格式。 | （4） |
'g' | 浮点格式。如果指数小于-4或者不小于精度，则使用大写指数格式，否则使用小数格式。 | （4） |
'c' | 单个字符（接受整数或单个字符串）。 | |
'r' | 字符串（使用repr()转换任何Python对象）。 | （5） |
's' | String（使用str()转换任何Python对象）。 | （5） |
'a' | 字符串（使用ascii()转换任何Python对象）。 | （5） |
'%' | 没有参数被转换，导致结果中有一个'%'字符。 |
笔记：
替代形式造成左侧填充零 (
'0') ，且数字的格式，如果结果的前导字符插入不是零。替代形式导致
'0x'或'0X'（取决于'x'或'X'替代形式会导致结果始终包含小数点，即使没有数字跟着它。
精度决定小数点后的位数，默认为6。
替代形式使结果总是包含小数点，在其他情况下会删除的尾随零不会被删除。
精度决定小数点前后的有效位数，默认值为6。
如果precision
N，则输出将被截断为N个字符。
- 参见 PEP 237。
由于Python字符串具有明确的长度，因此%s转换不会假定'\0'是字符串的结尾。
在版本3.1中进行了更改：绝对值超过1e50的数字不再被%g转换所取代。 %f
4.8. 二进制序列类型 — bytes、bytearray、memoryview ¶
用于处理二进制数据的核心内置类型是bytes和bytearray。它们由memoryview支持，它使用buffer protocol访问其他二进制对象的内存，而无需进行复制。
array模块支持基本数据类型（如32位整数和IEEE754双精度浮点值）的高效存储。
4.8.1.Bytes¶
字节对象是字节组成的不可变序列。由于许多主要的二进制协议都基于ASCII文本编码，因此字节对象提供了几种方法，这些方法仅在使用ASCII兼容数据时有效，并且在许多方面与字符串对象非常相似。
首先，除了添加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兼容通常会导致数据损坏）。
除了字面值形式之外，字节对象还可以通过其他方式创建：
- 一个指定长度的用零填充字节对象：
bytes(10) - 从一个整数可迭代对象：
bytes(range(20)) - 通过缓冲区协议复制现有的二进制数据：
bytes(obj)
另请参阅内置的bytes。
由于2个十六进制数字精确地对应于单个字节，所以十六进制数字是用于描述二进制数据的通常使用的格式。因此，字节类型具有额外的类方法来读取该格式的数据：
- classmethod
bytes.fromhex(string)¶ 这个
bytes类方法返回一个字节对象，解码给定的字符串对象。该字符串必须包含每个字节两个十六进制数字，忽略ASCII空格。>>> bytes.fromhex('2Ef0 F1f2 ') b'.\xf0\xf1\xf2'
存在反向转换函数将字节对象转换为其十六进制表示形式。
bytes.hex()¶返回一个字符串对象，在实例中每个字节包含两个十六进制数字。
>>> b'\xf0\xf1\xf2'.hex() 'f0f1f2'
版本3.5中的新功能。
由于字节对象是整数序列（类似于元组），对于字节对象b，b[0]将是一个整数，而b[0:1]将是一个长度为1的字节对象。（这与文本字符串形成对比，其中索引和切片将产生长度为1的字符串）
字节对象的表示使用字面格式（b'...'），因为它通常比实例更有用。字节（[46， 46， 46]）。您总是可以使用list(b)将字节对象转换为整数列表。
注意
对于Python 2.x用户：在Python 2.x系列中，允许在8比特字符串（2.x提供的最接近内置二进制数据类型的东西）和Unicode字符串之间进行各种隐式转换。这是一个向后兼容的解决方法，以说明Python最初只支持8位文本，而Unicode文本是后来的补充。在Python 3.x中，这些隐式转换消失了 - 8位二进制数据和Unicode文本之间的转换必须是明确的，而字节和字符串对象总是会比较不等。
4.8.2.Bytearray 对象¶
bytearray对象是bytes对象的可变对象。对于bytearray对象没有专用的字面值语法，而是总是通过调用构造函数创建的：
- 创建一个空实例：
bytearray() - 创建一个给定10个字节长度的零填充实例：
bytearray(10) - 从一个可迭代的整数对象填充数据：
bytearray(range(20)) - 通过缓冲区协议复制现有的二进制数据：
bytearray(b'Hi!')
由于bytearray对象是可变的，除了在Bytes and Bytearray Operations中描述的常见字节和字节阵列操作之外，它们还支持mutable序列操作。
另请参阅内置的bytearray。
由于2个十六进制数字精确地对应于单个字节，所以十六进制数字是用于描述二进制数据的通常使用的格式。因此，bytearray类型具有一个附加类方法来读取该格式的数据：
- classmethod
bytearray.fromhex(string)¶ 这个
bytearray类方法返回bytearray对象，解码给定的字符串对象。该字符串必须包含每个字节两个十六进制数字，忽略ASCII空格。>>> bytearray.fromhex('2Ef0 F1f2 ') bytearray(b'.\xf0\xf1\xf2')
存在一个逆转换函数将一个bytearray对象转换为十六进制表示。
bytearray.hex()¶返回一个字符串对象，在实例中每个字节包含两个十六进制数字。
>>> bytearray(b'\xf0\xf1\xf2').hex() 'f0f1f2'
版本3.5中的新功能。
由于bytearray对象是整数序列（类似于列表），对于bytearray对象b，b [0]将是整数，而b [0 ：1]将是长度为1的bytearray对象。（这与文本字符串形成对比，其中索引和切片将产生长度为1的字符串）
bytearray对象的表示使用字节字面值格式（bytearray（b'...'）），因为它通常比例如。bytearray（[46， 46， 46]）。您总是可以使用list（b）将bytearray对象转换为整数列表。
4.8.3.Bytes和Bytearray操作¶
bytes和bytearray对象都支持公共序列操作。它们不仅与相同类型的操作数互操作，而且可与任何字节状对象进行互操作。由于这种灵活性，它们可以在操作中自由混合而不引起错误。但是，结果的返回类型可能取决于操作数的顺序。
注意
字节和bytearray对象的方法不接受字符串作为它们的参数，就像字符串上的方法不接受字节作为它们的参数一样。例如，你必须写：
a = "abc"
b = a.replace("a", "f")
和：
a = b"abc"
b = a.replace(b"a", b"f")
一些字节和bytearray操作假定使用ASCII兼容的二进制格式，因此在使用任意二进制数据时应避免使用。这些限制如下。
注意
使用这些基于ASCII的操作来处理未以ASCII格式存储的二进制数据可能导致数据损坏。
字节和bytearray对象的以下方法可以与任意二进制数据一起使用。
bytes.count(sub[, start[, end]])¶bytearray.count(sub[, start[, end]])¶返回范围[开始，结束]中的子序列sub的字节对象的个数。可选参数start和end被解释为切片表示法。
要搜索的子序列可以是任何字节类对象或0到255范围内的整数。
在版本3.3中更改：还接受范围为0到255的整数作为子序列。
bytes.decode(encoding="utf-8", errors="strict")¶bytearray.decode(encoding="utf-8", errors="strict")¶从bytes对象返回一个指定解码类型的字符串。默认编码为
'utf-8'。可能会给出错误来设置不同的错误处理方案。errors的缺省值是'strict'，表示编码错误会引发一个UnicodeError。其他可能的值为'ignore'，'replace'和通过codecs.register_error()注册的任何其他名称，请参见错误处理程序。有关可能的编码列表，请参见Standard Encodings部分。在版本3.1中已更改：添加了对关键字参数的支持。
bytes.endswith(suffix[, start[, end]])¶bytearray.endswith(suffix[, start[, end]])¶如果二进制数据以指定的后缀结尾，则返回
True，否则返回False。后缀也可以是要查找的后缀元组。使用可选的start，从该位置开始测试。使用可选的结束，停止在该位置进行比较。要搜索的后缀可以是任何字节状对象。
bytes.find(sub[, start[, end]])¶bytearray.find(sub[, start[, end]])¶返回发现子序列sub的数据中的最低索引，使得sub包含在片
s [start：end]中。可选参数start和end被解释为切片表示法。如果未找到sub，则返回-1。要搜索的子序列可以是任何字节状对象或0到255范围内的整数。
在版本3.3中更改：还接受范围为0到255的整数作为子序列。
bytes.index(sub[, start[, end]])¶bytearray.index(sub[, start[, end]])¶像
find()，但是如果找不到子序列，则会引发ValueError异常。要搜索的子序列可以是任何字节状对象或0到255范围内的整数。
在版本3.3中更改：还接受范围为0到255的整数作为子序列。
bytes.join(iterable)¶bytearray.join(iterable)¶返回字节或bytearray对象，它是可迭代 可迭代中二进制数据序列的连接。译者例子:b''.join([b'a',b'b'])。如果iterable中有任何值不是bytes的对象，包括
str，则会引发TypeError对象。元素之间的分隔符是提供此方法的字节或bytearray对象的内容。
- static
bytes.maketrans(from, to)¶ - static
bytearray.maketrans(from, to)¶ 此静态方法返回可用于
bytes.translate()的翻译表，它将中的每个字符从映射到中相同位置的字符到； from和to必须都是字节状对象，并具有相同的长度。版本3.1中的新功能。
bytes.partition(sep)¶bytearray.partition(sep)¶在第一次出现sep时分割序列，并返回包含分隔符之前的部分，分隔符和分隔符后面的部分的3元组。如果找不到分隔符，则返回包含原始序列副本的3元组，后跟两个空字节或bytearray对象。
要搜索的分隔符可以是任何字节状对象。
bytes.replace(old, new[, count])¶bytearray.replace(old, new[, count])¶返回序列的副本，其中所有出现的old替换为new。如果给出可选参数count，则仅替换第一个count出现次数。
搜索和替换的子序列可以是任何字节状对象。
注意
此方法的bytearray版本不会原地操作 - 它总是产生一个新对象，即使没有进行任何更改。
bytes.rfind(sub[, start[, end]])¶bytearray.rfind(sub[, start[, end]])¶返回序列中找到子序列sub的最高索引，以使sub包含在
s [start：end]中。可选参数start和end被解释为切片表示法。失败时返回-1。要搜索的子序列可以是任何字节类对象或0到255范围内的整数。
在版本3.3中更改：还接受范围为0到255的整数作为子序列。
bytes.rindex(sub[, start[, end]])¶bytearray.rindex(sub[, start[, end]])¶与
rfind()类似，但在未找到子序列子时引发ValueError。要搜索的子序列可以是任何字节类对象或0到255范围内的整数。
在版本3.3中更改：还接受范围为0到255的整数作为子序列。
bytes.rpartition(sep)¶bytearray.rpartition(sep)¶拆分最后一次sep的序列，并返回包含分隔符之前的部分，分隔符和分隔符后面的部分的3元组。如果找不到分隔符，则返回包含原始序列副本的3元组，后跟两个空字节或bytearray对象。
要搜索的分隔符可以是任何字节状对象。
-
bytes.startswith(prefix[, start[, end]])¶ bytearray.startswith(prefix[, start[, end]])¶如果二进制数据以指定的前缀开头，则返回
True，否则返回False。前缀也可以是要查找的前缀元组。使用可选的start，从该位置开始测试。使用可选的结束，停止在该位置进行比较。要搜索的前缀可以是任何字节状对象。
-
bytes.translate(table[, delete])¶ -
bytearray.translate(table[, delete])¶ 返回字节或bytearray对象的副本，其中发生在可选参数delete中的所有字节都被删除，剩余的字节已通过给定的转换表映射，该转换表必须是长度为256的字节对象。
您可以使用
bytes.maketrans()方法来创建转换表。对于只删除字符的转换，将表参数设置为
None：>>> b'read this short text'.translate(None, b'aeiou') b'rd ths shrt txt'
以下对字节和bytearray对象的方法具有默认行为，它们假定使用ASCII兼容的二进制格式，但仍然可以通过传递适当的参数与任意二进制数据一起使用。请注意，本节中的所有bytearray方法都不会原地操作，而是生成新对象。
-
bytes.center(width[, fillbyte])¶ bytearray.center(width[, fillbyte])¶返回以长度width的序列居中的对象的副本。填充使用指定的fillbyte（默认为ASCII空格）完成。对于
字节对象，如果width小于或等于len（s），则返回原始序列。注意
此方法的bytearray版本不会原地操作 - 它总是产生一个新对象，即使没有进行任何更改。
bytes.ljust(width[, fillbyte])¶bytearray.ljust(width[, fillbyte])¶以长度width的顺序返回左对齐的对象的副本。填充使用指定的fillbyte（默认为ASCII空格）完成。对于
字节对象，如果width小于或等于len（s），则返回原始序列。注意
此方法的bytearray版本不会原地操作 - 它总是产生一个新对象，即使没有进行任何更改。
-
bytes.lstrip([chars])¶ -
bytearray.lstrip([chars])¶ 返回删除指定前导字节的序列副本。chars参数是一个二进制序列，用于指定要删除的字节值集合 - 名称是指此方法通常与ASCII字符一起使用的事实。如果省略或
None，chars参数默认为删除ASCII空格。字符参数不是前缀；相反，其值的所有组合都被剥离：>>> b' spacious '.lstrip() b'spacious ' >>> b'www.example.com'.lstrip(b'cmowz.') b'example.com'
要移除的字节值的二进制序列可以是任何bytes-like object。
注意
此方法的bytearray版本不会原地操作 - 它总是产生一个新对象，即使没有进行任何更改。
-
bytes.rjust(width[, fillbyte])¶ -
bytearray.rjust(width[, fillbyte])¶ 按照长度宽度的顺序返回右对齐的对象的副本。填充使用指定的fillbyte（默认为ASCII空格）完成。对于
字节对象，如果width小于或等于len（s），则返回原始序列。注意
此方法的bytearray版本不会原地操作 - 它总是产生一个新对象，即使没有进行任何更改。
bytes.rsplit(sep=None, maxsplit=-1)¶bytearray.rsplit(sep=None, maxsplit=-1)¶将二进制序列拆分为相同类型的子序列，使用sep作为分隔符字符串。如果给出maxsplit，则最多maxsplit分割完成，最右边个分割。如果未指定sep或
None，则任何仅由ASCII空白组成的子序列都是分隔符。除了从右边分割外，rsplit()的行为与split()的行为类似，下面详细介绍。
-
bytes.rstrip([chars])¶ -
bytearray.rstrip([chars])¶ 返回删除指定尾随字节的序列副本。chars参数是一个二进制序列，用于指定要删除的字节值集合 - 名称是指此方法通常与ASCII字符一起使用的事实。如果省略或
None，chars参数默认为删除ASCII空格。chars参数不是后缀；相反，其值的所有组合都被剥离：>>> b' spacious '.rstrip() b' spacious' >>> b'mississippi'.rstrip(b'ipz') b'mississ'
要移除的字节值的二进制序列可以是任何bytes-like object。
注意
此方法的bytearray版本不会原地操作 - 它总是产生一个新对象，即使没有进行任何更改。
bytes.split(sep=None, maxsplit=-1)¶bytearray.split(sep=None, maxsplit=-1)¶将二进制序列拆分为相同类型的子序列，使用sep作为分隔符字符串。如果给出了maxsplit并且是非负的，那么至多完成maxsplit分割（因此，列表最多将具有
maxsplit+1如果没有指定maxsplit或者-1，那么分割数量没有限制（所有可能的分割）。If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty subsequences (for example,
b'1,,2'.split(b',')returns[b'1', b'', b'2']). The sep argument may consist of a multibyte sequence (for example,b'1<>2<>3'.split(b'<>')returns[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])¶ 返回删除指定前导字节和尾随字节的副本。chars参数是一个二进制序列，用于指定要删除的字节值集合 - 名称是指此方法通常与ASCII字符一起使用的事实。如果省略或
None，chars参数默认为删除ASCII空格。chars参数不是前缀或后缀；相反，其值的所有组合都被剥离：>>> b' spacious '.strip() b'spacious' >>> b'www.example.com'.strip(b'cmowz.') b'example'
要移除的字节值的二进制序列可以是任何bytes-like object。
注意
此方法的bytearray版本不会原地操作 - 它总是产生一个新对象，即使没有进行任何更改。
字节和字节数组对象的以下方法假定使用ASCII兼容的二进制格式，不应将其应用于任意二进制数据。请注意，本节中的所有bytearray方法都不会原地操作，而是生成新对象。
bytes.capitalize()¶bytearray.capitalize()¶返回序列的一个副本，每个字节解释为一个ASCII字符，第一个字节大写，其余的小写。非ASCII字节值通过不变。
注意
此方法的bytearray版本不会原地操作 - 它总是产生一个新对象，即使没有进行任何更改。
bytes.expandtabs(tabsize=8)¶bytearray.expandtabs(tabsize=8)¶根据当前列和给定的选项卡大小，将所有ASCII选项卡字符替换为一个或多个ASCII空格的序列副本返回。每个tabsize字节都会出现制表位（默认值为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版本不会原地操作 - 它总是产生一个新对象，即使没有进行任何更改。
bytes.isalnum()¶bytearray.isalnum()¶如果序列中的所有字节均为字母ASCII字符或ASCII十进制数字，且序列不为空，则返回true，否则返回false。Alphabetic ASCII characters are those byte values in the sequence
b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'. ASCII十进制数字是序列b'0123456789'中的那些字节值。例如：
>>> b'ABCabc1'.isalnum() True >>> b'ABC abc1'.isalnum() False
bytes.isalpha()¶bytearray.isalpha()¶如果序列中的所有字节均为字母ASCII字符且序列不为空，则返回true，否则返回false。Alphabetic ASCII characters are those byte values in the sequence
b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.例如：
>>> b'ABCabc'.isalpha() True >>> b'ABCabc1'.isalpha() False
bytes.isdigit()¶bytearray.isdigit()¶如果序列中的所有字节均为ASCII十进制数字，且序列不为空，则返回true，否则返回false。ASCII十进制数字是序列
b'0123456789'中的那些字节值。例如：
>>> b'1234'.isdigit() True >>> b'1.23'.isdigit() False
bytes.islower()¶bytearray.islower()¶如果序列中至少有一个小写ASCII字符，并且没有大写ASCII字符，则返回true，否则返回false。
例如：
>>> b'hello world'.islower() True >>> b'Hello world'.islower() False
小写ASCII字符是序列中的那些字节值
b'abcdefghijklmnopqrstuvwxyz'。大写ASCII字符是序列b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'中的那些字节值。
bytes.isspace()¶bytearray.isspace()¶如果序列中的所有字节均为ASCII空格且序列不为空，则返回true，否则返回false。ASCII whitespace characters are those byte values in the sequence
b' \t\n\r\x0b\f'(space, tab, newline, carriage return, vertical tab, form feed).
bytes.istitle()¶bytearray.istitle()¶如果序列是ASCII标题并且序列不为空，则返回true，否则返回false。有关“titlecase”定义的更多详细信息，请参见
bytes.title()。例如：
>>> b'Hello World'.istitle() True >>> b'Hello world'.istitle() False
bytes.isupper()¶bytearray.isupper()¶如果序列中至少有一个大写字母ASCII字符，并且没有小写ASCII字符，则返回true，否则返回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版本不会原地操作 - 它总是产生一个新对象，即使没有进行任何更改。
bytes.splitlines(keepends=False)¶bytearray.splitlines(keepends=False)¶返回二进制序列中的行列表，以ASCII行边界为中心。此方法使用universal newlines方法来分割行。换行符不包含在结果列表中，除非给出keepends且为true。
例如：
>>> 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']
与给定分隔符字符串sep时的
split()不同，此方法返回空字符串的空列表，并且终端行分隔符不会导致额外的行：>>> 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'中的那些字节值。Unlike
str.swapcase(), it is always the case thatbin.swapcase().swapcase() == binfor the binary versions. 大小写转换在ASCII中是对称的，即使对于任意的Unicode代码点通常不是这样。注意
此方法的bytearray版本不会原地操作 - 它总是产生一个新对象，即使没有进行任何更改。
bytes.title()¶bytearray.title()¶返回二进制序列的标题版本，其中单词以大写ASCII字符开头，其余字符为小写。Uncased字节值保持不变。
例如：
>>> b'Hello world'.title() b'Hello World'
小写ASCII字符是序列中的那些字节值
b'abcdefghijklmnopqrstuvwxyz'。大写ASCII字符是序列b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'中的那些字节值。所有其他字节值都是uncased。该算法使用简单的与语言无关的单词作为连续字母组的定义。该定义在许多情况下都有效，但这意味着收缩和占有者中的撇号会形成单词边界，这可能不是理想的结果：
>>> 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版本不会原地操作 - 它总是产生一个新对象，即使没有进行任何更改。
4.8.4. printf -style字节格式¶
注意
这里描述的格式化操作表现出各种各样的怪癖，导致许多常见错误（如未能正确显示元组和字典）。如果要打印的值可能是元组或字典，请将其包装在一个元组中。
字节对象（bytes / bytearray）有一个独特的内置操作：%运算符（模数）。这也被称为字节格式或插值运算符。Given format % values (where format is a bytes object), % conversion specifications in format are replaced with zero or more elements of values. 其效果与在C语言中使用sprintf()类似。
如果格式需要单个参数，则值可能是单个非元组对象。[5] Otherwise, values must be a tuple with exactly the number of items specified by the format bytes object, or a single mapping object (for example, a dictionary).
转换说明符包含两个或多个字符，并具有以下组件，它们必须按以下顺序出现：
'%'字符表示说明符的开始。- 映射键（可选），由括号括起来的字符序列（例如，
(somename)）组成。 - 转换标志（可选），影响某些转换类型的结果。
- 最小字段宽度（可选）。如果指定为
'*'（星号），则实际宽度将从值中的元组的下一个元素中读取，并且要转换的对象位于最小字段宽度和可选精度。 - 精度（可选），作为
'.'给出（点），然后是精度。如果指定为'*'（星号），则从values中的元组的下一个元素读取实际精度，并且要转换的值在精度之后。 - 长度修饰符（可选）。
- 转换类型。
如果右参数是一个字典（或其他映射类型），那么字节对象中的格式必须在'%'之后插入该字典中的括号映射键。 >字符。映射键从映射中选择要格式化的值。例如：
>>> print(b'%(language)s has %(number)03d quote types.' %
... {b'language': b"Python", b"number": 2})
b'Python has 002 quote types.'
在这种情况下format中不可以出现*指示符（因为它们需要一个序列参数的列表）。
转换标志字符是：
| 旗 | 含义 |
|---|---|
'#' | 值转换将使用“替代形式”（如下定义）。 |
'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)）转换任何Python对象。 | （5） |
'r' | 'r'是'a'的别名，只能用于Python2 / 3代码库。 | （7） |
'%' | 没有参数被转换，导致结果中有一个'%'字符。 |
笔记：
替代形式造成左侧填充零 (
'0') ，且数字的格式，如果结果的前导字符插入不是零。替代形式导致
'0x'或'0X'（取决于'x'或'X'替代形式会导致结果始终包含小数点，即使没有数字跟着它。
精度决定小数点后的位数，默认为6。
替代形式使结果总是包含小数点，在其他情况下会删除的尾随零不会被删除。
精度决定小数点前后的有效位数，默认值为6。
如果precision
N，则输出将被截断为N个字符。b'%s'is deprecated, but will not be removed during the 3.x series.b'%r'is deprecated, but will not be removed during the 3.x series.参见 PEP 237。
注意
此方法的bytearray版本不会原地操作 - 它总是产生一个新对象，即使没有进行任何更改。
也可以看看
版本3.5中的新功能。
4.8.5. 内存视图¶
memoryview objects allow Python code to access the internal data of an object that supports the buffer protocol without copying.
- class
memoryview(obj)¶ 创建引用obj的
memoryview。obj must support the buffer protocol. 支持缓冲协议的内置对象包括bytes和bytearray。一个
memoryview具有元素的概念，它是由原始对象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模块的本机格式说明符之一，则还支持使用整数或整数元组进行索引，并返回一个元素 t6>正确的类型。一维记忆体视图可以用一个整数或一个整数元组索引。多维内存视图可以用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]
如果底层对象是可写的，则内存视图支持一维切片分配。不允许调整大小：
>>> 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”的可哈希（只读）类型的一维记忆视图也是可散列的。散列被定义为
散列（m） == 散列（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中更改：一维memoryviews现在可以切片。格式为'B'，'b'或'c'的一维记忆体现在是可散列的。
版本3.4中更改： memoryview现在通过
collections.abc.Sequence自动注册版本3.5中的变化：现在可以使用整数元组将索引编入索引。
memoryview有几种方法：__eq__(exporter)¶如果一个memoryview和一个 PEP 3118导出器的形状是相同的，并且所有对应的值在操作数各自的格式代码使用
structFor the subset of
structformat strings currently supported bytolist(),vandware equal ifv.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
Note that, as with floating point numbers,
v is wdoes not implyv == wfor memoryview objects.在版本3.3中进行了更改：以前的版本比较了不考虑项目格式和逻辑阵列结构的原始内存。
tobytes()¶以字节串形式返回缓冲区中的数据。这相当于在memoryview上调用
bytes构造函数。>>> m = memoryview(b"abc") >>> m.tobytes() b'abc' >>> bytes(m) b'abc'
对于非连续数组，结果等于所有元素转换为字节的展平列表表示。
tobytes()supports all format strings, including those that are not instructmodule syntax.
hex()¶返回包含缓冲区中每个字节的两个十六进制数字的字符串对象。
>>> m = memoryview(b"abc") >>> m.hex() '616263'
版本3.5中的新功能。
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]
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])¶将内存视图转换为新的格式或形状。shape默认为
[byte_length//new_itemsize]，这意味着结果视图将是一维的。返回值是一个新的内存视图，但缓冲区本身未被复制。支持的转换为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 / 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 /字节转换为3D /整数至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中的新功能。
在版本3.5中更改：转换为字节视图时，源格式不再受到限制。
还有几个只读属性可用：
-
obj¶ 内存视图的基础对象：
>>> 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模块样式）的字符串。内存视图可以从具有任意格式字符串的出口商创建，但是一些方法（例如，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¶ 一个整数，指示内存所代表的多维数组的维数。
suboffsets¶在内部用于PIL风格的阵列。该值仅供参考。
-
c_contiguous¶ 指示内存是否为C- contiguous的布尔值。
版本3.3中的新功能。
-
f_contiguous¶ 指示内存是否为Fortran contiguous的bool。
版本3.3中的新功能。
-
contiguous¶ 指示内存是否contiguous的bool。
版本3.3中的新功能。
4.9.集合类型 — set, frozenset¶
集合对象是一个由互不相同的hashable对象组成的无序集合。常见用途包括成员资格测试，删除序列中的重复项，以及计算数学运算，如交集，联合，差异和对称差异。（对于其他容器，请参阅内置的dict，list和tuple类以及collections模块。 ）
像其他集合, sets 支持 x in set, len(set), 和 for x in set. 作为无序集合，集合不会记录元素位置或插入顺序。因此，集合不支持索引，切片或其他类序列行为。
目前有两种内置集合类型，set和frozenset。set类型是可变的 - 可以使用像add()和remove()这样的方法更改内容。由于它是可变的，因此它没有散列值，不能用作字典键或另一个集的元素。frozenset类型是不可变的，可哈希的 - 其内容创建后不能更改；它因此可以用作字典键或作为另一个集合的元素。
除了使用set构造函数外，还可以通过在大括号中放置逗号分隔的元素列表来创建非空的集合（不是frozensets），例如：{'jack'， 'sjoerd'} ，
这两个类的构造函数都是一样的：
- class
set([iterable])¶ - class
frozenset([iterable])¶ 返回其元素取自iterable的新集或冻结集对象。一个集合的元素必须是hashable。为了表示集合集合，内部集合必须是
frozenset对象。如果未指定iterable，则返回一个新的空集。len(s)返回集合 s 的元素个数（即s的基数）
x in s中返回x 是否 是 s的元素.
x not in s返回x 是否 不是 s的元素.
isdisjoint(other)¶如果该集合中任何一个元素都与另一个集合other中的任何一个元素都不一样（即两集合不相交），则返回
True。当且仅当两集合的交集为空集时，这两个集合不相交
issubset(other)¶set <= other测试集合中的每个元素是否在其他中。
set < other测试该集合是否是other的一个子集，即
set <= 其他 和 set ！= 其他。
issuperset(other)¶set >= other测试other中的每个元素是否在集合中。
set > other测试集合是否是other，即
set ＆gt； = 其他 和 set ！= 其他。
union(other, ...)¶set | other | ...用集合中的元素和所有其他元素返回一个新集合。
intersection(other, ...)¶set & other & ...返回一个新集合，其中包含该集合和其他所有元素共有的元素。
difference(other, ...)¶set - other - ...返回集合中不包含其他元素的新集合。
symmetric_difference(other)¶set ^ other返回集合中的元素或其他中的元素，但不能同时返回。
copy()¶用s的浅拷贝返回一个新集合。
Note, the non-operator versions of
union(),intersection(),difference(), andsymmetric_difference(),issubset(), andissuperset()methods will accept any iterable as an argument. 相反，他们的基于操作符号的对等体需要它们的参数是集合。This precludes error-prone constructions likeset('abc') & 'cbs'in favor of the more readableset('abc').intersection('cbs').既可以将
set和frozenset支持集设置为比较。当且仅当每个集合中的每个元素都包含在另一个中（每个元素是另一个的子集）时，两个集合是相等的。当且仅当第一组是第二组的合适子集（是子集，但不相等）时，集合小于另一集合。当且仅当第一个集合是第二个集合的适当超集（是超集，但不相等）时，集合比另一集合大。set的实例将根据其成员与frozenset的实例进行比较。For example,set('abc') == frozenset('abc')returnsTrueand so doesset('abc') in set([frozenset('abc')]).子集和等式比较不推广到总排序函数。For example, any two nonempty disjoint sets are not equal and are not subsets of each other, so all of the following return
False:a<b,a==b, ora>b.由于集合只定义了部分排序（子集关系），所以
list.sort()方法的输出对于集合列表是未定义的。设置元素，如字典键，必须是hashable。
将
set实例与frozenset混合的二元运算返回第一个操作数的类型。For example:frozenset('ab') | set('bc')returns an instance offrozenset.下表列出了
set不适用于frozenset的不可变实例的可用操作：update(other, ...)¶set |= other | ...更新集合，添加所有其他元素。
intersection_update(other, ...)¶set &= other & ...更新集合，只保留其中的元素和其他所有元素。
difference_update(other, ...)¶set -= other | ...更新设置，删除其他设备中的元素。
symmetric_difference_update(other)¶set ^= other更新集合，只保留任一集合中的元素，但不能同时存在于两者中。
add(elem)¶将元素elem添加到集合中。
discard(elem)¶从集合中移除元素elem，如果它存在。
clear()¶删除集合中的所有元素。
注意，
update()，intersection_update()，difference_update()和symmetric_difference_update()Note, the elem argument to the
__contains__(),remove(), anddiscard()methods may be a set. 为了支持搜索等效的冻结集，elem集在搜索过程中暂时发生变化，然后进行恢复。在搜索期间，elem集不应该被读取或者变异，因为它没有一个有意义的值。
4.10.映射类型 - dict ¶
一个mapping对象将hashable值映射到任意对象。映射是可变对象。目前只有一种标准映射类型，那就是字典。（对于其他容器，请参阅内置的列表，集合和元组类和容器模块。 ）
A dictionary’s keys are almost arbitrary values. 值是不能hashable，也就是包含列表、字典或其它可变类型的值（它们通过值而不是对象ID进行比较）不可以用作键。用于键的数字类型服从数字比较的正常规则：如果两个数字相等（如1和1.0），则它们可以互换使用以索引相同的字典条目。（但请注意，由于计算机将浮点数字存储为近似值，因此将它们用作字典键通常是不明智的。）
Dictionaries can be created by placing a comma-separated list of key: value pairs within braces, for example: {'jack': 4098, 'sjoerd': 4127} or {4098: 'jack', 4127: 'sjoerd'}, or by the dict constructor.
- class
dict(**kwarg)¶ - class
dict(mapping, **kwarg) - class
dict(iterable, **kwarg) 返回从可选的位置参数和可能为空的关键字参数集合初始化的新字典。
如果没有给出位置参数，则创建空字典。如果给出了位置参数并且它是一个映射对象，则将使用与映射对象相同的键值对创建一个字典。否则，位置参数必须是一个iterable的对象。迭代器中的每个项目本身必须是一个具有两个对象的迭代器。每个项目的第一个对象成为新字典中的一个键，第二个对象成为相应的值。如果某个键出现多次，则该键的最后一个值将成为新词典中的对应值。
如果给出关键字参数，则将关键字参数及其值添加到从位置参数创建的字典中。如果添加的键已经存在，那么来自关键字参数的值将替换位置参数中的值。
To illustrate, the following examples all return a dictionary equal to
{"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标识符的键。否则，可以使用任何有效的密钥。
这些是字典支持的操作（因此，自定义映射类型也应该支持）：
len(d)返回字典中的项目数量d。
d[key]用键键返回d的项目。如果键不在地图中，则引发
KeyError。如果一个dict的子类定义了一个方法
__missing__()并且键不存在，那么d[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]设置为值。
del d[key]从d中删除
d [key]。引发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(seq[, value])¶ 创建一个新字典，键来自seq且值设置为value。
fromkeys()是一个类方法，返回一个新的字典。value默认为None。
-
get(key[, default])¶ 如果 key 在字典里，返回 key 的值，否则返回 default 值。如果 default 未给出，它默认为
None，此方法永远不会引发KeyError。
popitem()¶从字典中随便删除并返回一个
(key, value)对。popitem()is useful to destructively iterate over a dictionary, as often used in set algorithms. 如果字典为空，调用popitem()会产生一个KeyError。
setdefault(key[, default])¶如果key在字典中，则返回其值。如果没有，则插入值为default的key，并返回default。default默认为
None。
update([other])¶使用其他中的键/值对更新字典，覆盖现有的键。返回
None。update()接受另一个字典对象或键/值对的迭代（作为元组或其他长度为2的迭代）。如果指定了关键字参数，则字典随后会使用这些键/值对进行更新：d.update（red = 1， blue = 2） t0 >。
当且仅当它们具有相同的
(key, value)对时，字典才会相等。其它比较(‘<’, ‘<=’, ‘>=’, ‘>’) 将引发TypeError。
另见
types.MappingProxyType可用于创建dict的只读视图。
4.10.1.字典视图对象¶
dict.keys()、dict.values() 和 dict.items() 返回的对象是视图对象。它们提供了有关字典条目的动态视图，这意味着当字典更改时，视图反映了这些更改。
字典视图可以迭代以产生它们各自的数据，并支持成员资格测试：
len(dictview)返回字典中的条目数量。
iter(dictview)返回字典中的键，值或项（表示为
（键， 值）的元组）的迭代器。键和值以非随机的任意顺序迭代，在Python实现中有所不同，并取决于字典的插入和删除历史。如果按键，值和项目视图被重复执行而不对词典进行中间修改，则项目顺序将直接对应。This allows the creation of
(value, key)pairs usingzip():pairs = zip(d.values(), d.keys()). Another way to create the same list ispairs = [(v, k) for (k, v) in d.items()].在字典中添加或删除条目时迭代视图可能会引发
RuntimeError或无法迭代所有条目。
-
x in dictview Return
Trueif x is in the underlying dictionary’s keys, values or items (in the latter case, x should be a(key, value)tuple).
按键视图像集合一样，因为它们的条目是独特且可散列的。如果所有的值都是可散列的，那么（key， value）对是唯一且可散列的，那么items视图也是set-like的。（由于条目通常不是唯一的，因此值视图不会被视为集合类。）For set-like views, all of the operations defined for the abstract base class collections.abc.Set are available (for example, ==, <, or ^).
字典视图用法的示例：
>>> 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
>>> list(keys)
['eggs', 'bacon', 'sausage', 'spam']
>>> list(values)
[2, 1, 1, 500]
>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['spam', 'bacon']
>>> # set operations
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}
>>> keys ^ {'sausage', 'juice'}
{'juice', 'sausage', 'bacon', 'spam'}
4.11.上下文管理器类型¶
Python的with语句支持由上下文管理器定义的运行时上下文的概念。这是使用一对方法实现的，该方法允许自定义用户类去定义在语句体执行前进入并且在语句结束时退出的运行时上下文。
contextmanager.__enter__()¶进入运行时上下文，返回此对象或另一个相关的运行时上下文的对象。此方法返回的值被绑定到使用此上下文管理器
with语句的as子句中的标识符上。一个返回自身的上下文管理器的例子是一个file object。文件对象从 __enter__()返回自己使得
open()作为上下文表达式被用在with语句中。管理器返回相关对象的一个例子参见
decimal.localcontext()。这些管理器将活跃的十进制上下文设置为原始的十进制上下文的副本，然后返回该副本。This allows changes to be made to the current decimal context in the body of thewithstatement without affecting code outside thewithstatement.
contextmanager.__exit__(exc_type, exc_val, exc_tb)¶退出运行时环境并返回一个布尔标志，指示是否应该抑制发生的任何异常。如果在使用语句执行
with否则，所有三个参数都是None。Returning a true value from this method will cause the
withstatement to suppress the exception and continue execution with the statement immediately following thewithstatement. 否则在该方法执行完成后异常继续传播。在执行此方法期间发生的异常将用语句替换发生在with传入的异常不应该显式重新显示 - 相反，此方法应该返回一个false值，以指示该方法已成功完成，并且不希望抑制引发的异常。这允许上下文管理代码轻松检测
__exit__()方法是否实际失败。
Python定义了几个上下文管理器来支持简单的线程同步，及时关闭文件或其他对象，并简化对活动的十进制算术上下文的操作。特定的类型没有特别对待它们的上下文管理协议的实现。有关示例，请参阅contextlib模块。
Python的generator和contextlib.contextmanager装饰器提供了实现这些协议的便捷方式。如果一个生成器函数使用contextlib.contextmanager修饰器进行修饰，它将返回一个实现必要的__enter__()和__exit__()方法，而不是由未修饰的生成器函数生成的迭代器。
请注意，Python / C API中的Python对象的类型结构中没有任何这些方法的特定插槽。想要定义这些方法的扩展类型必须提供它们作为普通的Python可访问方法。与设置运行时环境的开销相比，单个类字典查找的开销可以忽略不计。
4.12.其他内置类型¶
解释器支持几种其他类型的对象。其中大多数支持只有一个或两个操作。
4.12.1.模块¶
模块上唯一的特殊操作是属性访问：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'>。
4.12.2.类和类实例¶
4.12.3.函数¶
函数对象由函数定义创建。函数对象的唯一操作是调用它：func(argument-list)。
真的有两种类型的函数对象：内建函数和用户定义的函数。两者都支持相同的操作（来调用函数），但实现是不同的，因此不同的对象类型。
有关更多信息，请参见Function definitions。
4.12.4.方法¶ T0>
方法是使用属性表示法调用的函数。有两种风格：内置方法（如列表上的append()）和类实例方法。内置方法用支持它们的类型来描述。
如果通过实例访问方法（在类名称空间中定义的函数），则会得到一个特殊对象：一个绑定方法（也称为实例方法）对象。调用时，它会将self参数添加到参数列表中。Bound methods have two special read-only attributes: m.__self__ is the object on which the method operates, and m.__func__ is the function implementing the method. Calling m(arg-1, arg-2, ..., arg-n) is completely equivalent to calling 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'
有关更多信息，请参阅The standard type hierarchy。
4.12.5.代码对象¶
代码对象被实现用来表示“伪编译”的可执行Python代码，如函数体。它们不同于函数对象，因为它们不包含对其全局执行环境的引用。代码对象由内置的compile()函数返回，并且可以通过它们的__code__属性从函数对象中提取。另请参阅code模块。
通过将代码对象（而不是源字符串）传递给exec()或eval()内置函数，可以执行或评估代码对象。
有关更多信息，请参阅The standard type hierarchy。
4.12.6.输入对象¶
类型对象表示各种对象类型。一个对象的类型通过内建函数type()访问。类型没有特别的操作。标准模块types定义所有标准的内建类型的名称。
类型写成这样：<class 'int'>.
4.12.8. Ellipsis对象¶
这个对象通常被切片使用（参见Slicings）。它不支持特殊操作。Ellipsis对象有且只有一个，名为Ellipsis（内建的名称）。type(Ellipsis)()生成的也是这个唯一的Ellipsis实例。
它被写为Ellipsis或...。
4.12.9.NotImplemented 对象¶
当它们被要求对不支持的类型进行操作时，该对象从比较和二进制操作中返回。有关更多信息，请参见Comparisons。只有一个NotImplemented对象。type(NotImplemented)()产生单例实例。
它被写为NotImplemented。
4.12.10.布尔值¶
布尔值是两个常量对象False和True。它们被用来表示真值（尽管其他值也可以被认为是错误或真实的）。在数值上下文中（例如，当用作算术运算符的参数时），它们的行为分别与整数0和1相同。内建函数bool()可用于将任何值转换为一个布尔值，如果值可以解释为真值（见上面Truth Value Testing一节）。
它们分别写为False和True。
4.12.11.内部对象¶
有关此信息，请参阅The standard type hierarchy。它描述了堆栈框架对象，追溯对象和切片对象。
4.13.特殊属性¶
当前的实现向几个对象类型添加了一些特殊的对它们有意义的只读属性。它们其中有一些无法通过內建函数dir()检测出来。
object.__dict__¶用于存储对象（可写）属性的一个字典或映射对象。
instance.__class__¶类实例所属的类。
class.__bases__¶类对象的基类组成的元组。
definition.__name__¶类、函数、方法、描述器或生成器实例的名称。
class.__mro__¶此属性是在方法解析期间查找基类时考虑的类的元组。
class.__subclasses__()¶每个类保存一个弱引用列表到它的直接子类。此方法返回所有仍然活着的引用的列表。例：
>>> int.__subclasses__() [<class 'bool'>]
脚注
| [1] | 有关这些特殊方法的更多信息，请参阅Python参考手册（Basic customization）。 |
| [2] | As a consequence, the list [1, 2] is considered equal to [1.0, 2.0], and similarly for tuples. |
| [3] | 自解析器无法分辨操作数的类型以来，它们必须具备。 |
| [4] | （1，2，3，4）类别属性是“Lu”（Letter，大写），“Ll”（Letter，小写）或“Lt”（Letter，titlecase）之一。 |
| [5] | (1, 2) To format only a tuple you should therefore provide a singleton tuple whose only element is the tuple to be formatted. |