4.内建类型 ¶
以下各节描述内置于解释器的标准类型。
主要的内建类型有数字、序列、映射、类、实例和异常。
有些容器类是可变的。添加、删除或重新排列成员而不返回特定项的方法，不会返回容器实例本身而是返回None。
某些操作被几种对象类型支持；特别地，实际上所有对象都可以被比较，测试真值并转换为字符串（使用repr()函数或稍微不同的str()函数） 。当通过print()函数写入对象时，隐式使用后一个函数。
4.1.真值测试 ¶
任何对象都可以被测试真值、用于if或while条件中或作为下面的布尔操作的操作数。以下值被视为假：
NoneFalse任何数值类型的零，例如，
0、0.0、0j。任何空序列，例如，
"、()、[]。任何空映射，例如，
{}。用户定义的类的实例，如果该类定义一个
__bool__()或__len__()方法，当该方法返回布尔值False或整数零的时候 。[1]
所有其他值都被认为是真 —— 所以许多类型的对象总是为真。
结果为布尔值的操作和内建函数，总是返回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 | 对象的ID |
is not | 不同的对象ID |
不同类型（除了不同的数值类型），永远不会相等。此外，某些类型 （例如，函数对象） 支持只有退化比较，因为该类型的任何两个对象都是不相等的。以下的操作会使<, <=, > and >= 操作会抛出 TypeError 异常，1、使用一个复杂数值类型（complex number）与其他的内建的数值类型进行比较；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"和"inf"来表示非数字（NaN)）和正/负无穷。
Python定义
pow(0,0)和0 ** 0为1，这对于编程语言很常见。接受的数字字面值包括数字
0到9或任何Unicode等效字符（具有Nd属性的代码点）。有关
Nd属性的代码点的完整列表，请参见http://www.unicode.org/Public/8.0.0/ucd/extracted/DerivedNumericType.txt。
所有number.Real类型（int和float）还包括以下操作：
| 操作 | 结果 |
|---|---|
math.trunc(x) | x截断为Integral |
round(x[, n]) | x舍入到n数字，舍入到一半到偶数。如果省略n，它将默认为0。 |
math.floor(x) | 最大的Integral <= x |
math.ceil(x) | 最小Integral> = x |
4.4.1.整数类型的位运算¶
按位操作只对整数有意义。负数被视为其2的补码值（假设有足够的位，因此在操作期间不会发生溢出）。
二进制按位操作的优先级都低于数值运算，并高于比较运算；一元操作~具有与其他一元数字操作（+和-）相同的优先级。
此表列出按升序排列的按位运算：
| 操作 | 结果 | 注 |
|---|---|---|
x | y | x和y的按位或 | |
x ^ y | x和y的按位异或 | |
x ＆amp; y | x和y的按位与 | |
x n | x左移n位 | （1）（2） |
x >＆gt; n | x右移n位 | （1）（3） |
~x | 反转x的各个位 |
注：
- 负的移位数目是非法的并导致引发一个
ValueError。 - 由n位进行的左移等效于在没有溢出检查的情况下乘以
pow（2， n）。 - 按n位的右移位等同于在没有溢出检查的情况下除以
pow（2， n）。
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参数确定二进制补码是否用于表示整数。如果有符号是
False且给出了负整数，则会引发OverflowError。有符号的默认值为False。版本3.2中的新功能。
- classmethod
int.from_bytes(bytes, byteorder, *, signed=False)¶ 返回由给定的字节数组表示的整数。
>>> int.from_bytes(b'\x00\x10', byteorder='big') 16 >>> int.from_bytes(b'\x00\x10', byteorder='little') 4096 >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True) -1024 >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False) 64512 >>> int.from_bytes([255, 0, 0], byteorder='big') 16711680
参数bytes必须是类似字节的对象或产生字节的可迭代对象。。
byteorder参数确定用于表示整数的字节顺序。如果byteorder为
"big"，则最高有效字节位于字节数组的开头。如果byteorder为"little"，则最高有效字节位于字节数组的末尾。要请求主机系统的本机字节顺序，请使用sys.byteorder作为字节顺序值。有符号参数指示是否使用二进制补码表示整数。
版本3.2中的新功能。
4.4.3.浮点的附加方法¶
浮点类型实现自numbers.Real abstract base class。浮点数还具有以下的其它方法。
float.as_integer_ratio()¶返回一对整数（2元组），它们的比例准确地等于浮点数的原始值，且分母为正数。无穷引发
ValueError，NaNs引发OverflowError。
float.is_integer()¶如果浮点数实例有有限个整数值，则返回
False，否则返回True：>>> (-2.0).is_integer() True >>> (3.2).is_integer() False
两种方法都支持与十六进制字符串的相互转换。由于Python的浮点数内部存储为二进制数，浮点数和十进制字符串通之间的相互转化通常会有一个小的舍入误差。与此相反的是，十六进制字符串允许浮点数的精确表示和规格。这在调试时和数值工作中很有用。
float.hex()¶返回浮点数的十六进制字符串表示形式。对于有限的浮点数，这种表示形式总是包括一个前导的
p和尾部0x及指数。
- classmethod
float.fromhex(s)¶ 类方法返回由十六进制字符串s表示的float。字符串s可能有前导和尾随空格。
请注意， float.hex()是实例方法，而float.fromhex()是一个类方法。
十六进制字符串的形式为：
[sign] ['0x'] integer ['.' fraction] ['p' exponent]
可选的exponent可以为+或integer，sign和fraction是十六进制数的字符串，-是带有可选的前导符号的十进制整数。大小写不敏感，且整数或小数至少有一个十六进制数字。此语法类似于C99 标准的第6.4.4.2节中指明的语法，也类似Java 1.5起使用的语法。特别地，float.hex()的输出在C或Java代码中可作为十六进制浮点数的字面值，而且C的Double.toHexString格式的十六进制字符串或Java的%a可以被float.fromhex()接受。
注意指数是用十进制数而不是十六进制表示，并且它给出用来乘系数的2的幂。例如，十六进制的字符串3740.0表示浮点数(3 + 10./16 + 7./16**2) * 2.0**10，或0x3.a7p10：
>>> float.fromhex('0x3.a7p10')
3740.0
应用反向转换为3740.0给出了一个不同的十六进制字符串表示的相同数目：
>>> float.hex(3740.0)
'0x1.d380000000000p+11'
4.4.4.数值类型的散列¶
对于可能是不同类型的数字x和y，需要hash（x） For ease of implementation and efficiency across a variety of numeric types (including x == y时，t6> hash（y） （有关更多详细信息，请参阅__hash__()方法文档）。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的值可用于Python作为sys.hash_info的modulus属性。
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. - 如果
x = m / n 负有理数将如果结果散列为hash(x)定义为-hash(-x)。-1，请将其替换为-2。 - 特定值
sys.hash_info.inf，-sys.hash_info.inf和sys.hash_info.nan用作正无穷大的哈希值，负无穷大或nans（分别）。（所有hashable都有相同的哈希值。） - 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。
为了澄清上述规则，这里有一些示例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
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强加的任何类型和值限制的任意对象。
in和not in操作具有与比较操作相同的优先级。+（连接）和*（重复）操作具有与相应数值操作相同的优先级。
| 操作 | 结果 | 注 |
|---|---|---|
x in s | True如果s的项目等于x，则False | （1） |
x not in s | False如果s的项目等于x，否则True | （1） |
s + t | s和t的并置 | （6）（7） |
s * n or n * s | 相当于将s添加到自身n次 | （2）（7） |
s[i] | i项目s，来源0 | （3） |
s[i:j] | 从i到j的s | （3）（4） |
s[i:j:k] | slice of s from i to j with step k | （3）（5） |
len(s) | 长度s | |
min(s) | s的最小项 | |
max(s) | s的最大项目 | |
s.index（x [， i [， j]]） | 在s中（在索引i之后或索引j之前）的x | （8） |
s.count(x) | s中x的总出现次数 |
相同类型的序列也支持比较。特别地，元组和列表通过比较相应的元素进行比较。这意味着要比较结果相等，每个元素必须比较基于平等且两个序列必须具有相同的类型和相同的长度。（详情请参阅语言参考中的Comparisons。）
注：
虽然
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]]
发生的是
[[]]是包含空列表的单元素列表，因此[[]] *的所有三个元素 3是对此单个空列表的引用。修改lists的任何元素都修改这个列表。你可以用下面的方式创建一个包含不同列表的列表：>>> lists = [[] for i in range(3)] >>> lists[0].append(3) >>> lists[1].append(5) >>> lists[2].append(7) >>> lists [[3], [5], [7]]
有关详细说明，请参阅常见问题解答条目How do I create a multidimensional list?。
如果i或j是负值，该索引是相对于字符串结尾的值：用
len(s) + i或len(s) + j取代。但请注意0仍然是-0。s从i到j的切片定义为索引为k项组成的序列，其中
i < = k < j。如果i或j大于len(s)，则使用len(s)。如果i省略或为None，则使用0。如果j省略或为None，则使用len(s)。如果i大于或等于j，则切片为空。s从i到i步长为k的切片定义为索引
x = i + n*k的项组成的序列，其中0 <= n < (j-i)/k。换句话说，索引是i+k、i+3*k、i、i+2*k等等，在到达j（但不包括j）时停止。如果i或j大于len(s)，则使用len(s)。如果i或j省略或为None，那么它们是"终点"值（哪一端取决于标志k）。请注意，k不能为零。如果k是None，它被视为1。连接不可变序列总是导致一个新的对象。这意味着通过重复级联构建序列将在总序列长度中具有二次运行时成本。要获得线性运行时成本，必须切换到以下选项之一：
- 如果连接
str对象，则可以构建一个列表，并在结尾使用str.join()，否则写入io.StringIO并在完成时检索其值 - 如果连接
bytes对象，您可以类似地使用bytes.join()或io.BytesIO，或者您可以进行in-place concatenationbytearray对象。bytearray对象是可变的，并具有有效的过分配机制 - 如果连接
tuple对象，请扩展list - 对于其他类型，调查相关类文件
- 如果连接
一些序列类型（例如
range）仅支持遵循特定模式的项序列，因此不支持序列连接或重复。在s中找不到x时，
index引发ValueError。当支持时，索引方法的附加参数允许有效搜索序列的子部分。传递额外的参数大致相当于使用s[i:j].index(x)，只是不复制任何数据，返回的索引相对于序列的开始，而不是开始的切片。
4.6.2.不可变序列类型¶
唯一的操作，不变序列类型通常实现，也不是可变的序列类型实现支持hash()内建。
此支持允许不可变序列（例如tuple实例）用作dict键，并存储在set和frozenset
尝试对包含不可缓冲值的不可变序列进行散列将导致TypeError。
4.6.3.可变序列类型¶
下表中的操作在可变序列类型上定义。提供了collections.abc.MutableSequence ABC，以便更容易在自定义序列类型上正确实现这些操作。
在表中s是可变序列类型的实例，t是任何可迭代对象，x是满足任何类型的任意对象，由s（例如bytearray）强加的值限制只接受满足0 / t9> x 255）。
| 操作 | 结果 | 注 |
|---|---|---|
s [i] = x | x替换s的项目i | |
s [i：j] = t | 从可迭代的t的内容替换从i到j的s | |
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 | 使用t的内容延伸s（大部分与s [len（s）：len（s）] t3 > = t） | |
s * = n | 更新s，其内容重复n次 | （6） |
s.insert（i， x） | 在由i给出的索引处插入x到s（与s [i：i] = [x]） | |
s.pop([i]) | 在i检索项目，并从s中删除它 | （2） |
s.remove(x) | 从s中移除第一个项目s [i] == x | （3） |
s.reverse() | 反转s的项目 | （4） |
注：
t的长度必须与它正在取代的切片相同。
可选参数i默认为
-1，因此默认情况下删除并返回最后一个项目。在s中找不到x时，
remove引发ValueError。在反转大序列时，
reverse()方法修改空间经济性的序列。为了提醒用户它通过副作用操作，它不返回反向序列。clear()和copy()是为了与不支持切片操作的可变容器的接口（如dictset）新版本3.3：
clear()和copy()方法。值n是整数，或者是实现
__index__()的对象。零和负值n清除序列。不复制序列中的项目；如s * n中对Common Sequence Operations
4.6.4.列表¶
列表是可变序列，通常用于存储同构项目的容器（其中相似性的精确程度将随应用程序而变化）。
- class
list([iterable])¶ 列表可以以多种方式构建：
- 使用一对方括号表示空列表：
[] - 使用方括号，用逗号分隔项目
[a],[a, b, c] - 使用列表推导式：
[x for x in iterable] - 使用类型构造函数：
list()或list(iterable)
构造器会建立一个和iterable同样顺序和元素的列表.iterable可以是序列，支持迭代的容器或迭代器对象。如果iterable已经是一个列表，则会创建并返回一个副本，类似于
iterable[:]。For example,list('abc')returns['a', 'b', 'c']andlist( (1, 2, 3) )returns[1, 2, 3]. 如果没有给出参数，那么构造函数将创建一个新的空列表[]。许多其他操作也产生列表，包括
sorted()内建。列表实现所有common和mutable序列操作。列表还提供以下附加方法：
sort(*, key=None, reverse=None)¶此方法仅使用元素之间的
<比较对列表进行原地排序。异常不会被抑制 - 如果任何比较操作失败，整个排序操作将失败（并且列表可能会保持部分修改状态）。sort()接受只能通过关键字（仅限关键字的参数）传递的两个参数：键指定用于从每个列表元素（例如，
key=str.lower）提取比较键的一个参数的函数。对应于列表中的每个项目的键被计算一次，然后用于整个分类处理。默认值None意味着列表项将直接排序而不计算单独的键值。functools.cmp_to_key()实用程序可用于将2.x样式cmp函数转换为键函数。reverse是一个布尔值。如果设置为
True，则列表元素以相反的方式排序。该方法在排序大序列时修改空间经济性的序列。为了提醒用户它通过副作用操作，它不返回排序的序列（使用
sorted()来显式请求一个新的排序列表实例）。sort()方法保证稳定。排序是稳定的，如果它保证不会改变比较结果相等的元素的相对顺序 — 这在依据多个途径进行排序时非常有用 （例如，先根据部门然后根据薪酬等级排序）。CPython实现细节：在对列表进行排序时，尝试改变，甚至检查列表的效果是未定义的。Python的C实现使得列表在持续时间内显示为空，并且如果它可以检测到列表在排序期间已经改变，则引发
ValueError。
- 使用一对方括号表示空列表：
4.6.5.元组¶
元组是不变序列，通常用于存储异构数据的容器（例如由内置的枚举()生成的2元组）。元组还用于需要不变的同构数据序列（例如允许在set或dict实例中存储）的情况。
- class
tuple([iterable])¶ 元组可以以多种方式构建：
- 使用一对括号表示空元组：
() - 对单个元组使用尾随逗号：
a,或(a,) - 以逗号分隔项目:
a, b, cor(a, b, c) - 使用
tuple()内建：tuple()或tuple(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¶
- class
range(stop)¶ - class
range(start, stop[, step]) 范围构造函数的参数必须是整数（内建
int或实现__index__特殊方法的任何对象）。如果省略步骤参数，则默认为1。如果省略start参数，它将默认为0。如果步骤为零，则会引发ValueError。对于正的步骤，范围
r的内容由公式r [i] t5> 开始 + 步骤* i其中i 0和r [i] t13>。对于负的步骤，范围的内容仍然由公式
r [i] = / t4> + 步骤* i，但约束是i > = t9 > 0和r [i] > 停止。如果
r[0]不满足值约束，范围对象将为空。范围确实支持负指数，但是这些被解释为从由正指数确定的序列的结尾处的索引。允许包含大于
sys.maxsize的绝对值的范围，但某些功能（例如len()）可能引发OverflowError。范围示例：
>>> list(range(10)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> list(range(1, 11)) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] >>> list(range(0, 30, 5)) [0, 5, 10, 15, 20, 25] >>> list(range(0, 10, 3)) [0, 3, 6, 9] >>> list(range(0, -10, -1)) [0, -1, -2, -3, -4, -5, -6, -7, -8, -9] >>> list(range(0)) [] >>> list(range(1, 0)) []
范围实现除串联和重复之外的所有common序列操作（由于范围对象只能表示遵循严格模式的序列，并且连接通常会违反该模式）。
start¶start参数的值（如果未提供参数，则为
0）
stop¶停止参数的值
step¶步骤参数的值（如果未提供参数，则为
1）
与常规list或tuple相比，range类型的优点是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还支持两种样式的字符串格式化，一种提供大量的灵活性和定制（见str.format()，Format String Syntax和Custom String Formatting），另一个基于C printf样式格式，它处理的范围较窄，并且稍微难以正确使用，但对于可处理的情况（printf-style String Formatting）。
标准库的Text Processing Services部分包括提供各种文本相关实用程序（包括re模块中的正则表达式支持）的许多其他模块。
str.capitalize()¶返回字符串的副本，该副本第一个字符大写，其余字符小写。
str.casefold()¶返回字符串的casefolded副本。表壳式字符串可用于无盒匹配。
casefolding类似于小写，但更积极，因为它旨在删除字符串中的所有case区别。例如，德国小写字母
'ß'等效于"ss"。由于它已经是小写的，lower()对'ß'不起作用；casefold()将其转换为"ss"。表单折叠算法在Unicode标准的3.13节中描述。
版本3.3中的新功能。
str.center(width[, fillchar])¶返回长度为width的字符串，并使得自身居中。填充使用指定的fillchar（默认为ASCII空格）完成。如果width小于或等于
len(s)则返回原始字符串。
-
str.count(sub[, start[, end]])¶ 返回在[start, end]范围内的子串sub非重叠出现的次数。可选参数start和end都以切片表示法解释。
-
str.encode(encoding="utf-8", errors="strict")¶ 将字符串的编码版本作为字节对象返回。默认编码为
'utf-8'。可以给出errors以设置不同的错误处理方案。errors的默认值是'strict'，意思编码错误引发一个UnicodeError。Other possible values are'ignore','replace','xmlcharrefreplace','backslashreplace'and any other name registered viacodecs.register_error(), see section Error Handlers. 可能的编码列表，请参阅Standard Encodings部分。在版本3.1中已更改：添加了对关键字参数的支持。
str.endswith(suffix[, start[, end]])¶如果字符串以指定的suffix结尾则返回
False，否则返回True。suffix也可以是一个元组。可选的start表示从该位置开始测试。可选的end表示在该位置停止比较。
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是一个dict子类：>>> class Default(dict): ... def __missing__(self, key): ... return key ... >>> '{name} was born in {country}'.format_map(Default(name='Guido')) 'Guido was born in country'
版本3.2中的新功能。
str.index(sub[, start[, end]])¶类似
find()，但未找到子字符串时引发ValueError。
str.isalnum()¶如果字符串中的所有字符都是字母数字且至少有一个字符，则返回true，否则返回false。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，ARABIC-INDIC DIGIT 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字符数据库中定义为“其他”或“分隔符”的字符，除了被认为是可打印的ASCII空间（0x20）。（请注意，在此上下文中的可打印字符是在字符串上调用
repr()时不应转义的字符。它对处理写入sys.stdout或sys.stderr的字符串没有影响。
str.isspace()¶如果字符串中只有空格字符，并且至少有一个字符，则返回true，否则返回false。空格字符是在Unicode字符数据库中定义为“其他”或“分隔符”并且具有双向属性为“WS”、“B”或“S”之一的那些字符。
str.istitle()¶如果字符串是标题类型的字符串且至少包含一个字符，则返回 true。例如：大写字符可能只能跟着非标题类（数字、符号和转义字符）的字符和小写字符。 否则返回 false。
str.join(iterable)¶返回一个字符串，为iterable可迭代对象中字符串的连接。如果可迭代中有任何非字符串值，包括
bytes对象，则会引发TypeError。元素之间的分隔符是提供该方法的字符串。
str.ljust(width[, fillchar])¶返回字符串的长度宽度中左对齐一个字符串。填充使用指定的fillchar（默认为ASCII空格）完成。如果width小于或等于
len(s)则返回原始字符串。
str.lstrip([chars])¶返回删除前导字符的字符串的副本。Chars参数是一个字符串，指定要移除的字符集。如果省略或
Nonechars参数默认为删除空格。chars参数不是前缀；相反，它的值的所有组合被去除：>>> ' spacious '.lstrip() 'spacious ' >>> 'www.example.com'.lstrip('cmowz.') 'example.com'
- static
str.maketrans(x[, y[, z]])¶ 此静态方法返回可用于
str.translate()的转换表。如果只有一个参数，它必须是将Unicode ordinals（整数）或字符（长度为1的字符串）映射到Unicode ordinal，字符串（任意长度）或None的字典。字符键将被转换为序数。
如果有两个参数，它们必须是相等长度的字符串，并且在结果字典中，x中的每个字符将被映射到y中相同位置的字符。如果有第三个参数，它必须是一个字符串，其字符将被映射到结果中的无。
str.partition(sep)¶在分隔符首次出现位置拆分字符串，并返回包含分隔符之前部分、分隔符本身和分隔符之后部分的3元组。如果找不到分隔符，返回包含字符串本身，跟着两个空字符串的 3 元组。
str.replace(old, new[, count])¶返回字符串的一个拷贝，其中所有的子串old通过new替换。如果指定了可选参数count，则只有前面的count个出现被替换。
str.rfind(sub[, start[, end]])¶返回被搜索子串最后一次出现在字符串的索引位置,
s[start:end]被搜索范围为[start:end]可选参数start和end作为切片表示法解释。失败返回-1。
str.rindex(sub[, start[, end]])¶类似
rfind()，但未找到子字符串子时引发ValueError。
str.rjust(width[, fillchar])¶返回字符串的长度宽度中右对齐的字符串。填充使用指定的fillchar（默认为ASCII空格）完成。如果width小于或等于
len(s)则返回原始字符串。
str.rpartition(sep)¶拆分 （ sep），最后一个匹配项的字符串，并返回包含分隔符，分隔符本身和部分之前的部分在分隔符之后的 3 元组。如果找不到分隔符，返回包含两个空字符串，后面跟有字符串本身的 3 元组。
str.rsplit(sep=None, maxsplit=-1)¶在字符串中，使用sep作为分隔符字符串返回一个单词列表。如果给出了maxsplit ，顶多分裂为maxsplit+1个元素，从最右边开始。如果未指定sep或
None任何空格的字符串是一个分隔符。除了从右边分裂，rsplit()像split()在下面详细描述。
str.rstrip([chars])¶返回一个移去尾部字符后的字符串的拷贝。Chars参数是一个字符串，指定要移除的字符集。如果省略或
Nonechars参数默认为删除空格。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给定且为真。
此方法在以下行边界上分割。特别地，边界是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']
为了比较，
split('\n')给出：>>> ''.split('\n') [''] >>> 'Two lines\n'.split('\n') ['Two lines', '']
str.startswith(prefix[, start[, end]])¶如果字符串以prefix开头则返回
True，否则返回False。prefix也可以是一个需要查找的前缀元组。可选的start表示从该位置开始测试字符串。可选的end表示在该位置停止字符串比较。
-
str.strip([chars])¶ 返回字符串的一个副本，删除前导和尾随字符。Chars参数是一个字符串，指定要移除的字符集。如果省略或
Nonechars参数默认为删除空格。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()¶返回字符串首字母大写的一个版本，所有单词以大写字母开始，剩下的字母都是小写。
举个例子：
>>> '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序号或字符串，将字符映射到一个或多个其他字符； returnNone，从返回字符串中删除字符；或引发LookupError异常，将字符映射到自身。您可以使用
str.maketrans()从不同格式的字符到字符映射创建转换映射。另请参阅
codecs模块，以获得自定义字符映射的更灵活的方法。
str.upper()¶返回字符串的一个拷贝，其中所有大小写有区别的字符[4]转换为大写。请注意，
str.upper().isupper()可能是False如果s包含未包含字符， s）不是“Lu”（Letter，大写），而是eg“Lt”（Letter，titlecase）。所使用的上层算法在Unicode标准的3.13节中描述。
str.zfill(width)¶返回剩余字符串为ASCII
'0'的字符串，以生成长度宽度的字符串。A leading sign prefix ('+'/'-') is handled by inserting the padding after the sign character rather than before. 如果width小于或等于len(s)则返回原始字符串。举个例子：
>>> "42".zfill(5) '00042' >>> "-42".zfill(5) '-0042'
4.7.2. printf -style字符串格式¶
注
这里描述的格式化操作展示了导致许多常见错误（例如未能正确地显示元组和字典）的各种怪癖。使用较新的str.format()接口有助于避免这些错误，并且还提供了一种更加强大，灵活和可扩展的格式化文本的方法。
字符串对象有一个唯一的内建操作：%操作符（modulo）。这也被称为字符串格式化或插值操作符。Given format % values (where format is a string), % conversion specifications in format are replaced with zero or more elements of values. 效果类似于在C语言中使用sprintf()。
如果format需要一个单一的参数，values可以是一个单个的非元组对象。[5]否则，values必须是一个元组且其元素个数与格式字符串指定的完全相同，或者是一个单一的映射对象（例如，一个字典）。
转换说明符包含两个或多个字符并具有以下组件，必须按以下顺序发生：
'%'字符，它标记指示符的起点。- 映射的键（可选），由圆括号括起来的字符序列组成（例如，
(somename)）。 - 转换的标志（可选），它们影响某些转换类型的结果。
- 字段最小的宽度（可选）。如果用
'*'（星号）表示，则真正的宽度从元组values中下一个元素读取，字段最小宽度值后面的是将要转换的对象和可选的精度。 - 精度（可选），以
'.'给出（点）后跟精度。如果指定为'*'（星号），则从值中的元组的下一个元素读取实际精度，并且转换的值在精度之后。 - 长度调整器（可选）。
- 转换的类型。
当右侧参数是一个字典（或其它映射类型）时，那么字符串中的formats必须包含一个圆括号括起来的键，其来自于'%'字符后立即插入的那个字典。映射的键从映射中选择要格式化的值。举个例子：
>>> print('%(language)s has %(number)03d quote types.' %
... {'language': "Python", "number": 2})
Python has 002 quote types.
在这种情况下format中不可以出现*指示符（因为它们需要一个连续的参数列表）。
转换标志字符包括：
| 标志 | 含义 |
|---|---|
'#' | The value conversion will use the “alternate form” (where defined below). |
'0' | The conversion will be zero padded for numeric values. |
'-' | The converted value is left adjusted (overrides the '0' conversion if both are given). |
' ' | (a space) A blank should be left before a positive number (or empty string) produced by a signed conversion. |
'+' | A sign character ('-' or '+') will precede the conversion (overrides a “space” flag). |
可以存在长度修改符（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' | 字符串（使用str()转换任意Python对象）。 | （5） |
'a' | String（使用ascii()转换任何Python对象）。 | （5） |
'%' | 不转换任何参数，结果中出现的是'%'字符。 |
注：
替代形式造成一家领先的零 (
'0') 左侧填充和格式设置的数字如果结果的前导字符之间插入已经不是零。替代形式导致前导
'0X'或'X'（具体取决于是否使用了'0x'或者'x'格式） 来插入左侧填充和格式的数量，如果前导字符的结果已经不是零之间。替代形式使结果总是包含小数点，即使没有任何数字跟随它。
精度决定小数点之后的有效位数，默认为6。
替代形式使结果总是包含小数点，和尾随零不因为他们否则将会被删除。
精度决定小数点前后的有效位数，默认为6。
如果precision为
N，则输出将截断为N个字符。
- 请参阅 PEP 237。
由于Python字符串具有显式长度，因此%s转换不假设'\0'是字符串的结尾。
在版本3.1中更改的版本： %f转换绝对值超过1e50的数字不再被%g转换取代。
4.8.二进制序列类型 - bytes，bytearray，memoryview ¶
用于处理二进制数据的核心内建类型是bytes和bytearray。它们由memoryview支持，它使用buffer protocol访问其他二进制对象的内存，而无需进行复制。
array模块支持高效存储基本数据类型，如32位整数和IEEE754双精度浮点值。
4.8.1.字节¶
字节对象是单字节的不可变序列。由于许多大型二进制协议是基于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前缀来禁止转义序列的处理。有关字节字面值的各种形式的更多信息，包括支持的转义序列，请参见String and Bytes literals。
虽然字节字面值和表示是基于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中描述的公共字节和bytearray操作，它们还支持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以设置不同的错误处理方案。errors的默认值是'strict'，意思编码错误引发一个UnicodeError。其他可能的值为'ignore'，'replace'和通过codecs.register_error()注册的任何其他名称，请参见错误处理程序。可能的编码列表，请参阅Standard Encodings部分。在版本3.1中已更改：添加了对关键字参数的支持。
bytes.endswith(suffix[, start[, end]])¶bytearray.endswith(suffix[, start[, end]])¶如果二进制数据以指定的后缀结尾，则返回
True，否则返回False。suffix也可以是一个元组。可选的start表示从该位置开始测试。可选的end表示在该位置停止比较。要搜索的后缀可以是任何字节状对象。
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()的翻译表，它将中的每个字符从映射到中相同位置的字符到； 从和到必须都是字节状对象，并具有相同的长度。版本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。要搜索的子序列可以是任何bytes-like object或0到255范围内的整数。
在版本3.3中更改：还接受范围为0到255的整数作为子序列。
bytes.rindex(sub[, start[, end]])¶bytearray.rindex(sub[, start[, end]])¶当找不到子序列sub时，像
rfind()但引用ValueError要搜索的子序列可以是任何bytes-like object或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。prefix也可以是一个需要查找的前缀元组。可选的start表示从该位置开始测试。可选的end表示在该位置停止比较。要搜索的前缀可以是任何字节状对象。
-
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空格。chars参数不是前缀；相反，它的值的所有组合被去除：>>> b' spacious '.lstrip() b'spacious ' >>> b'www.example.com'.lstrip(b'cmowz.') b'example.com'
要删除的字节值的二进制序列可以是任何bytes-like object。
注
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made.
-
bytes.rjust(width[, fillbyte])¶ -
bytearray.rjust(width[, fillbyte])¶ 返回对象右对齐的副本，长度width。填充使用指定的fillbyte（默认为ASCII空格）完成。对于
bytes对象，如果width小于或等于len(s)，则返回原始序列。注
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made.
bytes.rsplit(sep=None, maxsplit=-1)¶bytearray.rsplit(sep=None, maxsplit=-1)¶将二进制序列拆分为相同类型的子序列，使用sep作为定界符字符串。如果给出了maxsplit ，顶多分裂为maxsplit+1个元素，从最右边开始。如果未指定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。
注
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made.
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']). sep参数可以由多字节序列（例如，b'1<>2<>3'.split(b'<>')返回[b'1'， b'2'， b'3']）。使用指定的分隔符拆分空序列会根据要拆分的对象的类型返回[b'']或[bytearray(b'')]。sep参数可以是任何bytes-like object。举个例子：
>>> b'1,2,3'.split(b',') [b'1', b'2', b'3'] >>> b'1,2,3'.split(b',', maxsplit=1) [b'1', b'2,3'] >>> b'1,2,,3,'.split(b',') [b'1', b'2', b'', b'3', b'']
如果未指定sep或
None，则应用不同的分割算法：连续ASCII空格的运行被视为单个分隔符，并且结果将不包含空字符串如果序列具有前导或尾随空格，则在开始或结束。因此，拆分空序列或仅由ASCII空格组成但不带指定分隔符的序列返回[]。举个例子：
>>> b'1 2 3'.split() [b'1', b'2', b'3'] >>> b'1 2 3'.split(maxsplit=1) [b'1', b'2 3'] >>> b' 1 2 3 '.split() [b'1', b'2', b'3']
-
bytes.strip([chars])¶ -
bytearray.strip([chars])¶ 返回具有指定前导和尾随字节的序列的副本。chars参数是一个二进制序列，指定要删除的字节值集合 - 名称指的是此方法通常与ASCII字符一起使用的事实。如果省略或
None，则chars参数默认为删除ASCII空格。chars参数不是前缀或后缀；相反，它的值的所有组合被去除：>>> b' spacious '.strip() b'spacious' >>> b'www.example.com'.strip(b'cmowz.') b'example'
要删除的字节值的二进制序列可以是任何bytes-like object。
注
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made.
以下字节和bytearray对象的方法假定使用ASCII兼容的二进制格式，不应该应用于任意二进制数据。请注意，本节中的所有bytearray方法都不会操作，而是生成新对象。
bytes.capitalize()¶bytearray.capitalize()¶返回一个序列的副本，每个字节被解释为一个ASCII字符，第一个字节大写，其余部分为小写。非ASCII字节值不变地传递。
注
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made.
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'
注
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made.
bytes.isalnum()¶bytearray.isalnum()¶如果序列中的所有字节都是字母ASCII字符或ASCII十进制数字，并且序列不为空，则返回true，否则返回false。字母ASCII字符是序列
b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'中的那些字节值。ASCII十进制数字是序列b'0123456789'中的那些字节值。举个例子：
>>> b'ABCabc1'.isalnum() True >>> b'ABC abc1'.isalnum() False
bytes.isalpha()¶bytearray.isalpha()¶如果序列中的所有字节都是字母ASCII字符，并且序列不为空，则返回true，否则返回false。字母ASCII字符是序列
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空格字符是
b' \ t \ n \ r \ x0b \ f'序列中的字节值（空格，制表符，换行符，回车，垂直制表符，换页）。
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'中的那些字节值。注
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made.
bytes.splitlines(keepends=False)¶bytearray.splitlines(keepends=False)¶返回二进制序列中的行的列表，在ASCII行边界处断开。此方法使用universal newlines方法分隔行。换行符不包含在结果列表中，除非给定keepends给定且为真。
举个例子：
>>> 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'中的那些字节值。与
str.swapcase()不同，它始终是bin.swapcase()。swapcase() == bin。案例转换在ASCII中是对称的，即使对于任意Unicode代码点通常也不是真的。注
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made.
bytes.title()¶bytearray.title()¶返回二进制序列的标题化版本，其中单词以大写ASCII字符开头，其余字符为小写。未修改的字节值保持不变。
举个例子：
>>> b'Hello world'.title() b'Hello World'
小写ASCII字符是序列
b'abcdefghijklmnopqrstuvwxyz'中的那些字节值。大写ASCII字符是序列b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'中的那些字节值。所有其他字节值都未设置。该算法使用一个简单的独立于具体语言的定义，将连续的一组字母定义为一个单词。该定义在很多情况下可以工作，但也意味着在缩略和所有格构成词的边界中，这可能不是预期的结果：
>>> b"they're bill's friends from the UK".title() b"They'Re Bill'S Friends From The Uk"
可以使用正则表达式为撇号构造一种变通方法：
>>> import re >>> def titlecase(s): ... return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?", ... lambda mo: mo.group(0)[0:1].upper() + ... mo.group(0)[1:].lower(), ... s) ... >>> titlecase(b"they're bill's friends.") b"They're Bill's Friends."
注
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made.
bytes.upper()¶bytearray.upper()¶返回具有所有小写ASCII字符的序列的副本，转换为其对应的大写副本。
举个例子：
>>> b'Hello World'.upper() b'HELLO WORLD'
小写ASCII字符是序列
b'abcdefghijklmnopqrstuvwxyz'中的那些字节值。大写ASCII字符是序列b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'中的那些字节值。注
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made.
bytes.zfill(width)¶bytearray.zfill(width)¶返回剩余的填充ASCII
b'0'数字的序列的副本，以形成长度宽度的序列。前导符号前缀（b'+'/b'-'）通过在符号字符之后插入填充来处理，而不是之前。对于bytes对象，如果width小于或等于len(seq)，则返回原始序列。举个例子：
>>> b"42".zfill(5) b'00042' >>> b"-42".zfill(5) b'-0042'
注
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made.
4.8.4. printf -style Bytes Formatting ¶
注
这里描述的格式化操作展示了导致许多常见错误（例如未能正确地显示元组和字典）的各种怪癖。如果正在打印的值可能是元组或字典，请将其包装在元组中。
字节对象（bytes / bytearray）有一个唯一的内建操作：%操作符（modulo）。这也称为字节格式或插值 t>操作符。Given format % values (where format is a bytes object), % conversion specifications in format are replaced with zero or more elements of values. 效果类似于在C语言中使用sprintf()。
如果format需要一个单一的参数，values可以是一个单个的非元组对象。[5]否则，值必须是由字节对象或单个映射对象（例如字典）指定的项目数量的元组。
转换说明符包含两个或多个字符并具有以下组件，必须按以下顺序发生：
'%'字符，它标记指示符的起点。- 映射的键（可选），由圆括号括起来的字符序列组成（例如，
(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中不可以出现*指示符（因为它们需要一个连续的参数列表）。
转换标志字符包括：
| 标志 | 含义 |
|---|---|
'#' | The value conversion will use the “alternate form” (where defined below). |
'0' | The conversion will be zero padded for numeric values. |
'-' | The converted value is left adjusted (overrides the '0' conversion if both are given). |
' ' | (a space) A blank should be left before a positive number (or empty string) produced by a signed conversion. |
'+' | A sign character ('-' or '+') will precede the conversion (overrides a “space” flag). |
可以存在长度修改符（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' | Bytes（使用repr(obj).encode('ascii','backslashreplace)转换任何Python对象）。 | （5） |
'r' | 'r'是'a'的别名，应该仅用于Python2 / 3代码库。 | （7） |
'%' | 不转换任何参数，结果中出现的是'%'字符。 |
注：
替代形式造成一家领先的零 (
'0') 左侧填充和格式设置的数字如果结果的前导字符之间插入已经不是零。替代形式导致前导
'0X'或'X'（具体取决于是否使用了'0x'或者'x'格式） 来插入左侧填充和格式的数量，如果前导字符的结果已经不是零之间。替代形式使结果总是包含小数点，即使没有任何数字跟随它。
精度决定小数点之后的有效位数，默认为6。
替代形式使结果总是包含小数点，和尾随零不因为他们否则将会被删除。
精度决定小数点前后的有效位数，默认为6。
如果precision为
N，则输出将截断为N个字符。b'%s'已弃用，但不会在3.x系列期间删除。b'%r'已弃用，但不会在3.x系列期间删除。请参阅 PEP 237。
注
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made.
请参见
版本3.5中的新功能。
4.8.5.内存视图¶
memoryview对象允许Python代码在不进行复制的情况下访问支持buffer protocol的对象的内部数据。
- class
memoryview(obj)¶ 创建引用obj的
memoryview。obj必须支持缓冲区的协议。支持缓冲区协议的内建对象包括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]
如果底层对象是可写的，memoryview支持一维切片分配。不允许调整大小：
>>> data = bytearray(b'abcefg') >>> v = memoryview(data) >>> v.readonly False >>> v[0] = ord(b'z') >>> data bytearray(b'zbcefg') >>> v[1:4] = b'123' >>> data bytearray(b'z123fg') >>> v[2:3] = b'spam' Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: memoryview assignment: lvalue and rvalue have different structures >>> v[2:6] = b'spam' >>> data bytearray(b'z1spam')
具有格式“B”，“b”或“c”的散列（只读）类型的一维存储器视图也是可哈希的。散列定义为
hash（m） == hash（m.tobytes()）>>> v = memoryview(b'abcefg') >>> hash(v) == hash(b'abcefg') True >>> hash(v[2:4]) == hash(b'ce') True >>> hash(v[::-2]) == hash(b'abcefg'[::-2]) True
在版本3.3中更改：一维内存观看现在可以切片。具有格式“B”，“b”或“c”的一维存储器查看现在是可哈希的。
在版本3.4中更改： memoryview现在已自动注册到
collections.abc.Sequence在3.5版本中更改： memoryviews现在可以用整数的元组索引。
memoryview有几种方法：__eq__(exporter)¶A memoryview and a PEP 3118 exporter are equal if their shapes are equivalent and if all corresponding values are equal when the operands’ respective format codes are interpreted using
structsyntax.For 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()¶以字节形式返回缓冲区中的数据。这相当于在内存视图上调用
bytes构造函数。>>> m = memoryview(b"abc") >>> m.tobytes() b'abc' >>> bytes(m) b'abc'
对于非连续数组，结果等于扁平列表表示，其中所有元素都转换为字节。
tobytes()支持所有格式字符串，包括不在struct模块语法中的字符串。
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])¶将memoryview转换为新的格式或形状。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 / int到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 / unsigned char转换为2D / unsigned long：
>>> 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'现在根据struct模块语法进行处理。这意味着memoryview（b'abc'）[0] == b'abc'[0] = = 97。
itemsize¶内存视图的每个元素的字节大小：
>>> 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的bool。
版本3.3中的新功能。
f_contiguous¶一个bool指示内存是否为Fortran contiguous。
版本3.3中的新功能。
contiguous¶指示存储器是contiguous的bool。
版本3.3中的新功能。
4.9.集合类型 — set, frozenset¶
集合对象是一个不同hashable对象组成的无序集合。常见的使用包括成员测试、从序列中删除重复项和计算数学运算（如交、并、差和对称差）。（对于其他容器，请参阅内建dict，list和tuple类和collections模块。
类似其它容器，集合支持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])¶ 返回新的集合或frozenset对象，其元素取自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测试集合中的每个元素是否在other中。
set < other测试集合是否是other的一个真子集，即
set <= other and set != other。
issuperset(other)¶set >= other测试other中的每个元素是否在集合中。
set > other测试集合是否是other的真超集，即
set >= other and set != other。
union(other, ...)¶set | other | ...返回一个新的集合，元素来自于集合和所有其它的集合。
intersection(other, ...)¶set & other & ...返回一个新的集合，元素是结集合和其它集合共有的。
difference(other, ...)¶set - other - ...返回一个新的集合，元素在集合中但不在其它集合中。
symmetric_difference(other)¶set ^ other返回一个新的集合，元素在集合或other中，但不能在两个集合中都存在。
copy()¶返回一个新的集合，为s的一个浅拷贝。
请注意，非运算符版本的
union()、intersection()、difference()，和symmetric_difference()、issubset()、issuperset()方法将接受任何可作为参数的迭代。相反，他们的基于操作符号的对等体需要它们的参数是集合。这就排除了出错的建筑物，如支持更具可读性的set('abc').intersection('cbs')set('abc') & 'cbs'。set和frozenset支持字符集进行比较。两套是平等的当且仅当每个组的每个元素包含在另 （每个都的另一个子集）。一set小于另一个set当且仅当第一组是第二个集的一个子集 （是一个子集，但不是等于）。一套是否大于另一个设置当且仅当第一组的第二套真超集 （是超集，但不是等于）。frozenset基于其成员的实例与实例的set进行比较。例如，set('abc') = = frozenset('abc')返回True，且set('abc') 在 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。
frozenset混合set实例的二元运算返回第一个操作数的类型。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()方法将接受任何可作为参数的迭代。请注意，
__contains__()、remove()和discard()方法的元素参数可能是一套。为了支持寻找等效的 frozenset，在搜索期间暂时突变，然后还原elem设置。在搜索， elem集不应读或变异因为它没有一个有意义的值。
4.10.映射类型 - dict ¶
一个mapping对象将hashable的值映射到任意对象。映射是可变对象。目前只有一种标准映射类型，那就是字典。（对于其他容器，请参阅内置的列表，设置和元组类和容器模块。 ）
字典的键几乎是任意值。不hashable的值，也就是包含列表、字典或其它可变类型的值（它们通过值而不是对象ID进行比较）不可以用作键。用于键的数值类型遵守数值比较的正常规则：如果两个数字的比较结果相等（如1.0和1），那么它们可以用于互相索引相同的词典条目。（注意，由于计算机存储的是浮点数的近似值，因此将浮点数作为键值是不明智的。)
字典可以通过放置一个逗号分隔的key: value对列表于花括号中创建，例如：{'jack': 4098, 'sjoerd': 4127}或{4098: 'jack', 4127: 'sjoerd'}，或通过dict构造函数创建。
- class
dict(**kwarg)¶ - class
dict(mapping, **kwarg) - class
dict(iterable, **kwarg) 返回一个新的字典，从一个可选的位置参数和一个可能为空的关键字参数集合初始化。
如果没有给定位置参数，则创建一个空的字典。如果给定位置参数且它是一个映射对象，则创建一个与该映射对象具有相同的键-值对的一个字典。否则，位置参数必须是一个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标识符。否则，可以使用任何有效的键。
这些是字典支持的操作（因此，自定义映射类型也应该支持）：
len(d)返回字典中的项目数量d。
d[key]返回字典d中键为key的元素。如果key不在映射中，则引发一个
KeyError。If a subclass of dict defines a method
__missing__()and key is not present, thed[key]operation calls that method with the key key as argument.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]。引发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和值将设置为值创建一个新的字典。
fromkeys()是一个类方法，返回一个新字典。value默认为None。
-
get(key[, default])¶ 如果 key 在字典里，返回 key 的值，否则返回 default 值。如果 default 未给出，它默认为
None，此方法永远不会引发KeyError。
keys()¶返回字典的键的新的视图。请参阅documentation of view objects。
popitem()¶从字典中移除并返回任意一个
(key, value)对。popitem()对于破坏性地遍历一个字典很有用，正如在集合算法中经常用到的一样。如果字典为空，调用popitem()将引发一个KeyError。
setdefault(key[, default])¶如果key在字典中，则返回其值。如果没有，则插入值为default的key，并返回default。default默认为
None。
update([other])¶依据other更新词典的键/值对，覆盖现有的键。返回
None。update()接受另一个字典对象或可迭代的键/值对（如元组或其它长度为2的可迭代对象）。如果指定的是关键字参数，那么字典使用这些键/值对更新：d.update(red=1, blue=2)。
values()¶返回字典的值的新的视图。请参阅documentation of view objects。
当且仅当它们具有相同的
（键， 值）对时，字典才比较等于。订单比较（'='，'>'）引发TypeError。
请参见
types.MappingProxyType可用于创建dict的只读视图。
4.10.1.字典视图对象¶
The objects returned by dict.keys(), dict.values() and dict.items() are view objects.它们提供字典条目上的一个动态视图，这意味着当字典更改时，视图会反映出这些变化。
字典视图可以遍历来产生它们各自的数据，并支持成员测试：
len(dictview)返回字典中的条目数。
iter(dictview)返回字典中键、值或项（表示为
(key, value)元组）上的一个迭代器。键和值迭代的顺序是任意的但非随机，因Python的实现而异，取决于字典插入和删除操作的历史。如果键、值和项的视图的遍历过程中不对字典作任何修改，项的顺序将始终一致。这允许使用
zip()创建(value, key)对：pairs = zip(d.values(), d.keys())。另一种创建相同列表的方式是pairs = [(v, k) for （k, v） in d.items()]。迭代视图过程中添加或删除字典中的项可能引发
RuntimeError或遍历所有条目失败 。
x in dictview返回
True，如果x在底层字典的键、值或项中（在后者的情况下，x应该是(key, value)元组）。
键视图很像集合，因为它们的条目是唯一且可哈希的。如果所有值都是哈希的，那么（键， 值）对是唯一的和哈希的，那么项目视图也是类似的。（值视图不被作为类似集合的因为它们的条目通常不是唯一的。）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()。这些管理器将活跃的十进制上下文设置为原始的十进制上下文的副本，然后返回该副本。这允许向当前的十进制上下文的with语句正文中而不会影响外部with语句的代码的更改。
contextmanager.__exit__(exc_type, exc_val, exc_tb)¶退出运行时上下文并返回一个布尔标志，指示是否应该抑制发生的任何异常。执行主体
with语句时发生异常，如果参数不包含异常类型、 值和追踪信息。否则，所有三个参数都None。从该方法返回一个 true 值将导致
with语句来抑制该异常并且紧跟with语句之后的语句继续执行。否则该异常继续传播此方法执行完。此方法的执行过程中发生的异常将取代with语句正文中发生的任何异常。传递中的异常应该永远不会被显式-reraised 相反，此方法应返回 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.类和类实例¶
对于这些，请参见 Objects, values and types 和 Class definitions。
4.12.3.函数¶
函数对象通过函数定义创建。对函数对象的唯一操作是调用它：func(argument-list)。
真的有两种类型的函数对象：内建函数和用户定义的函数。两者都支持同样的操作（函数的调用），但实现不一样，因此对象类型也不一样。
更多的信息，请参阅 Function definitions。
4.12.4.方法¶
方法是使用属性符号调用的函数。有两种类型：内建的方法（如列表上的append()）和类的实例方法。内建的方法与支持它们的类型在一起描述。
如果通过实例访问一个方法（在类命名空间中定义的函数），则会得到一个特殊对象：绑定方法（也称为实例方法）对象。当被调用时，它会将self参数添加到参数列表中。绑定方法有两个特殊的只读属性：m.__self__是方法操作的对象，m.__func__是实现方法的函数。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（内建名称）。type(Ellipsis)()产生Ellipsis单例。
它写为Ellipsis或...。
4.12.9.NotImplemented 对象¶
当比较和二元操作被要求操作它们不支持的类型时，返回该对象。有关详细信息，请参见Comparisons。只有一个NotImplemented对象。type(NotImplemented)()生成单例实例。
它写成NotImplemented。
4.12.10.布尔值¶
布尔值是两个常量对象True和False。它们用来表示真值（尽管其它值也可以被认为是假或者是真）。在数字上下文中（例如，用作算术运算符的参数时），它们的行为分别像整数0和1。内建函数bool()可用于将任何值转换为一个布尔值，如果值可以解释为真值（见上面Truth Value Testing一节）。
它们分别写成True和False。
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） category属性是“Lu”（Letter，大写），“Ll”（Letter，小写）或“Lt”（Letter，titlecase）之一。 |
| [5] | （1，2）为了只格式化一个元组，你应该提供一个单元元组，其元素是要被格式化的元组。 |