Python标准库---1三、内置类型：二进制序列类型 ( bytes, bytearray)

时间 2019-12-12

标签 python 标准内置类型二进制序列 bytes bytearray 栏目 Python 繁體版

原文原文链接

上一篇文章： Python标准库---十二、内置类型:文本序列类型（str）
下一篇文章：

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

操做二进制数据的核心内置类型是 bytes 和 bytearray。它们由 memoryview 提供支持，该对象使用缓冲区协议来访问其余二进制对象所在内存，不须要建立对象的副本。git

array 模块支持高效地存储基本数据类型，例如 32 位整数和 IEEE754 双精度浮点值。正则表达式

bytes 对象

bytes 对象是由单个字节构成的不可变序列。因为许多主要二进制协议都基于 ASCII 文本编码，所以 bytes 对象提供了一些仅在处理 ASCII 兼容数据时可用，而且在许多特性上与字符串对象紧密相关的方法。算法

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

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

    单引号: b'一样容许嵌入 "双" 引号'。

    双引号: b"一样容许嵌入 '单' 引号"。

    三重引号: b'''三重单引号''', b"""三重双引号"""

bytes 字面值中只容许 ASCII 字符（不管源代码声明的编码为什么）。 任何超出 127 的二进制值必须使用相应的转义序列形式加入 bytes 字面值。

像字符串字面值同样，bytes 字面值也可使用 r 前缀来禁用转义序列处理。 请参阅 字符串和字节串字面值 了解有关各类 bytes 字面值形式的详情，包括所支持的转义序列。

虽然 bytes 字面值和表示法是基于 ASCII 文本的，但 bytes 对象的行为实际上更像是不可变的整数序列，序列中的每一个值的大小被限制为 0 <= x < 256 (若是违反此限制将引起 ValueError)。 这种限制是有意设计用以强调如下事实，虽然许多二进制格式都包含基于 ASCII 的元素，能够经过某些面向文本的算法进行有用的操做，但状况对于任意二进制数据来讲一般却并不是如此（盲目地将文本处理算法应用于不兼容 ASCII 的二进制数据格式每每将致使数据损坏）。

除了字面值形式，bytes 对象还能够经过其余几种方式来建立：

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

另请参阅 bytes 内置类型。

因为两个十六进制数码精确对应一个字节，所以十六进制数是描述二进制数据的经常使用格式。相应地，bytes 类型具备今后种格式读取数据的附加类方法：api

classmethod fromhex(string)

此 bytes 类方法返回一个解码给定字符串的 bytes 对象。 字符串必须由表示每一个字节的两个十六进制数码构成，其中的 ASCII 空白符会被忽略。

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

    在 3.7 版更改: bytes.fromhex() 如今会忽略全部 ASCII 空白符而不仅是空格符。

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

hex()

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

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

    3.5 新版功能.

因为 bytes 对象是由整数构成的序列（相似于元组），所以对于一个 bytes 对象 b，b[0] 将为一个整数，而 b[0:1] 将为一个长度为 1 的 bytes 对象。（这与文本字符串不一样，索引和切片所产生的将都是一个长度为 1 的字符串）。数组

bytes 对象的表示使用字面值格式 (b'...')，由于它一般都要比像 bytes([46, 46, 46]) 这样的格式更好用。你老是可使用 list(b) 将 bytes 对象转换为一个由整数构成的列表。函数

注解this

针对 Python 2.x 用户的说明：在 Python 2.x 系列中，容许 8 位字符串（ 2.x 所提供的最接近内置二进制数据类型的对象）与 Unicode 字符串进行各类隐式转换。这是为了实现向下兼容的变通作法，以适应 Python 最初只支持 8 位文本而 Unicode 文本是后来才被加入这一事实。在 Python 3.x 中，这些隐式转换已被取消 —— 8 位二进制数据与 Unicode 文本间的转换必须显式地进行，bytes 与字符串对象的比较结果将老是不相等。编码

