python内置类型详细解释

文章编写借鉴于内置类型 — Python 3.7.3 文档，主要用于自己学习和记录

python主要内置类型包括数字、序列、映射、类、实例和异常

有些多项集类是可变的。它们用于添加、移除或重排其成员的方法，将原地执行，并不返回特定的项，绝对不会返回多项集实例自身而是返回 None。

实际上所有对象都可以被比较、检测逻辑值，以及转换为字符串（使用 repr() 函数或略有差异的 str() 函数）。 后一个函数是在对象由 print() 函数输出时被隐式地调用的。

逻辑值检测

任何对象都可以进行逻辑值的检测，以便在 if 或 while 作为条件或是作为下文所述 布尔运算 的操作数来使用。

一个对象在默认情况下均被视为真值，除非当该对象被调用时其所属类定义了 __bool__() 方法且返回 False 或是定义了 __len__() 方法且返回零。

• 被定义为假值的常量: None 和 False。
• 任何数值类型的零: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)。
• 空的序列和多项集: '', (), [], {}, set(), range(0)。

产生布尔值结果的运算和内置函数总是返回 0 或 False 作为假值，1 或 True 作为真值。（重要例外：布尔运算 or 和 and 总是返回其中一个操作数。）

布尔运算（and,or,not）

按优先级排序，表格如下：

运算	结果	注释
x or y	if x is false, then y, else x	1
x and y	if x is false, then x, else y	2
not x	if x is false, then True, else False	3

注释：

1. 为短路运算符，因此只有第一个参数为 假 时才会对第二个参数求值
2. 为短路运算符，第一个参数为 真 时才会对第二个参数求值
3. not 的优先级比非布尔运算符 低 ，因此 not a == b 会被解读为 not (a == b) 而 a == not b 会引发语法错误。

比较

在 Python 中有八种比较运算符。它们的优先级相同（比布尔运算的优先级高）。比较运算可以任意串连。

例如，x < y <= z 等价于 x < y and y <= z，前者的不同之处在于 y 只被求值一次（但在两种情况下当 x < y 结果为假值时 z 都不会被求值）。

以下表格列出了此八种比较运算符

运算	含义
<	严格小于
<=	小于或等于
>	严格大于
>=	大于或等于
==	等于
!=	不等于
is	对象标识
is not	否定的对象标识

注意

<, <=, > 和 >= 运算符在以下情况中将引发 TypeError 异常：当比较复数与另一个内置数字类型时，当两个对象具有无法被比较的不同类型时，或在未定义次序的其他情况时。

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

一个类实例不能与相同类或的其他实例或其他类型的对象进行排序，除非该类定义了足够多的方法，包括 __lt__(), __le__(), __gt__() 以及 __ge__()

is 和 is not 运算符无法自定义；并且它们可以被应用于任意两个对象而不会引发异常。

数字类型( int, float, complex)

具有三种不同的数字类型：整数, 浮点数和复数。此外，布尔值属于整数的子类型，整数具有无限的精度，浮点数通常使用 C 中的 double 来实现，复数包含实部和虚部，分别以一个浮点数表示。要从一个复数中提取这两个部分，可使用 z.real 和 z.imag。

所有数字类型(复数除外)都支持下列运算，按优先级升序排序(所有数字运算的优先级都高于比较运算)

