(最全资料)二进制序列、字节操作详解(7)Python语言(必读进阶学习教程)(参考资料)

字节对象

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

class bytes（[ source [，encoding [，errors ] ] ] ）

首先，字节文字的语法与字符串文字的语法大致相同，只是b添加了前缀：

• 单引号： b'still allows embedded "double" quotes'
• 双引号：。b"still allows embedded 'single' quotes"
• 三重引用：，b'''3 single quotes'''b"""3 double quotes"""

字节文字中只允许使用ASCII字符（无论声明的源代码编码如何）。必须使用适当的转义序列将超过127的任何二进制值输入到字节文字中。

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

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

除了文字形式之外，还可以通过许多其他方式创建字节对象：

• 指定长度的零填充字节对象： bytes(10)
• 从可迭代的整数： bytes(range(20))
• 通过缓冲协议复制现有二进制数据： bytes(obj)

另请参阅内置字节。

由于2个十六进制数字精确地对应于单个字节，因此十六进制数字是用于描述二进制数据的常用格式。因此，bytes类型有一个额外的类方法来读取该格式的数据：

classmethod fromhex（string ）

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

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

 

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

存在反向转换函数以将字节对象转换为其十六进制表示。

hex（）

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

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

 

版本3.5中的新功能。

由于字节对象是整数序列（类似于元组），对于字节对象b，b[0]将是一个整数，而b[0:1]将是长度为1的字节对象。（这与文本字符串形成对比，其中索引和切片将产生长度为1）

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

Bytearray对象

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

class bytearray（[ source [，encoding [，errors ] ] ] ）

bytearray对象没有专用的文字语法，而是始终通过调用构造函数创建它们：

• 创建一个空实例： bytearray()
• 创建具有给定长度的零填充实例： bytearray(10)
• 从可迭代的整数： bytearray(range(20))
• 通过缓冲协议复制现有二进制数据： bytearray(b'Hi!')

由于bytearray对象是可变的，除了Bytes和Bytearray Operations中描述的公共字节和bytearray操作之外，它们还支持 可变序列操作。

另请参见内置的bytearray。

由于2个十六进制数字精确地对应于单个字节，因此十六进制数字是用于描述二进制数据的常用格式。因此，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 literal format（bytearray(b'...')），因为它通常比例如更有用 。您始终可以使用将bytearray对象转换为整数列表。bytearray([46, 46, 46])list(b)

字节和字节操作

字节和bytearray对象都支持公共 序列操作。它们不仅与相同类型的操作数互操作，而且与任何类似字节的对象互操作。由于这种灵活性，它们可以在操作中自由混合而不会导致错误。但是，结果的返回类型可能取决于操作数的顺序。

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

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

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

字节和bytearray对象的以下方法可以与任意二进制数据一起使用。

bytes.count（sub [，start [，end ] ] ）

bytearray.count（sub [，start [，end ] ] ）