bytearray 对象

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

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

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

建立一个空实例: bytearray()
建立一个指定长度的以零值填充的实例: bytearray(10)
经过由整数组成的可迭代对象: bytearray(range(20))
经过缓冲区协议复制现有的二进制数据: bytearray(b'Hi!')
因为 bytearray 对象是可变的，该对象除了 bytes 和 bytearray 操做中所描述的 bytes 和 bytearray 共有操做以外，还支持可变序列操做。

另请参见 bytearray 内置类型。

因为两个十六进制数码精确对应一个字节，所以十六进制数是描述二进制数据的经常使用格式。相应地，bytearray 类型具备今后种格式读取数据的附加类方法：

classmethod fromhex(string)

bytearray 类方法返回一个解码给定字符串的 bytearray 对象。 字符串必须由表示每一个字节的两个十六进制数码构成，其中的 ASCII 空白符会被忽略。

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

在 3.7 版更改: bytearray.fromhex() 如今会忽略全部 ASCII 空白符而不仅是空格符。

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

hex()

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

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

3.5 新版功能.

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

bytearray 对象的表示使用 bytes 对象字面值格式 (bytearray(b'...'))，由于它一般都要比 bytearray([46, 46, 46]) 这样的格式更好用。你老是可使用 list(b) 将 bytearray 对象转换为一个由整数构成的列表。

bytes 和 bytearray 操做

bytes 和 bytearray 对象都支持通用序列操做。它们不只能与相同类型的操做数，也能与任何 bytes-like object 进行互操做。因为这样的灵活性，它们能够在操做中自由地混合而不会致使错误。可是，操做结果的返回值类型可能取决于操做数的顺序。

注解

bytes 和 bytearray 对象的方法不接受字符串做为其参数，就像字符串的方法不接受 bytes 对象做为其参数同样。例如，你必须使用如下写法:

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

和:

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

某些 bytes 和 bytearray 操做假定使用兼容 ASCII 的二进制格式，所以在处理任意二进数数据时应当避免使用。这些限制会在下文中说明。

注解

使用这些基于 ASCII 的操做来处理未以基于 ASCII 的格式存储的二进制数据可能会致使数据损坏。

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

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

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

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

要搜索的子序列能够是任意 bytes-like object 或是 0 至 255 范围内的整数。

在 3.3 版更改: 也接受 0 至 255 范围内的整数做为子序列。

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

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

返回从给定 bytes 解码出来的字符串。 默认编码为 'utf-8'。 能够给出 errors 来设置不一样的错误处理方案。 errors 的默认值为 'strict'，表示编码错误会引起 UnicodeError。 其余可用的值为 'ignore', 'replace' 以及任何其余经过 codecs.register_error() 注册的名称，请参阅 Error Handlers 小节。 要查看可用的编码列表，请参阅 标准编码 小节。

注解

将 encoding 参数传给 str 容许直接解码任何 bytes-like object，无须建立临时的 bytes 或 bytearray 对象。

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

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

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

若是二进制数据以指定的 suffix 结束则返回 True，不然返回 False。 suffix 也能够为由多个供查找的后缀构成的元组。 若是有可选项 start，将从所指定位置开始检查。 若是有可选项 end，将在所指定位置中止比较。

要搜索的后缀能够是任意 bytes-like object。

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

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

返回子序列 sub 在数据中被找到的最小索引，sub 包含于切片 s[start:end] 以内。 可选参数 start 与 end 会被解读为切片表示法。 若是 sub 未被找到则返回 -1。

要搜索的子序列能够是任意 bytes-like object 或是 0 至 255 范围内的整数。

注解

find() 方法应该只在你须要知道 sub 所在位置时使用。 要检查 sub 是否为子串，请使用 in 操做符:

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

在 3.3 版更改: 也接受 0 至 255 范围内的整数做为子序列。

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

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

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