运算	结果	注释
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 的绝对值
int(x)	将 x 转化为整数	3,6
float(x)	将 x 转化为浮点数	4,6
complex(re, im)	一个带有实部 re 和虚部 im 的复数，im默认为0	6
c.conjugate()	复数 c 的共轭复数
divmod(x, y)	(x // y, x % y)	2
pow(x)	x 的 y 次幂	5
x ** y	x 的 y 次幂	5

注释：

1. 结果值是一个整数 ，但结果的类型不一定是 int。 运算结果总是向负无穷的方向舍入,例如：1//2 为 0，(-1)//2 为 -1，1//(-2) 为 -1 而 (-1)//(-2) 为 0
2. 不可用于复数。
3. 将浮点数转换为整数会被舍入
4. float 也接受字符串 "nan" 和附带可选前缀 "+" 或 "-" 的 "inf" 分别表示非数字 (NaN) 以及正或负无穷。
5. Python 将 pow(0, 0) 和 0 ** 0 定义为 1
6. 接受的数字字面值包括数码 0 到 9 或任何等效的 Unicode 字符

所有 int 和 float 类型还包括下列运算

运算	结果	示例
math.trunc(x)	将 x 截断为int	math.trunc(3.14) 为 3
round(x[, n])	x 舍入到 n 位小数	round(3.14159, 3) 为 3.142
math.floor(x)	小于等于 x 的最大 int	math.floor(3.14) 为 3
math.ceil(x)	大于等于 x 的最小 int	math.ceil(3.14) 为 4

整数类型的按位运算

按位运算只对 整数 有意义。

计算按位运算的结果，就相当于使用无穷多个二进制符号位对二的补码执行操作。

二进制按位运算的优先级全都低于数字运算，但又高于比较运算；一元运算 ~ 具有与其他一元算术运算 (+ and -) 相同 的优先级。

以下表格是以优先级升序排序的按位运算：

运算	结果	注释
x | y	x 和 y 按位 或	4
x ^ y	x 和 y 按位 异或	4
x & y	x 和 y 按位 与	4
x << n	x 左移 n 位	1,2
x >> n	x 右移 n 位	1,3
~x	x 逐位取反

注释：

1. 负 的移位数是非法的，会导致引发 ValueError。
2. 左移 n 位等价于不带 溢出检测 (避免造成缓冲区溢出问题)地乘以 pow(2, n)。
3. 右移 n 位等价于不带 溢出检测 (避免造成缓冲区溢出问题)地除以 pow(2, n)。
4. 使用带有至少一个额外符号扩展位的有限个二进制补码表示（有效位宽度为 1 + max(x.bit_length(), y.bit_length()) 或以上）执行这些计算就足以获得相当于有无数个符号位时的同样结果。

整数类型的附加方法

int.bit_length()

返回以二进制表示一个整数所需要的位数，不包括符号位和前面的零:

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6  # 即表示的是（100101）的长度

更准确地说，如果 x 非零，则 x.bit_length() 是使得 2**(k-1) <= abs(x) < 2**k 的唯一正整数 k。如果 x 为零，则 x.bit_length() 返回 0。

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

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

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

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

byteorder 参数用于表示整数的字节顺序.如果 byteorder 为 "big"，则最高位字节放在字节数组的开头。 如果 byteorder 为 "little"，则最高位字节放在字节数组的末尾。 要请求主机系统上的原生字节顺序，使用 sys.byteorder 作为字节顺序值。

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

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

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

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

bytes 参数必须为一个 bytes-like object 或是生成字节的可迭代对象。

byteorder 参数与to_bytes()函数的此参数一致

signed 参数指明是否使用二的补码来表示整数。

浮点类型的附加方法

float.as_integer_ratio()

返回一对整数，其比率正好等于原浮点数并且分母为正数。 无穷大会引发 OverflowError 而 NaN 则会引发 ValueError:

>>> (3.14).as_integer_ratio()
(7070651414971679, 2251799813685248)
>>> (0.00).as_integer_ratio()
(0, 1)

float.is_integer()

如果 float 实例可用有限位整数表示则返回 True，否则返回 False:

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

float.hex()

以十六进制字符串的形式返回一个浮点数表示。 对于有限浮点数，这种表示法将总是包含前导的 0x 和尾随的 p 加指数。

>>> (3.14159).hex()
'0x1.921f9f01b866ep+1'

classmethod float.fromhex(s)

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

注意

• float.hex() 是实例方法，而float.fromhex(s) 是类方法

十六进制字符串采用的方式是：(与float.hex()函数返回的结果表示形式一致)

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

• sign 可选，可以是 + 或 - ,integer 和 fraction 是十六进制数码组成的字符串，exponent 是带有可选前导符的十进制整数。
• 在 integer 或 fraction 中必须至少有一个十六进制数码。
• exponent 是十进制数而非十六进制数，它给出要与系数相乘的 2 的幂次。

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

数字类型的哈希运算

对于可能为不同类型的数字 x 和 y，要求 x == y 时 必定 hash(x) == hash(y)

迭代器类型

Python 支持在容器中进行迭代的概念。

容器对象要提供迭代支持，必须定义一个方法:

• container.__iter__() 返回一个迭代器对象

迭代器对象自身需要支持以下两个方法，它们共同组成了 迭代器协议:

• iterator.__iter__() 返回迭代器对象本身。 这是同时允许容器和迭代器配合 for 和 in 语句使用所必须的。
• iterator.__next__() 从容器中返回下一项。 如果已经没有项可返回，则会引发 StopIteration 异常。

一旦迭代器的 __next__() 方法引发了 StopIteration，它必须一直对后续调用引发同样的异常。 不遵循此行为特性的实现将无法正常使用。

生成器类型

Python 的 generator 提供了一种实现迭代器协议的便捷方式。如果容器对象 __iter__() 方法被实现为一个生成器，它将自动返回一个迭代器对象（从技术上说是一个生成器对象），该对象提供 __iter__() 和 __next__() 方法。

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

有三种基本序列类型：list, tuple 和 range 对象。

通用序列操作

大多数序列类型，包括可变类型和不可变类型都支持下表中的操作。

以下表格按优先级升序列出了序列操作。（表格中s 和 t 是具有相同类型的序列，n, i, j 和 k 是整数而 x 是任何满足 s 所规定的类型和值限制的任意对象。）

• in 和 not in 操作具有与比较操作相同的优先级。
• + (拼接) 和 * (重复) 操作具有与对应数值运算相同的优先级。

运算	结果	注释
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 或 n * s	相当于 s 与自身进行 n 次拼接	(2)(7)
s[i]	s 的第 i 项，起始为 0	(3)
s[i:j]	s 从 i 到 j 的切片	(3)(4)
s[i:j:k]	s 从 i 到 j 步长为 k 的切片	(3)(5)
len(s)	s 的长度
min(s)	s 的最小项
max(s)	s 的最大项
s.index(x[, i[, j]])	x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）	(8)
s.count(x)	s.count(x)

相同类型的序列也支持比较。 特别地，tuple 和 list 的比较是通过比较对应元素的字典顺序。 这就表示着想要比较结果相等，则每个元素比较结果都必须相等，并且两个序列长度必须相同。

注释：

1. 虽然 in 和 not in 操作在通常情况下仅被用于简单的成员检测，但对于某些专门化序列 (例如 str, bytes 和 bytearray) 也使用它们进行子序列检测:

>>> "gg" in "eggs"
True

1. 小于 0 的 n 值会被当作 0 来处理 (生成一个与 s 同类型的空序列)。需要注意的是序列 s 中的项并不会被拷贝；它们会被多次引用，例如：

>>> lists = [[]] * 3  # [[]] 是一个包含了一个空列表的单元素列表，所以 [[]] * 3 结果中的三个元素都是对这一个空列表的引用。
>>> lists
[[], [], []]
>>> lists[0].append(3)  # 修改 lists 中的任何一个元素实际上都是对这一个空列表的修改。
>>> lists
[[3], [3], [3]]
# 可以用以下方法创建以不同列表为元素的列表:
>>> lists = [[] for i in range(3)]
>>> lists[0].append(3)
>>> lists[1].append(5)
>>> lists[2].append(7)
>>> lists
[[3], [5], [7]]

1. 如果 i 或 j 为负值，则索引顺序是相对于序列 s 的末尾: 索引号会被替换为 len(s) + i 或 len(s) + j。 但要注意 -0 仍然为 0。

2. s 从 i 到 j的切片被定义为所有满足 i <= k < j 的索引号 k 的项组成的序列。 如果 i 或 j 大于 len(s)，则使用 len(s).
   
   如果 i 被省略或为 None，则使用 0。 如果 j 被省略或为 None，则使用 len(s)。 如果 i 大于等于 j，则切片为空。

3. s 从 i 到 j 步长为 k 的切片被定义为所有满足 0 <= n < (j-i)/k 的索引号 x = i + nk 的项组成的序列。换句话说，索引号为 i, i+k, i+2k, i+3*k，以此类推，当达到 j 时停止 (但一定不包括 j)。请注意，k 不可为零。 如果 k 为 None，则当作 1 处理。

4. 拼接不可变序列会生成新的对象。这意味着通过重复拼接来构建序列的运行时开销将会基于序列总长度的乘方。可以改用以下方法代替:

• 如果拼接 str 对象，你可以构建一个列表并在最后使用 str.join()
• 如果拼接 bytes 对象，你可以类似地使用 bytes.join(), 或者你也可以使用 bytearray 对象进行原地拼接。 bytearray 对象是可变的，并且具有高效的重分配机制
• 如果拼接 tuple 对象，请改为扩展 list 类

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

2. 当 x 在 s 中找不到时 index 会引发 ValueError。

不可变序列类型

支持对内置函数hash()的支持，尝试对包含有不可哈希值的不可变序列进行哈希运算将会导致 TypeError。

可变序列类型

以下表格中的操作是在可变序列类型上定义的。表格中的 s 是可变序列类型的实例，t 是任意可迭代对象，而 x 是符合对 s 所规定类型与值限制的任何对象

运算	结果	注释
s[i] = x	将 s 的第 i 项替换为 x
s[i:j] = t	将 s 从 i 到 j 的切片替换为可迭代对象 t 的内容
del s[i:j]	删除 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)] = 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()	就地将列表中的元素逆序	4

