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

二进制序列类型- ,,bytes bytearraymemoryview

用于操作二进制数据的核心内置类型是bytes和 bytearray。支持memoryview它们使用缓冲区协议来访问其他二进制对象的内存而无需复制。

array模块支持有效存储基本数据类型,如32位整数和IEEE754双精度浮点值。

 

字节对象

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

class bytessource [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 fromhexstring 
此类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中的新功能。

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

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

注意

对于Python 2.x用户:在Python 2.x系列中,允许在8位字符串(最接近2.x提供给内置二进制数据类型)和Unicode字符串之间进行各种隐式转换。这是一个向后兼容性的解决方法,以解释Python最初只支持8位文本,而Unicode文本是后来添加的事实。在Python 3.x中,那些隐式转换已经消失 – 8位二进制数据和Unicode文本之间的转换必须是显式的,并且字节和字符串对象将始终比较不相等。

 

Bytearray对象

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

class bytearraysource [encoding [errors 
bytearray对象没有专用的文字语法,而是始终通过调用构造函数创建它们:

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

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

另请参见内置的bytearray

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

classmethod fromhexstring 
此类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对象bb[0]将是一个整数,而b[0:1]将是一个长度为1的bytearray对象。(这与文本字符串形成对比,其中索引和切片将产生一个长度为1)

bytearray对象的表示使用bytes literal format(bytearray(b'...')),因为它通常比例如更有用 。您始终可以使用将bytearray对象转换为整数列表。bytearray([46, 46, 46])list(b)

 

字节和字节操作

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

注意

bytes和bytearray对象上的方法不接受字符串作为参数,就像字符串上的方法不接受字节作为参数一样。例如,你必须写:

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

 

和:

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

 

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

注意

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

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

bytes.countsub [start [end 
bytearray.countsub [start [end 
返回[ startend ] 范围内序列sub的非重叠出现次数。可选参数startend被解释为切片表示法。

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

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

bytes.decodeencoding =“utf-8”errors =“strict” 
bytearray.decodeencoding =“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.findsub [start [end 
bytearray.findsub [start [end 
返回找到序列的数据中的最低索引,使得包含在切片中s[start:end]。可选参数startend被解释为切片表示法。-1如果未找到sub,则返回 。

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

注意

find()只有在需要知道sub的位置时才应使用该方法。要检查sub是否是子字符串,请使用 in运算符:

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

 

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

bytes.indexsub [start [end 
bytearray.indexsub [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.maketransfromto 
static bytearray.maketransfromto 
此静态方法返回一个转换表可用于 bytes.translate()将每个字符映射在成在相同位置处的字符 ; fromto必须都是 类似字节的对象并具有相同的长度。

3.1版中的新功能。

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

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

bytes.replace旧的新的[计数
bytearray.replace旧的新的[计数
返回序列的副本,其中所有出现的子序列old都 替换为new。如果给出可选参数计数,则仅替换第一次计数

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

注意

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

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

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

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

bytes.rindexsub [start [end 
bytearray.rindexsub [start [end 
喜欢rfind()但是ValueError在没有找到序列子时加注。

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

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

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

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

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

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

bytes.translatetabledelete = b” 
bytearray.translatetabledelete = 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.centerwidth [fillbyte 
bytearray.centerwidth [fillbyte 
返回长度的序列为中心的对象的副本宽度。使用指定的fillbyte填充填充(默认为ASCII空间)。对于bytes对象,如果width小于或等于,则返回原始序列 len(s)

注意

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

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

注意

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

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

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

 

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

注意

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

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

注意

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

bytes.rsplitsep = Nonemaxsplit = -1 
bytearray.rsplitsep = Nonemaxsplit = -1 
使用sep 作为分隔符字符串,将二进制序列拆分为相同类型的子序列。如果给出maxsplit,则最多完成maxsplit分割,最右边的分割。如果未指定sep,None仅由ASCII空格组成的任何子序列都是分隔符。除了从右边分裂之外,rsplit()其行为类似于 split()下面详细描述的。
bytes.rstripchars 
bytearray.rstripchars 
返回已删除指定尾随字节的序列副本。的 字符参数是指定一组字节值的二进制序列被除去-名称指的是这种方法通常是用ASCII字符使用的事实。如果省略或None,则chars参数默认为删除ASCII空格。该字符参数不是后缀; 相反,它的所有值组合都被剥离:

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

 

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

注意

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

bytes.splitsep = Nonemaxsplit = -1 
bytearray.splitsep = Nonemaxsplit = -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.stripchars 
bytearray.stripchars 
返回序列的副本,删除指定的前导和尾随字节。的字符参数是指定一组字节值的二进制序列被除去-名称指的是这种方法通常是用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.expandtabstabsize = 8 
bytearray.expandtabstabsize = 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.splitlineskeepends = False 
bytearray.splitlineskeepends = 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式字节格式

注意

这里描述的格式化操作表现出各种怪癖,导致许多常见错误(例如无法正确显示元组和字典)。如果要打印的值可能是元组或字典,请将其包装在元组中。

字节对象(bytesbytearray)有一个独特的内置操作:%运算符(模数)。这也称为字节格式化插值运算符。给定(格式为字节对象),格式的转换规范将替换为零个或多个元素。效果类似于在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.'

 

在这种情况下*,格式中不会出现说明符(因为它们需要顺序参数列表)。

转换标志字符是:

含义
'#' 值转换将使用“备用表单”(在下面定义)。
'0' 对于数值,转换将为零填充。
'-' 保留转换后的值('0' 如果给出两者,则覆盖转换)。
' ' (空格)在签名转换产生的正数(或空字符串)之前应留空。
'+' 符号字符('+''-')将在转换之前(覆盖“空格”标志)。

可以存在长度修饰符(hlL),但忽略它,因为它不是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' 字节(遵循缓冲协议或具有的 任何对象 __bytes__())。 (5)
's' 's'是别名'b',应该只用于Python2 / 3代码库。 (6)
'a' 字节(使用转换任何Python对象repr(obj).encode('ascii','backslashreplace))。 (5)
'r' 'r'是别名'a',应该只用于Python2 / 3代码库。 (7)
'%' 不转换参数,导致结果中出现'%' 字符。

笔记:

  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

注意

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

也可以看看

PEP 461 – 将%格式添加到字节和bytearray

版本3.5中的新功能。

 

内存视图

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

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

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

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

memoryview支持切片和索引以公开其数据。一维切片将产生子视图:

>>>
>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
>>> v[1:4]
<memory at 0x7f3ddc9f4350>
>>> bytes(v[1:4])
b'bce'

 

如果formatstruct模块中的本机格式说明符之一,则还支持使用整数或整数元组进行索引,并返回具有正确类型的单个元素。一维内存视图可以用整数或一个整数元组索引。多维内存视图可以使用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中的新功能。

脚注

[1] 有关这些特殊方法的更多信息,请参阅Python参考手册(基本自定义)。
[2] 因此,列表被认为是等同的,并且类似于元组。[1, 2][1.0, 2.0]
[3] 它们必须具有,因为解析器无法分辨操作数的类型。
[4] (1,2,3,4)下套管字符是那些具有一般类别属性是“路”(字母,大写),“LL”(字母,小写),或“LT”(字母,首字母大写)中的一个。
[5] (1,2)要格式化只有一个元组因此,你应该提供一个单元组的唯一元件是要格式化的元组。