要搜索的子序列能够是任意 bytes-like object 或是 0 至 255 范围内的整数。

在 3.3 版更改: 也接受 0 至 255 范围内的整数做为子序列。

bytes.join(iterable)

bytearray.join(iterable)

返回一个由 iterable 中的二进制数据序列拼接而成的 bytes 或 bytearray 对象。 若是 iterable 中存在任何非 字节类对象 包括存在 str 对象值则会引起 TypeError。 提供该方法的 bytes 或 bytearray 对象的内容将做为元素之间的分隔。

static bytes.maketrans(from, to)

static bytearray.maketrans(from, to)

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

3.1 新版功能.

bytes.partition(sep)

bytearray.partition(sep)

在 sep 首次出现的位置拆分序列，返回一个 3 元组，其中包含分隔符以前的部分、分隔符自己或其 bytearray 副本，以及分隔符以后的部分。 若是分隔符未找到，则返回的 3 元组中包含原序列以及两个空的 bytes 或 bytearray 对象。

要搜索的分隔符能够是任意 bytes-like object。

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

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

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

要搜索的子序列及其替换序列能够是任意 bytes-like object。

注解

此方法的 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]])

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

要搜索的子序列能够是任意 bytes-like object 或是 0 至 255 范围内的整数。

在 3.3 版更改: 也接受 0 至 255 范围内的整数做为子序列。

bytes.rpartition(sep)

bytearray.rpartition(sep)

在 sep 最后一次出现的位置拆分序列，返回一个 3 元组，其中包含分隔符以前的部分，分隔符自己或其 bytearray 副本，以及分隔符以后的部分。 若是分隔符未找到，则返回的 3 元组中包含两个空的 bytes 或 bytearray 对象以及原序列的副本。

要搜索的分隔符能够是任意 bytes-like object。

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

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

若是二进制数据以指定的 prefix 开头则返回 True，不然返回 False。 prefix 也能够为由多个供查找的前缀构成的元组。 若是有可选项 start，将从所指定位置开始检查。 若是有可选项 end，将在所指定位置中止比较。

要搜索的前缀能够是任意 bytes-like object。

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

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

返回原 bytes 或 bytearray 对象的副本，移除其中全部在可选参数 delete 中出现的 bytes，其他 bytes 将经过给定的转换表进行映射，该转换表必须是长度为 256 的 bytes 对象。

你可使用 bytes.maketrans() 方法来建立转换表。

对于仅需移除字符的转换，请将 table 参数设为 None:

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

在 3.6 版更改: 如今支持将 delete 做为关键字参数。

如下 bytes 和 bytearray 对象的方法的默认行为会假定使用兼容 ASCII 的二进制格式，但经过传入适当的参数仍然可用于任意二进制数据。请注意本小节中全部的 bytearray 方法都不是原地执行操做，而是会产生新的对象。

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 参数为指定要移除字节值集合的二进制序列 —— 这个名称代表此方法一般是用于 ASCII 字符。 若是省略或为 None，则 chars 参数默认移除 ASCII 空白符。 chars 参数并不是指定单个前缀；而是会移除参数值的全部组合:

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

要移除的字节值二进制序列能够是任意 bytes-like object。

注解

此方法的 bytearray 版本 并不是 原地操做 —— 它老是产生一个新对象，即使没有作任何改变。

bytes.rjust(width[, fillbyte])

bytearray.rjust(width[, fillbyte])

返回原对象的副本，在长度为 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 空白符的子序列都会被做为分隔符。 除了从右边开始拆分，rsplit() 的其余行为都相似于下文所述的 split()。

bytes.rstrip([chars])

bytearray.rstrip([chars])

返回原序列的副本，移除指定的末尾字节。 chars 参数为指定要移除字节值集合的二进制序列 —— 这个名称代表此方法一般是用于 ASCII 字符。 若是省略或为 None，则 chars 参数默认移除 ASCII 空白符。 chars 参数并不是指定单个后缀；而是会移除参数值的全部组合:

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