注释：

1. t 必须与它所替换的切片具有相同的长度
2. 可选参数 i 默认为 -1，因此在默认情况下会移除并返回最后一项。
3. 当在 s 中找不到 x 时 remove 操作会引发 ValueError
4. 当反转大尺寸序列时 reverse() 方法会原地修改该序列以保证空间经济性
5. 包含 clear() 和 copy() 函数是为了与不支持切片操作的可变容器的接口保持一致
6. n 值为一个整数，或是一个实现了 __index__() 的对象。n 值为零或负数将清空序列,序列中的项不会被拷贝,它们会被多次引用。

列表

列表是可变序列，通常用于存放同类项目的集合

class list([iterable])

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

• 使用一对方括号来表示空列表: []
• 使用方括号，其中的项以逗号分隔: [a], [a, b, c]
• 使用列表推导式: [x for x in iterable]
• 使用类型的构造器: list() 或 list(iterable)

构造器将构造一个列表，其中的项与 iterable 中的项具有相同的的值与顺序。

iterable 可以是序列、支持迭代的容器或其它可迭代对象。

如果 iterable 已经是一个列表，将创建并返回其副本，类似于 iterable[:]。

>>> list('abc')
['a', 'b', 'c']
>>> list((1, 2, 3))
[1, 2, 3]
>>> list()
[]

列表实现了所有 一般 和 可变 序列的操作。 列表还额外提供了以下方法：

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

此方法会对列表进行原地排序

key参数 指定带有一个参数的函数，用于从每个列表元素中提取比较键 (例如 key=str.lower)。默认值 None 表示直接对列表项排序而不计算一个单独的键值。

reverse参数 为一个布尔值。 如果设为 True，则每个列表元素将按反向顺序比较进行排序。

当排序大尺寸序列时此方法会原地修改该序列以保证空间经济性。

元祖

元组是不可变序列，通常用于储存异构数据的多项集

class tuple([iterable])

可以用以下多种方式构建元组：

• 使用一对圆括号来表示空元组: ()
• 使用一个后缀的逗号来表示单元组: a, 或 (a,) 但不能仅表示为(a)
• 使用以逗号分隔的多个项: a, b, c or (a, b, c)
• 使用内置的 tuple(): tuple() 或 tuple(iterable)

构造器将构造一个元组，其中的项与 iterable 中的项具有相同的值与顺序。

元组实现了所有 一般 序列的操作。

iterable 可以是序列、支持迭代的容器或其它可迭代对象。

如果 iterable 已经是一个元组，会不加改变地将其返回。

 >>> tuple('abc')
('a', 'b', 'c')
>>> tuple( [1, 2, 3] )
(1, 2, 3)
>>> tuple()
()

需要注意的是决定生成元组的其实是逗号而不是圆括号。 圆括号只是可选的，生成空元组或需要避免语法歧义的情况除外。

range 对象

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

class range(stop)

class range(start, stop[, step])

range 构造器的参数必须为整数（可以是内置的 int 或任何实现了 __index__ 特殊方法的对象）

如果省略 step 参数，其默认值为 1。 如果省略 start 参数，其默认值为 0，如果 step 为零则会引发 ValueError。

一些 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))
[]

range 对象实现了 一般 序列的所有操作，但拼接和重复除外

range 类型相比常规 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

使用 == 和 != 检测 range 对象是否相等是将其作为序列来比较。 也就是说，如果两个 range 对象表示相同的值序列就认为它们是相等的。

例如：

>>> range(0) == range(2, 1, 3)
True
>>> range(0, 3, 2) == range(0, 4, 2)
True

文本序列类型 --- str

在 Python 中处理文本数据是使用 str 对象，也称为 字符串。字符串 是由 Unicode 码位构成的不可变序列。字符串 字面值有以下多种不同的写法：

• 单引号 : '允许包含有 "双" 引号'
• 双引号 : "允许包含有 '单' 引号"
• 三重引号 : '''三重单引号''', """三重双引号"""(使用三重引号的字符串可以跨越多行 —— 其中所有的空白字符都将包含在该字符串字面值中。)

只由空格分隔的多个字符串字面值会被隐式地转换为单个字符串字面值。

>>> ("spam " "eggs") == "spam eggs"
True

字符串 也可以通过使用 str 构造器从其他对象创建。

由于不存在单独的“字符”类型，对 字符串 做 索引操作 将产生一个长度为 1 的 字符串。 也就是说，对于一个非空字符串 s, s[0] == s[0:1]。

不存在可变的字符串类型，但是 str.join() 或 io.StringIO 可以被被用来根据多个片段高效率地构建字符串。

class str(object='')

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

返回 object 的 字符串 版本。 如果未提供 object 则返回空字符串。

如果 encoding参数 或 errors参数 均未给出，str(object) 返回 object.__str__()。对于字符串对象，这是该字符串本身。 如果 object 没有 __str__() 方法，则 str() 将回退为返回 repr(object)。

如果 encoding参数 或 errors参数 至少给出其中之一，则 object 应该是一个 bytes-like object (例如 bytes 或 bytearray)。如果 object 是一个 bytes (或 bytearray) 对象，则 str(bytes, encoding, errors) 等价于 bytes.decode(encoding, errors)。

将一个 bytes 对象传入 str() 而不给出 encoding参数 或 errors参数 的操作属于第一种情况， 将返回非正式 的字符串 表示,例如：

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

字符串的方法

字符串实现了所有 一般 序列的操作，还额外提供了以下列出的一些附加方法。

str.capitalize()

