Python中有一类特殊的对象称为字节类对象,可在多种二进制数据操作中使用,如图片、音频、视频数据,通过socket套接字发送数据,以及与C语言的API进行数据交互等等。
bytes 只负责以字节序列的形式(二进制形式)来存储数据,至于这些数据到底表示什么内容(字符串、数字、图片、音频等),完全由程序的解析方式决定。如果采用合适的字符编码方式(字符集),字节串可以恢复成字符串;反之亦然,字符串也可以转换成字节串。
说的更直白一点,bytes 只是简单地记录内存中的原始数据,至于如何使用这些数据,bytes 并不在意,你想怎么使用就怎么使用,bytes 并不约束你的行为。
包括所有 bytes、bytearray 和 array.array 对象,以及许多普通 memoryview 对象。
bytes 对象是由单个字节构成的不可变序列。
Bytes 本质是一串由 0 和 1 组成的二进制串,但为了显示方便,每八位划分为一组,然后按组显示。如果这八位正好是一个可打印的 ASCII 字符的编码,如 A、z、0、% 等,则显示该字符;如果不是,则显示十六进制。
由于许多主要二进制协议都基于 ASCII 文本编码,因此 bytes 对象提供了一些仅在处理 ASCII 兼容数据时可用,并且在许多特性上与字符串对象紧密相关的方法。
字节串(bytes)和字符串(string)的对比:
字符串和 bytes 存在着千丝万缕的联系,我们可以通过字符串来创建 bytes 对象,或者说将字符串转换成 bytes 对象。有以下三种方法可以达到这个目的:
b
前缀就可以转换成 bytes。创建bytes有多种方法,一种是通过bytes进行显示的声明和转换,一种是从其他对象生成或转换而来。
语法:
class bytes([source[, encoding[, errors]]])
通过bytes()函数显示声明一个bytes类型
首先,表示 bytes 字面值的语法与字符串字面值的大致相同,只是添加了一个 b
前缀:
b'同样允许嵌入 "双" 引号'
。b"仍然允许嵌入 '单' 引号"
b'''三重单引号'''
, b"""三重双引号"""
bytes 字面值中只允许 ASCII 字符(无论源代码声明的编码为何)。 任何超出 127 的二进制值必须使用相应的转义序列形式加入 bytes 字面值。
像字符串字面值一样,bytes 字面值也可以使用 r
前缀来禁用转义序列处理。
虽然 bytes 字面值和表示法是基于 ASCII 文本的,但 bytes 对象的行为实际上更像是不可变的整数序列,序列中的每个值的大小被限制为 0 <= x < 256 (如果违反此限制将引发 ValueError)。 这种限制是有意设计用以强调以下事实,虽然许多二进制格式都包含基于 ASCII 的元素,可以通过某些面向文本的算法进行有用的操作,但情况对于任意二进制数据来说通常却并非如此(盲目地将文本处理算法应用于不兼容 ASCII 的二进制数据格式往往将导致数据损坏)。
除了字面值形式,bytes 对象还可以通过其他几种方式来创建:
bytes(10)
bytes(range(20))
bytes(obj)
- >>> b'123'
- b'123'
- >>> b'一二三'
- File "
" , line 1 - b'一二三'
- ^
- SyntaxError: bytes can only contain ASCII literal characters
-
- #大于 127 的字符建议使用 \xhh 表示。
- >>> b'\xe4\xb8\x80\xe4\xba\x8c\xe4\xb8\x89'
- b'\xe4\xb8\x80\xe4\xba\x8c\xe4\xb8\x89’
- >>> bytes('一二三', 'utf-8')
- b'\xe4\xb8\x80\xe4\xba\x8c\xe4\xb8\x89’
-
- >>> '一二三'.encode() # 或 '一二三'.encode('utf-8')
- b'\xe4\xb8\x80\xe4\xba\x8c\xe4\xb8\x89’
- >>> s = '这是一个中文字符串'
- >>> b = s.encode('utf-8')
- >>> print(b)
- b'\xe8\xbf\x99\xe6\x98\xaf\xe4\xb8\x80\xe4\xb8\xaa\xe4\xb8\xad\xe6\x96\x87\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2'
语法:
classmethod bytes.fromhex(string)
通过bytes的类方法将一个包含16进制数字串的string转换为bytes类型
由于两个十六进制数码精确对应一个字节,因此十六进制数是描述二进制数据的常用格式。 相应地,bytes 类型具有从此种格式读取数据的附加类方法。
方法返回一个解码给定字符串的 bytes 对象。 字符串必须由表示每个字节的两个十六进制数码构成,其中的 ASCII 空白符会被忽略。
- >>>bytes.fromhex('2Ef0 F1f2 ')
- b'.\xf0\xf1\xf2'
语法:
str.encode(encoding='UTF-8',errors='strict')
参数:
返回编码后的字节串
如:
- >>> str = "C语言中文网"
- >>> str.encode()
- b'C\xe8\xaf\xad\xe8\xa8\x80\xe4\xb8\xad\xe6\x96\x87\xe7\xbd\x91'
语法格式:
hex([sep[, bytes_per_sep]])
可以将 bytes 对象转换为对应的十六进制表示.
返回一个字符串对象,该对象包含实例中每个字节的两个十六进制数字。
- >>>b'\xf0\xf1\xf2'.hex()
- ‘f0f1f2'
- #将字符转化为 GBK 编码:
- #方法一:
- >>> bytes('一二三', 'gbk').hex()
- 'd2bbb6fec8fd'
- #方法二:
- >>> '一二三'.encode('gbk').hex()
- ‘d2bbb6fec8fd'
-
-
- #将 GBK 编码转化为字符 :
- #方法一:
- >>> str(bytes.fromhex('d2bbb6fec8fd'), 'gbk')
- '一二三'
-
- #方法二:
- >>> bytes.fromhex('d2bbb6fec8fd').decode('gbk')
- '一二三'
如果你希望令十六进制数字符串更易读,你可以指定单个字符分隔符作为 sep 形参包含于输出中。 默认情况下,该分隔符会放在每个字节之间。 第二个可选的 bytes_per_sep 形参控制间距。 正值会从右开始计算分隔符的位置,负值则是从左开始。
- >>>value = b'\xf0\xf1\xf2'
- >>>value.hex('-')
- 'f0-f1-f2'
- >>>value.hex('_', 2)
- 'f0_f1f2'
- >>>b'UUDDLRLRAB'.hex(' ', -4)
- '55554444 4c524c52 4142'
由于 bytes 对象是由整数构成的序列(类似于元组),因此对于一个 bytes 对象 b,b[0]
将为一个整数,而 b[0:1]
将为一个长度为 1 的 bytes 对象。 (这与文本字符串不同,索引和切片所产生的将都是一个长度为 1 的字符串)。
bytes 对象的表示使用字面值格式 (b'...'
),因为它通常都要比像 bytes([46, 46, 46])
这样的格式更好用。 你总是可以使用 list(b)
将 bytes 对象转换为一个由整数构成的列表。
语法格式:
bytes.decode(encoding='utf-8', errors='strict')
encoding为编码格式
返回解码为 str 的字节串。
errors 控制如何处理编码错误。
值 | 含意 |
---|---|
| 引发 UnicodeError (或其子类),这是默认的方案。 在 strict_errors() 中实现。 |
| 忽略错误格式的数据并且不加进一步通知就继续执行。 在 ignore_errors() 中实现。 |
| 用一个替代标记来替换。 在编码时,使用 ? (ASCII 字符)。 在解码时,使用 � (U+FFFD,官方的 REPLACEMENT CHARACTER)。 在 replace_errors() 中实现。 |
| 用反斜杠转义序列来替换。 在编码时,使用格式为 \xhh \uxxxx \Uxxxxxxxx 的 Unicode 码位十六进制表示形式。 在解码时,使用格式为 \xhh 的字节值十六进制表示形式。 在 backslashreplace_errors() 中实现。 |
| 在解码时,将字节替换为 |
- >>> str(b'\xe4\xb8\x80\xe4\xba\x8c\xe4\xb8\x89', 'utf-8')
- '一二三'
- >>> b'\xe4\xb8\x80\xe4\xba\x8c\xe4\xb8\x89'.decode()
- '一二三'
语法为:
bytes.count(sub[, start[, end]])
返回子序列 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。
如果 sub 为空,则返回字节串对象的长度加一.
- a = b'abcabcabd'
- print(a.count(b'')) #4
- print(a.count(b'ab'))#3
语法为:
bytes.startswith(prefix[, start[, end]])
如果二进制数据以指定的 prefix 开头则返回 True
,否则返回 False
。 prefix 也可以为由多个供查找的前缀构成的元组。 如果有可选项 start,将从所指定位置开始检查。 如果有可选项 end,将在所指定位置停止比较。
- s = b'Apollo'
- print(f"{s.startswith(b'Ap')=}") #s.startswith(b'Ap')=True
- #s.startswith('Ap') #TypeError prefix必须是bytes类型
-
- s = b'Apollo'
- print(f"{s.startswith(b'po')=}") #s.startswith(b'po')=False
-
- s = b'Apollo'
- print(f"{s.startswith(b'Apo')=}") #s.startswith(b'Apo')=True
- print(f"{s.startswith(b'Apo',1,4)=}") #s.startswith(b'Apo',1,4)=False
语法为:
bytes.endswith(suffix[, start[, end]])
如果二进制数据以指定的 suffix 结束则返回 True
,否则返回 False
。 suffix 也可以为由多个供查找的后缀构成的元组。 如果有可选项 start,将从所指定位置开始检查。 如果有可选项 end,将在所指定位置停止比较。
语法为:
bytes.removeprefix(prefix, /)
如果二进制数据以 prefix 字符串开头,返回 bytes[len(prefix):]
。 否则,返回原始二进制数据的副本:
- >>>b'TestHook'.removeprefix(b'Test')
- b'Hook'
- >>>b'BaseTestCase'.removeprefix(b'Test')
- b'BaseTestCase'
注意:此方法的 bytearray 版本 并非 原地操作 —— 它总是产生一个新对象,即便没有做任何改变,后面的其他方法也基本是这样的,如果有特别的会进行单独说明。
语法:
bytes.removesuffix(suffix, /)
如果二进制数据以 suffix 字符串结尾,并且 suffix 非空,返回 bytes[:-len(suffix)]
。 否则,返回原始二进制数据的副本:
- >>> b'demo.py'.removesuffix(b'.py')
- b'demo'
- >>> b'demo.py'.removesuffix(b'.cpp')
- b'demo.py'
语法:
bytes.find(sub[, start[, end]])
返回子序列 sub 在数据中被找到的最小索引,sub 包含于切片 s[start:end]
之内。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1
。
备注 find() 方法应该只在你需要知道 sub 所在位置时使用。 要检查 sub 是否为子串,请使用 in 操作符:
- >>> b'py' in b'demo.py'
- True
语法:
bytes.index(sub[, start[, end]])
类似于 find(),但在找不到子序列时会引发 ValueError。
- >>> x = 0x32
- >>> b'1234'.index(bytes([x]))
- 1
语法:
bytes.rfind(sub[, start[, end]])
返回子序列 sub 在序列内被找到的最大(最右)索引,这样 sub 将包含在 s[start:end]
当中。 可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 -1
。
语法:
bytes.rindex(sub[, start[, end]])
类似于 rfind(),但在子序列 sub 未找到时会引发 ValueError。
语法:
bytes.partition(sep)
在 sep 首次出现的位置拆分序列,返回一个 3 元组,其中包含分隔符之前的部分、分隔符本身或其 bytearray 副本,以及分隔符之后的部分。 如果分隔符未找到,则返回的 3 元组中包含原序列以及两个空的 bytes 或 bytearray 对象。
语法:
bytes.rpartition(sep)
在 sep 最后一次出现的位置拆分序列,返回一个 3 元组,其中包含分隔符之前的部分,分隔符本身或其 bytearray 副本,以及分隔符之后的部分。 如果分隔符未找到,则返回的 3 元组中包含两个空的 bytes 或 bytearray 对象以及原序列的副本。
- >>> b'demo.py'.rpartition(b'.')
- (b'demo', b'.', b'py')
- >>> b'demo.py'.partition(b'.')
- (b'demo', b'.', b'py')
- >>> b'demo.20230904.py'.rpartition(b'.')
- (b'demo.20230904', b'.', b'py')
- >>> b'demo.20230904.py'.partition(b'.')
- (b'demo', b'.', b'20230904.py')
注意与patition()方法的差别,rpatition()并没有把返回序列的三个元素的顺序倒置过来,r体现的是获取sep的位置。
语法:
bytes.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'')]
,具体取决于被拆分对象的类型。
- >>>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.rsplit(sep=None, maxsplit=- 1)
将二进制序列拆分为相同类型的子序列,使用 sep 作为分隔符。 如果给出了 maxsplit,则最多进行 maxsplit 次拆分,从 最右边 开始。 如果 sep 未指定或为 None,任何只包含 ASCII 空白符的子序列都会被作为分隔符。 除了从右边开始拆分,rsplit() 的其他行为都类似于下文所述的 split()。
bytes.splitlines(keepends=False)
返回由原二进制序列中各行组成的列表,在 ASCII 行边界符的位置拆分。结果列表中不包含换行符,除非给出了 keepends 且为真值。
Unix 的行结束约定 '\n'
、Windows 的约定 '\r\n'
以及旧版 Macintosh 的约定 '\r'
。
不同于 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.ljust(width[, fillbyte])
返回原对象的副本,在长度为 width 的序列中靠左对齐。 使用指定的 fillbyte 填充空位(默认使用 ASCII 空格符)。 对于 bytes 对象,如果 width 小于等于 len(s) 则返回原序列的副本。
语法:
bytes.rjust(width[, fillbyte])
返回原对象的副本,在长度为 width 的序列中靠右对齐。 使用指定的 fillbyte 填充空位(默认使用 ASCII 空格符)。 对于 bytes 对象,如果 width 小于等于 len(s) 则返回原序列的副本。
此方法的 bytearray 版本 并非 原地操作 —— 它总是产生一个新对象,即便没有做任何改变。
语法:
bytes.center(width[, fillbyte])
返回原对象的副本,在长度为 width 的序列内居中,使用指定的 fillbyte 填充两边的空位(默认使用 ASCII 空格符)。对于 bytes 对象,如果 width 小于等于 len(s) 则返回原序列的副本。
语法:
bytes.lstrip([chars])
返回原序列的副本,移除指定的前导字节。 chars 参数为指定要移除字节值集合的二进制序列 —— 这个名称表明此方法通常是用于 ASCII 字符。 如果省略或为 None
,则 chars 参数默认移除 ASCII 空白符。 chars 参数并非指定单个前缀;而是会移除参数值的所有组合:
- >>> b' www'.lstrip()
- b'www'
- >>> b'abc-abc-abcd'.lstrip(b'abcd')
- b'-abc-abcd'
语法:
bytes.rstrip([chars])
返回原序列的副本,移除指定的末尾字节。 chars 参数为指定要移除字节值集合的二进制序列 —— 这个名称表明此方法通常是用于 ASCII 字符。 如果省略或为 None
,则 chars 参数默认移除 ASCII 空白符。 chars 参数并非指定单个后缀;而是会移除参数值的所有组合:
bytes.strip([chars])
返回原序列的副本,移除指定的开头和末尾字节。 chars 参数为指定要移除字节值集合的二进制序列 —— 这个名称表明此方法通常是用于 ASCII 字符。 如果省略或为 None
,则 chars 参数默认移除 ASCII 空白符。 chars 参数并非指定单个前缀或后缀;而是会移除参数值的所有组合:
- >>>b' spacious '.strip()
- b'spacious'
- >>>b'www.example.com'.strip(b'cmowz.')
- b'example'
bytes.isalnum()
如果序列中所有字节都是字母类 ASCII 字符或 ASCII 十进制数码并且序列非空则返回 True
,否则返回 False
。 字母类 ASCII 字符就是字节值包含在序列 b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
中的字符。 ASCII 十进制数码就是字节值包含在序列 b'0123456789'
中的字符。
- >>>b'ABCabc1'.isalnum()
- True
- >>>b'ABC abc1'.isalnum()
- False
bytes.isalpha()
如果序列中所有字节都是字母类 ASCII 字符并且序列不非空则返回 True
,否则返回 False
。 字母类 ASCII 字符就是字节值包含在序列 b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
中的字符。
- >>>b'ABCabc'.isalpha()
- True
- >>>b'ABCabc1'.isalpha()
- False
bytes.isascii()
如果序列为空或序列中所有字节都是 ASCII 字节则返回 True
,否则返回 False
。 ASCII 字节的取值范围是 0-0x7F。
bytes.isdigit()
如果序列中所有字节都是 ASCII 十进制数码并且序列非空则返回 True
,否则返回 False
。 ASCII 十进制数码就是字节值包含在序列 b'0123456789'
中的字符。
bytes.islower()
如果序列中至少有一个小写的 ASCII 字符并且没有大写的 ASCII 字符则返回 True
,否则返回 False
。
bytes.isupper()
如果序列中至少有一个大写字母 ASCII 字符并且没有小写 ASCII 字符则返回 True
,否则返回 False
。
bytes.isspace()
如果序列中所有字节都是 ASCII 空白符并且序列非空则返回 True
,否则返回 False
。 ASCII 空白符就是字节值包含在序列 b' \t\n\r\x0b\f'
(空格, 制表, 换行, 回车, 垂直制表, 进纸) 中的字符。
bytes.istitle()
如果序列为 ASCII 标题大小写形式并且序列非空则返回 True
,否则返回 False
。
其中每个单词以一个大写 ASCII 字符为开头,其余字母为小写。 不区别大小写的字节值将保持原样不变。
bytes.lower()
返回原序列的副本,其所有大写 ASCII 字符均转换为对应的小写形式。
bytes.upper()
返回原序列的副本,其所有小写 ASCII 字符均转换为对应的大写形式。
bytes.swapcase()
返回原序列的副本,其所有小写 ASCII 字符均转换为对应的大写形式,反之亦反。
- >>>b'Hello World'.swapcase()
- b'hELLO wORLD'
bytes.replace(old, new[, count])
返回序列的副本,其中出现的所有子序列 old 都将被替换为 new。 如果给出了可选参数 count,则只替换前 count 次出现。
注意:此方法的 bytearray 版本 并非 原地操作 —— 它总是产生一个新对象,即便没有做任何改变。
bytes.capitalize()
返回原序列的副本,其中每个字节将都将被解读为一个 ASCII 字符,并且第一个字节的字符大写而其余的小写。 非 ASCII 字节值将保持原样不变。
bytes.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'
static bytes.maketrans(from, to)
此静态方法返回一个可用于 bytes.translate() 的转换对照表,它将把 from 中的每个字符映射为 to 中相同位置上的字符;from 与 to 必须都是 字节类对象 并且具有相同的长度。
bytes.translate(table, /, delete=b'')
返回原 bytes 或 bytearray 对象的副本,移除其中所有在可选参数 delete 中出现的 bytes,其余 bytes 将通过给定的转换表进行映射,该转换表必须是长度为 256 的 bytes 对象。
你可以使用 bytes.maketrans() 方法来创建转换表。
- >>>b'read this short text'.translate(None, b'aeiou')
- b'rd ths shrt txt'
bytes.title()
返回原二进制序列的标题版本,其中每个单词以一个大写 ASCII 字符为开头,其余字母为小写。 不区别大小写的字节值将保持原样不变。
该算法使用一种简单的与语言无关的定义,将连续的字母组合视为单词。 该定义在多数情况下都很有效,但它也意味着代表缩写形式与所有格的撇号也会成为单词边界,这可能导致不希望的结果:
- >>>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."
bytes.zfill(width)
返回原序列的副本,在左边填充 b'0' 数码使序列长度为 width。 正负值前缀 (b'+'/ b'-') 的处理方式是在正负符号 之后 填充而非在之前。 对于 bytes 对象,如果 width 小于等于 len(seq) 则返回原序列。
bytes.join(iterable)
返回一个由 iterable 中的二进制数据序列拼接而成的 bytes 或 bytearray 对象。 如果 iterable 中存在任何非 字节类对象 包括存在 str 对象值则会引发 TypeError。 提供该方法的 bytes 或 bytearray 对象的内容将作为元素之间的分隔。
bytearray 对象是 bytes 对象的可变对应物。
class bytearray([source[, encoding[, errors]]])
bytearray 对象没有专属的字面值语法,它们总是通过调用构造器来创建:
bytearray()
bytearray(10)
bytearray(range(20))
bytearray(b'Hi!')
由于 bytearray 对象是可变的,该对象除了 bytes 中所描述的 共有操作之外,还支持 可变 序列操作。
可选形参 source 可以用不同的方式来初始化数组:
bytes的方法,bytearray都支持,用法也一致。
- >>> a = bytearray(3) # 创建一个长度为 3, 元素值为 0 的 bytearray
- >>> a
- bytearray(b'\x00\x00\x00')
- >>> a[0] = 97; a[1] = 255 # 修改数字元素的值
- >>> a
- bytearray(b'a\xff\x00')
- >>> a.append(65) # 追加一个元素到末尾
- >>> a
- bytearray(b'a\xff\x00A')
- >>>
- >>> a = bytearray("abc你好", "utf-8") # 编码字符串创建 bytearray
- >>> a
- bytearray(b'abc\xe4\xbd\xa0\xe5\xa5\xbd')
- >>>
- >>> a = bytearray([1, 2, 3, 65, 97]) # 把整数列表中的各元素串起来转换为 bytearray
- >>> a
- bytearray(b'\x01\x02\x03Aa')
- >>>
- >>> a = bytearray(b"abc123") # 根据 bytes 序列创建 bytearray
- >>> a
- bytearray(b'abc123')
bytearray独有的方法:
bytearray.append(item: int)
添加一个元素到末尾, 值为 [0, 255] 区间内的整数
- # 创建一个二进制串,并赋值
- b = bytearray([0x44, 0x4C, 0x4a, 0x26])
- print(b) # 输出对应ASCII字符串:bytearray(b'DLJ&')
-
- # 添加一个元素
- b.append(0x3A)
- print(b) # 输出对应ASCII字符串:bytearray(b'DLJ&:')
-
- # 创建一个8字节空间,赋空值
- b = bytearray(8)
- print(len(b)) # 输出 --> 8
-
- # 给b设置值
- b[0] = 0x44
- b[1] = 0x4d
- print(b) # bytearray(b'DM\x00\x00\x00\x00\x00\x00')
-
- # 以字符串创建一个二进制
- b = bytearray(b'abc')
- # 修改字符串值
- b[1] = ord('R')
- print(b) # bytearray(b'aRc')
-
- # 通过16进制字符串构建二进制
- b = bytearray.fromhex('444c')
- print(b) # bytearray(b'DL')
-
- # 二进制字符串转换为int,一个int为4字节,需要通过struct模块转换
- import struct
- b = bytearray([0x01, 0x02, 0x03, 0x04])
- print(struct.unpack('i', b)) # 输出(67305985,)
bytearray.insert(index: int, item: int)
在 index 位置插入一个元素, 值为 [0, 255] 区间内的整数
bytearray.extend(iterable)
把可迭代对象的所有元素依次添加到数组的末尾,迭代元素的值必须为 [0, 255] 区间内的整数
bytearray.remove(item: int)
移除一个元素, 从左到右查找
bytearray.pop(index: int = -1)
移除并返回指定位置元素, 默认是最后一个
- my_array = bytearray([1, 2, 3, 4, 5])
- my_array.append(6)
- my_array.extend([7, 8, 9])
- my_array.insert(0, 0)
- my_array.pop(3)
- my_array.remove(4)
- my_array.reverse()
- print(my_array)
-
- bytearray(b'[9, 8, 7, 6, 5, 3, 2, 1, 0')
-
bytearray.reverse()
反转所有数组元素
- # 字节对象
- b = bytes([1, 2, 3, 4, 5])
-
- # 反向迭代器
- reversed_b = reversed(b)
-
- # 反向字节序列
- reversed_bytes = bytes(reversed_b)
-
- print(reversed_bytes)
-
- #b'\x05\x04\x03\x02\x01'
bytearray.copy()
复制数组的内容, 创建其副本返回
bytearray.clear()
清空数组内的所有元素