要移除的字节值二进制序列能够是任意 bytes-like object。

注解

此方法的 bytearray 版本 并不是 原地操做 —— 它老是产生一个新对象，即使没有作任何改变。

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

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

将二进制序列拆分为相同类型的子序列，使用 sep 做为分隔符。 若是给出了 maxsplit 且非负值，则最多进行 maxsplit 次拆分（所以，列表最多会有 maxsplit+1 个元素）。 若是 maxsplit 未指定或为 -1，则不限制拆分次数（进行全部可能的拆分）。

若是给出了 sep，则连续的分隔符不会被组合在一块儿而是被视为分隔空子序列 (例如 b'1,,2'.split(b',') 将返回 [b'1', b'', b'2'])。 sep 参数可能为一个多字节序列 (例如 b'1<>2<>3'.split(b'<>') 将返回 [b'1', b'2', b'3'])。 使用指定的分隔符拆分空序列将返回 [b''] 或 [bytearray(b'')]，具体取决于被拆分对象的类型。 sep 参数能够是任意 bytes-like object。

例如:

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

若是 sep 未指定或为 None，则会应用另外一种拆分算法：连续的 ASCII 空白符会被视为单个分隔符，其结果将不包含序列开头或末尾的空白符。 所以，在不指定分隔符的状况下对空序列或仅包含 ASCII 空白符的序列进行拆分将返回 []。

例如:

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

bytes.strip([chars])

bytearray.strip([chars])

返回原序列的副本，移除指定的开头和末尾字节。 chars 参数为指定要移除字节值集合的二进制序列 —— 这个名称代表此方法一般是用于 ASCII 字符。 若是省略或为 None，则 chars 参数默认移除 ASCII 空白符。 chars 参数并不是指定单个前缀或后缀；而是会移除参数值的全部组合:

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

要移除的字节值二进制序列能够是任意 bytes-like object。

注解

此方法的 bytearray 版本 并不是 原地操做 —— 它老是产生一个新对象，即使没有作任何改变。

如下 bytes 和 bytearray 对象的方法会假定使用兼容 ASCII 的二进制格式，不该当被应用于任意二进制数据。请注意本小节中全部的 bytearray 方法都不是原地执行操做，而是会产生新的对象。

bytes.capitalize()

bytearray.capitalize()

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

注解

此方法的 bytearray 版本 并不是 原地操做 —— 它老是产生一个新对象，即使没有作任何改变。

bytes.expandtabs(tabsize=8)

bytearray.expandtabs(tabsize=8)

返回序列的副本，其中全部的 ASCII 制表符会由一个或多个 ASCII 空格替换，具体取决于当前列位置和给定的制表符宽度。 每 tabsize 个字节设为一个制表位（默认值 8 时设定的制表位在列 0, 8, 16 依次类推）。 要展开序列，当前列位置将被设为零并逐一检查序列中的每一个字节。 若是字节为 ASCII 制表符 (b'\t')，则并在结果中插入一个或多个空格符，直到当前列等于下一个制表位。 （制表符自己不会被复制。） 若是当前字节为 ASCII 换行符 (b'\n') 或回车符 (b'\r')，它会被复制并将当前列重设为零。 任何其余字节会被不加修改地复制并将当前列加一，不论该字节值在被打印时会如何显示:

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

注解

此方法的 bytearray 版本 并不是 原地操做 —— 它老是产生一个新对象，即使没有作任何改变。

bytes.isalnum()

bytearray.isalnum()

若是序列中全部字节都是字母类 ASCII 字符或 ASCII 十进制数码而且序列非空则返回真值，不然返回假值。 字母类 ASCII 字符就是字节值包含在序列 b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。 ASCII 十进制数码就是字节值包含在序列 b'0123456789' 中的字符。

例如:

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