返回原字符串的副本，其首个字符大写，其余为小写。

>>> ('jack').capitalize()
'Jack'

str.casefold()

返回原字符串消除大小写的副本。 消除大小写的字符串可用于忽略大小写的匹配。

>>> ('Jack').casefold()
'jack'

str.center(width[, fillchar])

返回长度为 width参数 的字符串，原字符串在其正中。使用指定的 fillchar 填充两边的空位

如果 width参数 小于等于 len(s) 则返回原字符串的副本。

>>> ('Jack').center(10, "*")
'***Jack***'
>>> ('Jack').center(3)
'Jack'

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

返回子字符串 sub参数 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。

>>> ('Jaccck').count("c")
3
>>> ('Jaccck').count("c", 0, 4)
2

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

返回原字符串编码为字节串对象的版本。 默认编码为 'utf-8'。

可以给出 errors参数 来设置不同的错误处理方案。 errors 的默认值为 'strict'，表示编码错误会引发 UnicodeError。

>>> ('Jack').encode()
b'Jack'

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

如果字符串以指定的 suffix参数 结束返回 True，否则返回 False。

suffix参数 也可以为由多个供查找的后缀构成的元组。

如果有可选项 start，将从指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

>>> ('Jack').endswith('k')
True
>>> ('Jack').endswith(('w', 's', 'm', 'a'))
False
>>> ('Jack').endswith(('w', 's', 'm', 'a'), 0, 2)  # 元祖里面包含尾字符
True

str.expandtabs(tabsize=8)

返回字符串的副本，其中所有的制表符会由一个或多个空格替换，具体取决于当前列位置和给定的制表符宽度。每 tabsize参数 个字符设为一个制表位，用空格补充（默认值 8 时设定的制表位在列 0, 8, 16 依次类推）

>>> '01\t012\t0123\t01234'.expandtabs()
'01      012     0123    01234'  # 默认参数为8，首位为0，8，16...其余用空格替换
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01  012 0123    01234'  # 设置参数为4，首位为0，4，8...其余用空格替代

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

返回子字符串 sub参数 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。

str.format(*args, **kwargs)

执行字符串格式化操作。调用此方法的字符串可以包含字符串字面值和以花括号 {} 括起来的替换域。每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。

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

str.format_map(mapping)

类似于 str.format(**mapping)，不同之处在于 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'

>>> a = {'name': 'Jack', 'age': '22'}
>>> ('{name} is {age} years old').format_map(a)
'Jack is 22 years old'

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

类似于 find()，但在找不到子类时会引发 ValueError。

>>> ('Jaccck').index('c')
2
>>> ('Jaccck').index('c', 4, )
4
>>> ('Jaccck').index('c', 5, -1)
ValueError: substring not found

str.isalnum()

如果字符串中至少有一个字符且所有字符均为字母或数字则返回真值，否则返回假值。

>>> ('123wearefamily').isalnum()
True
>>> ('123 we are family').isalnum()  # 包含空格
False

str.isalpha()

如果字符串中至少有一个字符且所有字符均为字母则返回真值，否则返回假值。

>>> ('123wearefamily').isalpha()
False
>>> ('wearefamily').isalpha()
True

str.isascii()

如果字符串为空或所有字符均为 ASCII 字符则返回真值，否则返回假值。需要注意的是，此函数是3.7的新版功能，之前版本会报错

str.isdecimal()

如果字符串中至少有一个字符且所有字符均为十进制数字符则返回真值，否则返回假值。

>>> ('123wearefamily').isdecimal()
False
>>> ('123').isdecimal()
True

str.isdigit()

如果字符串中至少有一个字符且所有字符均为数字字符则返回真值，否则返回假值。数字字符包括十进制数字符和需要特别处理的数字。用法与 isascii() 类似。

str.isidentifier()

如果字符串根据语言定义属于有效的标识符则返回真值，否则返回假值。

>>> ('if').isidentifier()
True
>>> ('def').isidentifier()
True
>>> ('123bala').isidentifier()
False

str.islower()

检测字符串是否都为小写

如果字符串中至少有一个区分大小写的字符且此类字符均为小写则返回真值，否则返回假值。

>>> ('Petter').islower()
False
>>> ('i have a letter' ).islower()
True

str.isnumeric()

如果字符串中至少有一个字符且所有字符均为数值字符则返回真值，否则返回假值。数值字符包括数字字符，以及所有在 Unicode 中设置了数值特性属性的字符

对于 Unicode 数字、全角数字（双字节）、罗马数字和汉字数字会返回 True ，其他会返回 False

定义一个字符串为Unicode，只需要在字符串前添加 'u' 前缀即可

>>> (u"wearefamily").isnumeric()
False
>>> ("21243").isnumeric()
True
>>> ("一二三").isnumeric()
True

str.isprintable()

如果字符串中所有字符均为可打印字符或字符串为空则返回真值，否则返回假值。

>>> ('123\t456').isprintable()
False
>>> ('').isprintable()
True
>>> ('123456').isprintable()
True

str.isspace()

如果字符串中至少有一个字符且所有字符均为空白字符则返回真值，否则返回假值。

>>> ('      ').isspace()
True
>>> ('This is string example').isspace()
False

str.istitle()

如果字符串中至少有一个字符且为标题字符串则返回真值。

>>> ('This').istitle()
True
>>> ('this').istitle()
False
>>> ('THIS').istitle()
False

str.isupper()

检测字符串中所有的字母是否都为大写

如果字符串中至少有一个区分大小写的字符且此类字符均为大写则返回真值，否则返回假值。

>>> ('This is string example').isupper()
False
>>> ('THIS IS STRING EXAMPLE').isupper()
True

str.join(iterable)

返回一个由 iterable 中的字符串元素以指定字符拼接而成的字符串。如果 iterable 存在非字符串值则会引发 TypeError

>>> ('-').join(("father", "mother", "son", "grandfather", "grandmother"))
'father-mother-son-grandfather-grandmother'

str.ljust(width[, fillchar])

返回长度为 width参数 的字符串，原字符串在其中靠左对齐

使用指定的 fillchar参数 填充空位 (默认使用 ASCII 空格符)

如果 width参数 小于等于 len(s) 则返回原字符串的副本。

>>> ('Jack').ljust(12, '-')
'Jack--------'

str.lower()

返回原字符串的副本，其所有区分大小写的字符均转换为小写。

>>> ("Jack").lower()
'jack'