返回[ 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” ）

返回从给定字节解码的字符串。默认编码是 'utf-8'。可以给出错误以设置不同的错误处理方案。错误的默认值是'strict'，意味着编码错误会引发错误UnicodeError。其他可能的值是 'ignore'，'replace'以及通过其注册的任何其他名称 codecs.register_error()，请参见错误处理程序部分。有关可能的编码列表，请参阅标准编码部分。

注意

传递encoding参数以str允许直接解码任何 类似字节的对象，而无需创建临时字节或bytearray对象。

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

bytes.endswith（后缀[，start [，end ] ] ）

bytearray.endswith（后缀[，start [，end ] ] ）

返回True如果二进制数据与指定的结束后缀，否则返回False。 后缀也可以是要查找的后缀元组。通过可选的启动，从该位置开始测试。使用可选结束，停止在该位置进行比较。

要搜索的后缀可以是任何类似字节的对象。

bytes.find（sub [，start [，end ] ] ）

bytearray.find（sub [，start [，end ] ] ）

返回找到子序列子的数据中的最低索引，使得子包含在切片中s[start:end]。可选参数start和end被解释为切片表示法。-1如果未找到sub，则返回 。

搜索的子序列可以是任何类似字节的对象或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在没有找到子序列时提高。

搜索的子序列可以是任何类似字节的对象或0到255范围内的整数。

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

bytes.join（可迭代的）

bytearray.join（可迭代的）

返回一个bytes或bytearray对象，它是iterable中二进制数据序列的串联。TypeError如果iterable中有任何值不是类字节对象（包括str对象），则会引发A. 元素之间的分隔符是提供此方法的bytes或bytearray对象的内容。

static bytes.maketrans（from，to ）

static bytearray.maketrans（from，to ）

此静态方法返回一个转换表可用于 bytes.translate()将每个字符映射在从成在相同位置处的字符到 ; from和to必须都是 类似字节的对象并具有相同的长度。

3.1版中的新功能。

bytes.partition（sep ）

bytearray.partition（sep ）

在第一次出现sep时拆分序列，并返回包含分隔符之前的部分的3元组，分隔符本身或其bytearray副本以及分隔符之后的部分。如果未找到分隔符，则返回包含原始序列副本的3元组，后跟两个空字节或bytearray对象。

要搜索的分隔符可以是任何类似字节的对象。

bytes.replace（旧的，新的[，计数] ）

bytearray.replace（旧的，新的[，计数] ）

返回序列的副本，其中所有出现的子序列old都 替换为new。如果给出可选参数计数，则仅替换第一次计数。

搜索及其替换的子序列可以是任何 类似字节的对象。

注意

此方法的bytearray版本不能正常运行 – 它总是会生成一个新对象，即使没有进行任何更改。

bytes.rfind（sub [，start [，end ] ] ）

bytearray.rfind（sub [，start [，end ] ] ）

返回找到子序列sub的序列中的最高索引，以便包含subs[start:end]。可选参数start和end被解释为切片表示法。-1失败时返回 。

搜索的子序列可以是任何类似字节的对象或0到255范围内的整数。

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

bytes.rindex（sub [，start [，end ] ] ）

bytearray.rindex（sub [，start [，end ] ] ）

喜欢rfind()但是ValueError在没有找到子序列子时加注。

搜索的子序列可以是任何类似字节的对象或0到255范围内的整数。

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

bytes.rpartition（sep ）

bytearray.rpartition（sep ）

在最后一次出现sep时拆分序列，并返回包含分隔符之前的部分的3元组，分隔符本身或其bytearray副本以及分隔符之后的部分。如果未找到分隔符，则返回包含原始序列副本的3元组，后跟两个空字节或bytearray对象。

要搜索的分隔符可以是任何类似字节的对象。

bytes.startswith（前缀[，start [，end ] ] ）

bytearray.startswith（前缀[，start [，end ] ] ）

返回True如果二进制数据与指定的开始前缀，否则返回False。 前缀也可以是要查找的前缀元组。通过可选的启动，从该位置开始测试。使用可选结束，停止在该位置进行比较。

要搜索的前缀可以是任何类似字节的对象。

bytes.translate（table，delete = b” ）

bytearray.translate（table，delete = b” ）

返回字节或bytearray对象的副本，其中删除了可选参数delete中出现的所有字节，其余字节已通过给定的转换表进行映射，转换表必须是长度为256的字节对象。

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

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

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

 

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

字节和bytearray对象的以下方法具有默认行为，假定使用ASCII兼容的二进制格式，但仍可通过传递适当的参数与任意二进制数据一起使用。请注意，本节中的所有bytearray方法都不会在适当的位置运行，而是生成新对象。

bytes.center（width [，fillbyte ] ）

bytearray.center（width [，fillbyte ] ）

返回长度的序列为中心的对象的副本宽度。使用指定的fillbyte填充填充（默认为ASCII空间）。对于bytes对象，如果width小于或等于，则返回原始序列 len(s)。

注意

此方法的bytearray版本不能正常运行 – 它总是会生成一个新对象，即使没有进行任何更改。

bytes.ljust（width [，fillbyte ] ）

bytearray.ljust（width [，fillbyte ] ）

以长度宽度的顺序返回左对齐的对象的副本。使用指定的fillbyte填充填充（默认为ASCII空间）。对于bytes对象，如果width小于或等于，则返回原始序列 len(s)。

注意

此方法的bytearray版本不能正常运行 – 它总是会生成一个新对象，即使没有进行任何更改。

bytes.lstrip（[ chars ] ）

bytearray.lstrip（[ chars ] ）

返回已删除指定前导字节的序列副本。的 字符参数是指定一组字节值的二进制序列被除去-名称指的是这种方法通常是用ASCII字符使用的事实。如果省略或None，则chars参数默认为删除ASCII空格。该字符参数不是前缀; 相反，它的所有值组合都被剥离：

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

 

要删除的字节值的二进制序列可以是任何 类似字节的对象。

注意

此方法的bytearray版本不能正常运行 – 它总是会生成一个新对象，即使没有进行任何更改。

bytes.rjust（width [，fillbyte ] ）

bytearray.rjust（width [，fillbyte ] ）

以长度宽度的顺序返回右对齐的对象副本。使用指定的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 ] ）

返回已删除指定尾随字节的序列副本。的 字符参数是指定一组字节值的二进制序列被除去-名称指的是这种方法通常是用ASCII字符使用的事实。如果省略或None，则chars参数默认为删除ASCII空格。该字符参数不是后缀; 相反，它的所有值组合都被剥离：

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

 

要删除的字节值的二进制序列可以是任何 类似字节的对象。