bytes.isalpha()

bytearray.isalpha()

若是序列中全部字节都是字母类 ASCII 字符而且序列非空则返回真值，不然返回假值。 字母类 ASCII 字符就是字节值包含在序列 b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。

例如:

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

bytes.isascii()

bytearray.isascii()

若是序列为空或序列中全部字节都是 ASCII 字节则返回真值，不然返回假值。 ASCII 字节的取值范围是 0-0x7F。

3.7 新版功能.

bytes.isdigit()

bytearray.isdigit()

若是序列中全部字节都是 ASCII 十进制数码而且序列非空则返回真值，不然返回假值。 ASCII 十进制数码就是字节值包含在序列 b'0123456789' 中的字符。

例如:

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

小写 ASCII 字符就是字节值包含在序列 b'abcdefghijklmnopqrstuvwxyz' 中的字符。 大写 ASCII 字符就是字节值包含在序列 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。

bytes.isspace()

bytearray.isspace()

若是序列中全部字节都是 ASCII 空白符而且序列非空则返回真值，不然返回假值。 ASCII 空白符就是字节值包含在序列 b' \t\n\r\x0b\f' (空格, 制表, 换行, 回车, 垂直制表, 换页) 中的字符。

bytes.istitle()

bytearray.istitle()

若是序列为 ASCII 标题形式而且序列非空则返回真值，不然返回假值。 请参阅 bytes.title() 了解有关“标题形式”的详细定义。

例如:

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

小写 ASCII 字符就是字节值包含在序列 b'abcdefghijklmnopqrstuvwxyz' 中的字符。 大写 ASCII 字符就是字节值包含在序列 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。

bytes.lower()

bytearray.lower()

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

例如:

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

小写 ASCII 字符就是字节值包含在序列 b'abcdefghijklmnopqrstuvwxyz' 中的字符。 大写 ASCII 字符就是字节值包含在序列 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。

注解

此方法的 bytearray 版本 并不是 原地操做 —— 它老是产生一个新对象，即使没有作任何改变。

bytes.splitlines(keepends=False)

bytearray.splitlines(keepends=False)

返回由原二进制序列中各行组成的列表，在 ASCII 行边界符的位置拆分。 此方法使用 universal newlines 方式来分行。 结果列表中不包含换行符，除非给出了 keepends 且为真值。

例如:

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

不一样于 split()，当给出了分隔符 sep 时，对于空字符串此方法将返回一个空列表，而末尾的换行不会令结果中增长额外的行:

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

bytes.swapcase()

bytearray.swapcase()

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

例如:

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

小写 ASCII 字符就是字节值包含在序列 b'abcdefghijklmnopqrstuvwxyz' 中的字符。 大写 ASCII 字符就是字节值包含在序列 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。

不一样于 str.swapcase()，在些二进制版本下 bin.swapcase().swapcase() == bin 老是成立。 大小写转换在 ASCII 中是对称的，即便其对于任意 Unicode 码位来讲并不老是成立。

注解

此方法的 bytearray 版本 并不是 原地操做 —— 它老是产生一个新对象，即使没有作任何改变。

bytes.title()

bytearray.title()

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

例如:

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

小写 ASCII 字符就是字节值包含在序列 b'abcdefghijklmnopqrstuvwxyz' 中的字符。 大写 ASCII 字符就是字节值包含在序列 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。 全部其余字节值都不区分大小写。

该算法使用一种简单的与语言无关的定义，将连续的字母组合视为单词。 该定义在多数状况下都颇有效，但它也意味着表明缩写形式与全部格的撇号也会成为单词边界，这可能致使不但愿的结果:

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

可使用正则表达式来构建针对撇号的特别处理:

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

注解

此方法的 bytearray 版本 并不是 原地操做 —— 它老是产生一个新对象，即使没有作任何改变。

bytes.upper()

bytearray.upper()

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

例如:

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