str.lstrip([chars])

返回原字符串的副本，移除其中的前导字符。

chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。

>>> '   spacious   '.lstrip()
'spacious   '
>>> 'www.example.com'.lstrip('cmowz.')  # 指定需要移除的字符串的集合
'example.com'

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

此静态方法返回一个可供 str.translate() 使用的转换对照表。

如果只给出一个参数，则必须为一个字典

如果给出两个参数，则必须是长度一致的字符串，并且 x 中的每个字符都被映射为 y 中相同位置的字符

如果给出三个参数，则第三个参数表示需要删除的字符串

>>> trans = ("Jack").maketrans({'a':'2'})
>>> ("Jack").translate(trans)
'J2ck'
trans = ('Jack').maketrans('ac', 'ca')
>>> ("Jack").translate(trans)
'Jcak'
>>> trans = ('Jack').maketrans('ac', 'ca', 'k')
>>> ("Jack").translate(trans)
'Jca'

str.partition(sep)

在 sep 首次出现的位置拆分字符串，返回一个 3 个元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。

如果分隔符未找到，则返回的 3 个元组中包含字符本身以及两个空字符串。

>>> 'Jcaaak'.partition('a')
('Jc', 'a', 'aak')

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

返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。

>>> 'Jcaaak'.replace('a', '0', 2)
'Jc00ak'

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

返回子字符串 sub 在字符串内被找到的最大索引

sub 将包含在 s[start:end] 当中

如果未找到 sub 则返回 -1。

>>> 'Jcaaak'.rfind('a', 0, -1)  # 返回最后一个的索引
4

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

类似于 rfind()，但在子字符串 sub 未找到时会引发 </font color=red>ValueError。

>>> 'Jcaaak'.rindex('a', 0, -1)
4
>>> 'Jcaaak'.rindex('b', 0, -1)
ValueError: substring not found

str.rjust(width[, fillchar])

返回长度为 width 的字符串，原字符串在其中</font color=red>靠右对齐。 使用指定的 fillchar 填充</font color=red>空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。

>>> ('lucky').rjust(15, '+')
'++++++++++lucky'

str.rpartition(sep)

在 sep 最后一次出现的位置拆分字符串，返回一个 3 个元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。

如果分隔符未找到，则返回的 3 个元组中包含两个空字符串以及字符串本身。

>>> 'Jcaaak'.rpartition('a')
('Jcaa', 'a', 'k')

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

返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串，类似于 split() 函数，只不过是从最右端开始分割。

如果 sep 未指定或为 None，任何空白字符串都会被作为分隔符。

如果给出了 maxsplit，则最多进行 maxsplit 次拆分

>>> '1,2,3,4,5'.rsplit(',', 3)
['1,2', '3', '4', '5']
>>> '1,2,3,4,5'.split(',', 3)
['1', '2', '3', '4,5']

str.rstrip([chars])

返回原字符串的副本，移除其中的末尾字符。chars参数 为指定要移除字符的字符串。 如果省略或为 None，则 chars参数 默认移除空格符。

>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')  # chars参数表示一个集合，以它中的任意一个结尾的都会给被移除
'mississ'

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

返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。

如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）

如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）

>>> '1,2,3'.split(',')
['1', '2', '3']
>>> '1,2,3'.split(',', maxsplit=1)
['1', '2,3']
>>> '1,2,,3,'.split(',')
['1', '2', '', '3', '']
>>> '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']

str.splitlines([keepends])

返回由原字符串中各行组成的列表，在行边界的位置拆分。

结果列表中不包含行边界，除非给出了 keepends 且为真值。

此方法会以下列表格行边界进行拆分。

标识符	描述
\n	换行
\r	回车
\r\n	回车 + 换行
\v 或 \x0b	行制表符
\f 或 \x0c	换表单
\x1c	文件分隔符
\x1d	组分隔符
\x1e	记录分隔符
\x85	下一行 (C1 控制码)
\u2028	行分隔符
\u2029	段分隔符

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

>>> "".splitlines()  # 空字符串返回一个空列表
[]
>>> "One line\n".splitlines()  # 末尾的换行不会增加新的行
['One line']

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

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

如果字符串以指定的 prefix 开始则返回 True，否则返回 False。

prefix 也可以为由多个供查找的前缀构成的元组

如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

>>> ('Jack').startswith('J')
True
>>> ('Jack').startswith(('J', 'e', 'r'),  1, -1)
False

str.strip([chars])

返回原字符串的副本，移除其中的前导和末尾字符。

chars参数 为指定要移除字符的字符串。如果省略或为 None，则 chars参数 默认移除空格符

>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')  # chars不只表示单个前缀和后缀，也表示一个集合
'example'

>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32'  # 开头或者结尾的字符在遇到未包含在内的字符串时停止

str.swapcase()

返回原字符串的副本，其中大写字符转换为小写，小写字符转换为大写

>>> ('Jack').swapcase()
'jACK'

str.title()

返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。

>>> 'jACK'.title()
'Jack'
>>> "they're bill's friends from the UK".title()  # 连续的字母组合同样被视为单词
"They'Re Bill'S Friends From The Uk"

str.translate(table)

返回原字符串的副本，其中每个字符按给定的转换表进行映射。

你可以使用 str.maketrans() 基于不同格式的字符到字符映射来创建一个转换映射表。

>>> trans = ('We are family!').maketrans('abcde', '12345')
>>> ('We are family!').translate(trans)
'W5 1r5 f1mily!'

str.upper()

返回原字符串的副本，其中所有区分大小写的字符均转换为大写。

>>> ('we are family!').upper()
'WE ARE FAMILY!'

str.zfill(width)

返回原字符串的副本，在左边填充 ASCII '0' 数码使其长度变为 width。

如果 width 小于等于 len(s) 则返回原字符串的副本。

正负值前缀 ('+'/'-') 的处理方式是在 正负符号 之后 填充而非在之前。

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

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

操作二进制数据的核心内置类型是 bytes 和 bytearray。

它们由 memoryview 提供支持，该对象使用 缓冲区协议 来访问其他二进制对象所在内存，不需要创建对象的副本。

bytes 对象

bytes 对象是由单个字节构成的不可变序列。

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

表示 bytes 字面值的语法与字符串字面值的大致相同，只是添加了一个 b 前缀：