注意

此方法的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']b'1<>2<>3'.split(b'<>')[b'1',b'2', b'3'][b''][bytearray(b'')]

例如：

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

返回序列的副本，删除指定的前导和尾随字节。的字符参数是指定一组字节值的二进制序列被除去-名称指的是这种方法通常是用ASCII字符使用的事实。如果省略或None，则chars 参数默认为删除ASCII空格。该字符参数不是前缀或后缀; 相反，它的所有值组合都被剥离：

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

 

要删除的字节值的二进制序列可以是任何 类似字节的对象。

注意

此方法的bytearray版本不能正常运行 – 它总是会生成一个新对象，即使没有进行任何更改。

字节和bytearray对象的以下方法假定使用ASCII兼容的二进制格式，不应该应用于任意二进制数据。请注意，本节中的所有bytearray方法都不会在适当的位置运行，而是生成新对象。

bytes.capitalize（）

bytearray.capitalize（）

返回序列的副本，每个字节被解释为ASCII字符，第一个字节大写，其余字节小写。非ASCII字节值不变地传递。

注意

此方法的bytearray版本不能正常运行 – 它总是会生成一个新对象，即使没有进行任何更改。

bytes.expandtabs（tabsize = 8 ）

bytearray.expandtabs（tabsize = 8 ）

返回序列的副本，其中所有ASCII制表符由一个或多个ASCII空格替换，具体取决于当前列和给定的制表符大小。每个制表位字节都会出现制表符位置（默认值为8，在第0,8,16列等位置给出制表位置）。要扩展序列，将当前列设置为零，并逐个字节地检查序列。如果字节是ASCII制表符（b'\t'），则在结果中插入一个或多个空格字符，直到当前列等于下一个制表符位置。（不会复制制表符本身。）如果当前字节是ASCII换行符（b'\n'）或回车符（b'\r'），将其复制并将当前列重置为零。任何其他字节值都将保持不变，并且无论打印时字节值如何表示，当前列都会增加1：

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

 

注意

此方法的bytearray版本不能正常运行 – 它总是会生成一个新对象，即使没有进行任何更改。

bytes.isalnum（）

bytearray.isalnum（）

如果序列中的所有字节都是字母ASCII字符或ASCII十进制数字且序列不为空，则返回true，否则返回false。字母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.isascii（）

bytearray.isascii（）

如果序列为空或序列中的所有字节都是ASCII，则返回true，否则返回false。ASCII字节的范围是0-0x7F。

版本3.7中的新功能。

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。有关bytes.title()“标题”定义的更多详细信息，请参阅。

例如：

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

 

bytes.isupper（）

bytearray.isupper（）

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

例如：

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

 

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

bytes.lower（）

bytearray.lower（）

返回序列的副本，其中所有大写的ASCII字符都转换为相应的小写对应字符。

例如：

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

 

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

注意

此方法的bytearray版本不能正常运行 – 它总是会生成一个新对象，即使没有进行任何更改。

bytes.splitlines（keepends = False ）

bytearray.splitlines（keepends = False ）

返回二进制序列中的行列表，以ASCII行边界断开。此方法使用通用换行方法来分割线。除非给出keepends且为true，否则换行符不包括在结果列表中。

例如：

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

 

与给定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()，情况总是如此 。大小写转换在ASCII中是对称的，即使对于任意Unicode代码点通常也不是这样。bin.swapcase().swapcase() == bin

注意

此方法的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（宽度）

bytearray.zfill（宽度）

返回的ASCII码填序列左边的副本b'0'数字来长的序列宽度。一个前置符号前缀（b'+'/ b'-'）是通过将填充处理后的符号字符，而不是之前。对于bytes对象，如果width小于或等于，则返回原始序列len(seq)。

例如：

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

 

注意

此方法的bytearray版本不能正常运行 – 它总是会生成一个新对象，即使没有进行任何更改。

printf式字节格式

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

如果format需要单个参数，则值可以是单个非元组对象。[5] 否则，值必须是具有格式字节对象或单个映射对象（例如，字典）指定的项目数的元组。

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

1. 该'%'字符，标记说明符的开头。
2. 映射键（可选），由带括号的字符序列组成（例如(somename)）。
3. 转换标志（可选），它会影响某些转换类型的结果。
4. 最小字段宽度（可选）。如果指定为'*'（星号），则从值的元组的下一个元素读取实际宽度，并且要转换的对象在最小字段宽度和可选精度之后。
5. 精度（可选），以'.'（点）表示，后跟精度。如果指定为'*'（星号），则从值的元组的下一个元素读取实际精度，并且要转换的值在精度之后。
6. 长度修饰符（可选）。
7. 转换类型。