小写 ASCII 字符就是字节值包含在序列 b'abcdefghijklmnopqrstuvwxyz' 中的字符。 大写 ASCII 字符就是字节值包含在序列 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。

注解

此方法的 bytearray 版本 并不是 原地操做 —— 它老是产生一个新对象，即使没有作任何改变。

bytes.zfill(width)

bytearray.zfill(width)

返回原序列的副本，在左边填充 b'0' 数码使序列长度为 width。 正负值前缀 (b'+'/ b'-') 的处理方式是在正负符号 以后 填充而非在以前。 对于 bytes 对象，若是 width 小于等于 len(seq) 则返回原序列。

例如:

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

注解

此方法的 bytearray 版本 并不是 原地操做 —— 它老是产生一个新对象，即使没有作任何改变。

printf 风格的字节串格式化

注解

此处介绍的格式化操做具备多种怪异特性，可能致使许多常见错误（例如没法正确显示元组和字典）。若是要打印的值可能为元组或字典，请将其放入一个元组中。

字节串对象 (bytes/bytearray) 具备一种特殊的内置操做：使用 % (取模) 运算符。这也被称为字节串的格式化或插值运算符。对于 format % values (其中 format 为一个字节串对象)，在 format 中的 % 转换标记符将被替换为零个或多个 values 条目。其效果相似于在 C 语言中使用 sprintf()。

若是 format 要求一个单独参数，则 values 能够为一个非元组对象。 5 不然的话，values 必须或是是一个包含项数与格式字节串对象中指定的转换符项数相同的元组，或者是一个单独的映射对象（例如元组）。

转换标记符包含两个或更多字符并具备如下组成，且必须遵循此处规定的顺序：

'%' 字符，用于标记转换符的起始。
映射键（可选），由加圆括号的字符序列组成 (例如 (somename))。
转换旗标（可选），用于影响某些转换类型的结果。
最小字段宽度（可选）。若是指定为 '*' (星号)，则实际宽度会从 values 元组的下一元素中读取，要转换的对象则为最小字段宽度和可选的精度以后的元素。
精度（可选），以在 '.' (点号) 以后加精度值的形式给出。若是指定为 '*' (星号)，则实际精度会从 values 元组的下一元素中读取，要转换的对象则为精度以后的元素。
长度修饰符（可选）。
转换类型。

当右边的参数为一个字典（或其余映射类型）时，字节串对象中的格式必须包含加圆括号的映射键，对应 '%' 字符以后字典中的每一项。映射键将从映射中选取要格式化的值。例如：

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

在此状况下格式中不能出现 * 标记符（因其须要一个序列类的参数列表）。

转换旗标为：

能够给出长度修饰符 (h, l 或 L)，但会被忽略，由于对 Python 来讲没有必要 -- 因此 %ld 等价于 %d。

转换类型为：

注释:

此替代形式会在第一个数码以前插入标示八进制数的前缀 ('0o')。
此替代形式会在第一个数码以前插入 '0x' 或 '0X' 前缀（取决因而使用 'x' 仍是 'X' 格式）。
此替代形式老是会在结果中包含一个小数点，即便其后并无数码。
小数点后的数码位数由精度决定，默认为 6。
此替代形式老是会在结果中包含一个小数点，末尾各位的零不会如其余状况下那样被移除。
小数点先后的有效数码位数由精度决定，默认为 6。
若是精度为 N，输出将截短为 N 个字符。
b'%s' 已弃用，但在 3.x 系列中将不会被移除。
b'%r' 已弃用，但在 3.x 系列中将不会被移除。
参见 PEP 237。

注解

此方法的 bytearray 版本并不是原地操做 —— 它老是产生一个新对象，即使没有作任何改变。

参见

PEP 461 - 为 bytes 和 bytearray 添加 % 格式化

3.5 新版功能.

上一篇文章： Python标准库---十二、内置类型:文本序列类型（str）下一篇文章：