• 单引号: b'同样允许嵌入 "双" 引号'。
• 双引号: b"同样允许嵌入 '单' 引号"。
• 三重引号: b'''三重单引号''', b"""三重双引号"""

bytes 字面值中只允许 ASCII 字符，任何超出 127 的二进制值必须使用相应的转义序列形式加入 bytes 字面值。

像字符串字面值一样，bytes 字面值也可以使用 r 前缀来禁用转义序列处理。

除了字面值形式，bytes 对象还可以通过其他几种方式来创建：

• 指定长度的以零值填充的 bytes 对象: bytes(10)
• 通过由整数组成的可迭代对象: bytes(range(20))
• 通过缓冲区协议复制现有的二进制数据: bytes(obj)

由于两个十六进制数码精确对应一个字节，因此十六进制数是描述二进制数据的常用格式。

相应地，bytes 类型具有从此种格式读取数据的附加类方法：

classmethod fromhex(string)

此 bytes 类方法返回一个解码给定字符串的 bytes 对象。

字符串必须由表示每个字节的两个十六进制数构成，其中的 ASCII 空白符会被忽略。

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

存在一个反向转换函数，可以将 bytes 对象转换为对应的十六进制表示。

hex()

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

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

由于 bytes 对象是由整数构成的序列（类似于元组），因此对于一个 bytes 对象 b，b[0] 将为一个整数，而 b[0:1] 将为一个长度为 1 的 bytes 对象。

bytearray 对象

bytearray 对象是 bytes 对象的可变对应物。

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

bytearray 对象没有专属的字面值语法，它们总是通过调用构造器来创建：

• 创建一个空实例: bytearray()
• 创建一个指定长度的以零值填充的实例: bytearray(10)
• 通过由整数组成的可迭代对象: bytearray(range(20))
• 通过缓冲区协议复制现有的二进制数据: bytearray(b'Hi!')

由于 bytearray 对象是可变的，该对象除了 bytes 和 bytearray 操作 中所描述的 bytes 和 bytearray 共有操作之外，还支持 可变 序列操作。

classmethod fromhex(string)

bytearray 类方法返回一个解码给定字符串的 bytearray 对象。

字符串必须由表示每个字节的两个十六进制数构成，其中的 ASCII 空白符会被忽略。

在 3.7 版更改: bytearray.fromhex() 现在会忽略所有 ASCII 空白符而不只是空格符。

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

存在一个反向转换函数，可以将 bytearray 对象转换为对应的十六进制表示。

hex()

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

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

bytes 和 bytearray 操作

bytes 和 bytearray 对象都支持 通用 序列操作。

bytes 和 bytearray 对象的下列方法可以用于任意二进制数据。

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

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

返回子序列 sub 在 [start, end] 范围内非重叠出现的次数。

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

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

返回从给定 bytes 解码出来的字符串。 默认编码为 'utf-8'。

可以给出 errors参数 来设置不同的错误处理方案。 errors 的默认值为 'strict'，表示编码错误会引发 UnicodeError。

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

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

如果二进制数据以指定的 suffix 结尾则返回 True，否则返回 False。

suffix参数 也可以为由多个供查找的后缀构成的元组。

如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

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

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

返回子序列 sub 在数据中被找到的最小索引，sub 包含于切片 s[start:end] 之内。

如果 sub 未被找到则返回 -1。

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

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

类似于 find()，但在找不到子序列时会引发 ValueError。

bytes.join(iterable)

bytearray.join(iterable)

返回一个由 iterable 中的二进制数据序列经 bytes 或 bytearray 拼接而成的 bytes 或 bytearray 对象。

提供该方法的 bytes 或 bytearray 对象的内容将作为元素之间的分隔。

static bytes.maketrans(from, to)

static bytearray.maketrans(from, to)

此静态方法返回一个可用于 bytes.translate() 的转换对照表，它将把 from 中的每个字符映射为 to 中相同位置上的字符，from 与 to 必须都是 字节类对象 并且具有相同的长度。

bytes.partition(sep)

bytearray.partition(sep)

在 sep 首次出现的位置拆分序列，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身或其 bytearray 副本，以及分隔符之后的部分。

如果分隔符未找到，则返回的 3 元组中包含原序列以及两个空的 bytes 或 bytearray 对象。

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

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

返回序列的副本，其中出现的所有子序列 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。

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

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

返回子序列 sub 在序列内被找到的最大的索引，sub 将包含在 s[start:end] 当中。

如果未找到则返回 -1。

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

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

类似于 rfind()，但在子序列 sub 未找到时会引发 ValueError。

bytes.rpartition(sep)

bytearray.rpartition(sep)

在 sep 最后一次出现的位置拆分序列，返回一个 3 元组，其中包含分隔符之前的部分，分隔符本身或其 bytearray 副本，以及分隔符之后的部分。

如果分隔符未找到，则返回的 3 元组中包含两个空的 bytes 或 bytearray 对象以及原序列的副本。

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

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

如果二进制数据以指定的 prefix 开头则返回 True，否则返回 False。

(prefix) 也可以为由多个供查找的前缀构成的元组。

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

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

返回原 bytes 或 bytearray 对象的副本，移除其中所有在可选参数 delete 中出现的 bytes，其余 bytes 将通过给定的转换表进行映射。

在 3.6 版更改: 支持将 delete 作为关键字参数

可以使用 bytes.maketrans() 方法来创建转换表

>>> b'read this short text'.translate(None, b'aeiou')  # 对于仅需移除字符的转换，可以将table设置为None
b'rd ths shrt txt'

bytes.center(width[, fillbyte])

bytearray.center(width[, fillbyte])

返回原对象的副本，在长度为 width 的序列内居中，使用指定的 fillbyte 填充两边的空位（默认使用 ASCII 空格符）。

对于 bytes 对象，如果 width 小于等于 len(s) 则返回原序列的副本。

此方法的 bytearray 并非 原地操作，即便没有做任何改变也会产生一个新对象。

bytes.ljust(width[, fillbyte])

bytearray.ljust(width[, fillbyte])

返回原对象的副本，在长度为 width 的序列中靠左对齐，使用指定的 fillbyte 填充空位（默认使用 ASCII 空格符）

对于 bytes 对象，如果 width 小于等于 len(s) 则返回原序列的副本

此方法的 bytearray 并非 原地操作，即便没有做任何改变也会产生一个新对象。

bytes.lstrip([chars])

bytearray.lstrip([chars])

返回原序列的副本，移除指定的前导字节。