当右参数是字典（或其他映射类型）时，bytes对象中的格式必须包括括号中的映射键，该'%'字符串紧接在字符后面插入的字典中。映射关键字从映射中选择要格式化的值。例如：

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

转换类型包括：

笔记：

1. 替代形式导致'0o'在第一个数字之前插入前导八进制说明符（）。

2. 在另一种形式使得领先'0x'或'0X'（取决于是否'x'或'X'使用格式）的第一位数字之前插入。

3. 替代形式导致结果始终包含小数点，即使后面没有数字也是如此。

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

4. 替代形式导致结果始终包含小数点，并且不会删除尾随零，否则它们将被删除。

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

5. 如果是precision N，则输出将截断为N字符。

6. b'%s' 已弃用，但在3.x系列中不会被删除。

7. b'%r' 已弃用，但在3.x系列中不会被删除。

8. 看到 PEP 237。

内存视图

memoryview对象允许Python代码访问支持缓冲区协议的对象的内部数据而无需复制。

class memoryview（obj ）

创建一个memoryview引用obj。 obj必须支持缓冲协议。支持缓冲协议的内置对象包括 bytes和bytearray。

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

len(view)等于的长度tolist。如果，长度为1.如果，长度等于视图中的元素数。对于更高的维度，长度等于视图的嵌套列表表示的长度。该属性将为您提供单个元素中的字节数。view.ndim = 0view.ndim = 1itemsize

A 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模块中的本机格式说明符之一，则还支持使用整数或整数元组进行索引，并返回具有正确类型的单个元素。一维内存视图可以用整数或一个整数元组索引。多维内存视图可以使用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中已更改：内存视图现在可以使用整数元组进行索引。

memoryview 有几种方法：

__eq__（出口商）

记忆观和一个 如果 PEP 3118导出器的形状是等效的，并且当使用struct语法解释操作数的相应格式代码时所有相应的值相等，则它们是相等的。

对于子集struct的格式字符串目前支持的 tolist()，v并且w是相等的，如果：v.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

 

需要注意的是，如浮点数，并没有暗示 对memoryview对象。v is wv == w

在版本3.3中更改：以前的版本比较了原始内存，忽略了项目格式和逻辑阵列结构。

tobytes（）

将缓冲区中的数据作为字节串返回。这相当于bytes在memoryview上调用构造函数。

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

 

版本3.3中已更改：tolist()现在支持struct模块语法中的所有单字符本机格式 以及多维表示。

release（）

释放由memoryview对象公开的底层缓冲区。许多对象在对它们进行视图时会采取特殊操作（例如，a 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（格式[，形状] ）

将内存视图转换为新格式或形状。shape默认为 [byte_length//new_itemsize]，这意味着结果视图将是一维的。返回值是新的内存视图，但不会复制缓冲区本身。支持的强制转换为1D – > C- 连续 且C-连续 – > 1D。

目标格式仅限于struct语法中的单个元素本机格式 。其中一种格式必须是字节格式（’B’，’b’或’c’）。结果的字节长度必须与原始长度相同。

将1D / long转换为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 / ints到1D / signed char：

>>>
>>> import struct
>>> buf = struct.pack("i"*12, *list(range(12)))
>>> x = memoryview(buf)
>>> y = x.cast('i', shape=[2,2,3])
>>> y.tolist()
[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
>>> y.format
'i'
>>> y.itemsize
4
>>> len(y)
2
>>> y.nbytes
48
>>> z = y.cast('b')
>>> z.format
'b'
>>> z.itemsize
1
>>> len(z)
48
>>> z.nbytes
48

 

将1D / 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

memoryview的底层对象：

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

指示内存是否为只读的bool。

format

包含struct视图中每个元素的格式（以模块样式）的字符串。可以从具有任意格式字符串的导出器创建存储器视图，但是一些方法（例如tolist()）仅限于本机单元素格式。

在版本3.3中更改：'B'现在根据struct模块语法处理格式。这意味着。memoryview(b'abc')[0] ==b'abc'[0] == 97

itemsize

memoryview的每个元素的大小（以字节为单位）：

>>>
>>> import array, struct
>>> m = memoryview(array.array('H', [32000, 32001, 32002]))
>>> m.itemsize
2
>>> m[0]
32000
>>> struct.calcsize('H') == m.itemsize
True

 

ndim

一个整数，表示内存所代表的多维数组的维数。

shape

整数元组，ndim将存储器形状赋予N维数组的长度。

版本3.3中更改：空元组而不是Nonendim = 0时。

strides

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

版本3.3中更改：空元组而不是Nonendim = 0时。

suboffsets

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

c_contiguous

指示内存是否为C- 连续的 bool 。

版本3.3中的新功能。

f_contiguous

bool指示内存是否为Fortran 连续。

版本3.3中的新功能。

contiguous

bool指示内存是否连续。

版本3.3中的新功能。

脚注