(chars) 参数为指定要移除字节值集合的二进制序列，如果省略或为 None，则 chars 参数默认移除 ASCII 空白符。

(chars) 参数并非指定单个前缀；而是会移除参数值的所有组合

此方法的 bytearray 并非 原地操作，即便没有做任何改变也会产生一个新对象。

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

bytes.rjust(width[, fillbyte])

bytearray.rjust(width[, fillbyte])

返回原对象的副本，在长度为 width 的序列中靠右对齐。

使用指定的 fillbyte 填充空位（默认使用 ASCII 空格符）

对于 bytes 对象，如果 width 小于等于 len(s) 则返回原序列的副本。

此方法的 bytearray 并非 原地操作，即便没有做任何改变也会产生一个新对象。

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

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

将二进制序列拆分为相同类型的子序列，使用 sep 作为分隔符。

如果给出了 maxsplit参数，则最多进行 maxsplit 次拆分，从 最右边 开始。

如果 sep 未指定或为 None，任何只包含 ASCII 空白符的子序列都会被作为分隔符。

bytes.rstrip([chars])

bytearray.rstrip([chars])

返回原序列的副本，移除指定的末尾字节。

(chars) 参数为指定要移除字节值集合的二进制序列，如果省略或为 None，则 chars 参数默认移除 ASCII 空白符。

(chars) 参数并非指定单个后缀；而是会移除参数值的所有组合

此方法的 bytearray 并非 原地操作，即便没有做任何改变也会产生一个新对象。

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

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

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

将二进制序列拆分为相同类型的子序列，使用 sep 作为分隔符。

如果给出了 maxsplit 且非负值，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）

# sep指定时
>>> 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未指定时
>>> 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) 参数为指定要移除字节值集合的二进制序列,如果省略或为 None，则 chars 参数默认移除 ASCII 空白符。

(chars) 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合

此方法的 bytearray 并非 原地操作，即便没有做任何改变也会产生一个新对象。

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

bytes.capitalize()

bytearray.capitalize()

返回原序列的副本，其中每个字节将都将被解读为一个 ASCII 字符，并且第一个字节的字符大写而其余的小写。 非 ASCII 字节值将保持原样不变。

此方法的 bytearray 并非 原地操作，即便没有做任何改变也会产生一个新对象。

bytes.expandtabs(tabsize=8)

bytearray.expandtabs(tabsize=8)

返回序列的副本，其中所有的 ASCII 制表符会由一个或多个 ASCII 空格替换，具体取决于当前列位置和给定的制表符宽度。

与上文中str.expandtabs(tabsize=8) 类似，可参照对比使用

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

bytes.isalnum()

bytearray.isalnum()

如果序列中所有字节都是字母类 ASCII 字符或 ASCII 十进制数码并且序列非空则返回真值，否则返回假值。

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

bytes.isalpha()

bytearray.isalpha()

如果序列中所有字节都是字母类 ASCII 字符并且序列非空则返回真值，否则返回假值。

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

bytes.isascii()

bytearray.isascii()

如果序列为空或序列中所有字节都是 ASCII 字节则返回真值，否则返回假值。

bytes.isdigit()

bytearray.isdigit()

如果序列中所有字节都是 ASCII 十进制数码并且序列非空则返回真值，否则返回假值。

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

bytes.islower()

bytearray.islower()

如果序列中至少有一个小写 ASCII 字符并且没有大写 ASCII 字符则返回真值，否则返回假值。

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

bytes.isspace()

bytearray.isspace()

如果序列中所有字节都是 ASCII 空白符并且序列非空则返回真值，否则返回假值。

(ASCII 空白符)就是字节值包含在序列 b' \t\n\r\x0b\f' (空格, 制表, 换行, 回车, 垂直制表, 换页) 中的字符。

bytes.istitle()

bytearray.istitle()

如果序列为 ASCII 标题形式并且序列非空则返回真值，否则返回假值。

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

bytes.isupper()

bytearray.isupper()

如果序列中至少有一个大写字母 ASCII 字符并且没有小写 ASCII 字符则返回真值，否则返回假值。

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

bytes.lower()

bytearray.lower()

返回原序列的副本，其所有大写 ASCII 字符均转换为对应的小写形式。

此方法的 bytearray 并非 原地操作，即便没有做任何改变也会产生一个新对象。

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

bytes.splitlines(keepends=False)

bytearray.splitlines(keepends=False)

返回由原二进制序列中各行组成的列表，在 ASCII 行边界符的位置拆分。

结果列表中不包含换行符，除非给出了 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']

>>> b"".split(b'\n'), b"Two lines\n".split(b'\n')  #当给出 sep参数时，空字符串此方法返回一个空列表
([b''], [b'Two lines', b''])
>>> b"".splitlines(), b"One line\n".splitlines()
([], [b'One line'])

bytes.swapcase()

bytearray.swapcase()

返回原序列的副本，其所有小写 ASCII 字符均转换为对应的大写形式，反之亦反。

不同于 str.swapcase()，在些二进制版本下 bin.swapcase().swapcase() == bin 总是成立。

此方法的 bytearray 并非 原地操作，即便没有做任何改变也会产生一个新对象。

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

bytes.title()

bytearray.title()

返回原二进制序列的标题版本，其中每个单词以一个大写 ASCII 字符为开头，其余字母为小写。 不区别大小写的字节值将保持原样不变。

此方法的 bytearray 并非 原地操作，即便没有做任何改变也会产生一个新对象。

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

bytes.upper()

bytearray.upper()

返回原序列的副本，其所有小写 ASCII 字符均转换为对应的大写形式。

此方法的 bytearray 并非 原地操作，即便没有做任何改变也会产生一个新对象。

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

bytes.zfill(width)

bytearray.zfill(width)

返回原序列的副本，在左边填充 b'0' 数码使序列长度为 width。

对于 bytes 对象，如果 width 小于等于 len(seq) 则返回原序列。

此方法的 bytearray 并非 原地操作，即便没有做任何改变也会产生一个新对象。

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

集合类型 --- set, frozenset

set 对象是由具有唯一性的 hashable 对象所组成的无序多项集。

常见的用途包括成员检测、从序列中去除重复项以及数学中的集合类计算

作为一种无序的多项集，集合并不记录元素位置或插入顺序。 相应地，集合不支持索引、切片或其他序列类的操作。

目前有两种内置集合类型，set 和 frozenset。

set 类型是可变的 --- 其内容可以使用 add() 和 remove() 这样的方法来改变。 由于是可变类型，它没有哈希值，且不能被用作字典的键或其他集合的元素。

frozenset 类型是不可变并且具有哈希值 --- 其内容在被创建后不能再改变；因此它可以被用作字典的键或其他集合的元素。

class set([iterable])

class frozenset([iterable])

返回一个新的 set 或 frozenset 对象，其元素是一个可迭代对象。

要表示由集合对象构成的集合，所有的内层集合必须为 frozenset 对象。

如果未指定 iterable，则将返回一个新的空集合。

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

len(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(*others)

set | other | ...

返回一个新集合，其中包含来自原集合以及 others 指定的所有集合中的元素。

intersection(*others)

set & other & ...

返回一个新集合，其中包含原集合以及 others 指定的所有集合中共有的元素。

difference(*others)

set - other - ...

返回一个新集合，其中包含原集合中在 others 指定的其他集合中不存在的元素。

symmetric_difference(other)

set ^ other

返回一个新集合，其中的元素或属于原集合或属于 other 指定的其他集合，但不能同时属于两者。

copy()

返回原集合的浅拷贝。

下面列出了不应用于 frozenset 而仅运用于 set 的操作

update(*others)

set |= other | ...

更新集合，添加来自所有 others 的元素。

intersection_update(*others)

set &= other & ...

更新集合，只保留其中找到的元素和 others。

difference_update(*others)

set -= other | ...

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

symmetric_difference_update(other)

set ^= other

更新集合，只保留在两个集合中都找到的元素

add(elem)

向集合中添加元素 elem。

remove(elem)

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

discard(elem)

如果存在元素 elem，则从集合中删除它。

pop()

从集合中移除并返回某一元素。如果集合为空，则引发 KeyError。

clear()

从集合中删除所有元素。

映射类型 --- dict

映射对象将具有hash的值映射到任意对象。映射是可变的对象。目前只有一种标准映射，即dictionary。

字典的键几乎是任意值，也就是说，包含列表、字典或其他可变类型的值。

字典可以通过在大括号中放置以逗号分隔的key: value对列来创建，例如:{'jack': 4098， 'sjoerd': 4127}或{4098:'jack'， 4127: 'sjoerd'}，也可以通过dict构造函数创建。

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

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

如果没有提供位置参数，则创建一个空字典。如果给定了一个位置参数，并且它是一个映射对象，则使用与映射对象相同的键值对创建一个字典。否则，位置参数必须是一个可迭代的对象。iterable中的每个项本身必须是一个具有两个对象的iterable。

如果一个键出现多次，该键的最后一个值将成为新字典中对应的值。

如果给定关键字参数，则将关键字参数及其值添加到由位置参数创建的字典中。如果添加的键已经存在，关键字参数的值将替换位置参数的值。

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

以下是字典支持的操作：

len(d)

返回字典d中的项数。

d[key]

返回 d 中键为 key 的值。如果 key 不在映射中，则引发 KeyError

如果dict的子类定义了一个方法__missing__()，而 key 不存在，那么d[key]操作将以 key 作为参数调用该方法。如果没有定义__missing__()，则会引发KeyError。

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

d[key] = value

设置 d[key] 为 value

del d[key]

从d中删除d[key]。如果key不在映射中，则引发KeyError。

key in d

如果 d 中有键 key 则返回 True 否则返回False

key not in d

自己理解

iter(d)

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

clear()

从字典中删除所有项

copy()

返回字典的浅拷贝。

classmethod fromkeys(iterable[, value])

创建一个新字典，使用 iterable 中的键和设置为 value 的值。

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

get(key[, default])

如果 key 在字典中，则返回 key 的值，否则为 default。如果没有提供 default，则默认为 None，因此此方法不会引发 KeyError。

items()

返回字典项((键，值)对)的新视图

keys()

返回字典键的新视图。

pop(key[, default])

如果 key 在字典中，删除它并返回它的值，否则返回 default。如果没有给出 default，并且 key 不在字典中，则会引发 KeyError。

popitem()

从字典中删除并返回一个(键，值)对。此对按后进先出顺序返回。如果字典是空的，调用popitem()将引发一个KeyError。

setdefault(key[, default])

如果字典存在键 key ，返回它的值。如果不存在，插入值为 default 的键 key ，并返回 default 。 default 默认为 None。

update([other])

使用其他键/值对更新字典，覆盖现有键。返回None。

values()

返回字典值的新视图。

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

模块

模块上唯一的特殊操作是属性访问: m.name，其中 m 是模块，name 访问 m 的符号表中定义的名称。模块属性可以分配。(注意 <font color=orangeimport 语句严格来说不是对模块对象的操作;import foo 不需要一个名为foo 的模块对象，而是需要一个名为foo的模块的(外部)定义。

每个模块的一个特殊属性是__dict__。这是包含模块符号表的字典。修改这个字典实际上会改变模块的符号表，但是不能直接赋值给__dict__属性(您可以编写m.__dict__['a'] = 1，这定义了m.a等于1，但是你不能写m.__dict__ = {})。不建议直接修改__dict__。

函数

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

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

方法

方法是使用属性符号调用的函数。有两种方法:内置方法(如列表上的append())和类实例方法。

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

Type 对象

Type 对象表示各种对象类型。对象的 Type 由内置函数 type() 访问。对于类型没有特殊的操作。标准模块类型为所有标准内置类型定义了名称。

Type 的编写方式为：<class 'int'>

Null 对象

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

Ellipsis 对象

这个对象是常用的切片。它不支持任何特殊操作。只有一个名为 Ellipsis (一个内置名称)的省略号对象。类型(Ellipsis)()生成 Ellipsis 单例。

它被写为：Ellipsis 或者 ....。

特殊属性

object.__dict__

字典或其他映射对象，用于存储对象的(可写的)属性

instance.__class__

返回类实例所属的类。

class.__bases__

类对象的基类的元组。

definition.__name__

类、函数、方法、描述符或生成器实例的名称。

definition.__qualname__

类、函数、方法、描述符或生成器实例的限定名。

class.__mro__

此属性是一个类元组，在方法解析期间查找基类时将考虑这些类。

class.mro()

元类可以覆盖此方法，以自定义其实例的方法解析顺序。它在类实例化时调用，其结果存储在_mro__中。

class.__subclasses__()

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

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