bytearray对象类型
bytearray对象是与bytes对象相对应的可变对象。bytearray对象通过bytearray构造函数建立。bytearray对象是0~255的一个可变序列。bytearray函数生成bytearray对象。
bytearray([source[, encoding[, errors]]])
source参数，可选，可以用几种不同的方式来初始化数组:
・如果它是一个字符串，那么您还必须给出编码(以及可选的错误)参数，将字符串转化成字节序列。
・如果它是一个整数，那么数组将具有这个大小，并将用零初始化。
・如果它是符合缓冲区接口的对象，则将使用对象的只读缓冲区来初始化字节数组。
・如果它是可迭代的，那么它必须是range 0<=x<256的整数的迭代，它被用作数组的初始内容。
・如果没有参数，则创建一个大小为0的数组。
encoding参数，可选，指定编码。
errors参数，可选。
当source参数是一个字符串时
1
2
3
|
b = bytearray('你好', encoding='utf-8')
print(b) # 输出bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
print(type(b)) # 输出<class 'bytearray'>
|
当source参数是一个整数时
1
2
3
|
b = bytearray(5)
print(b) # 输出bytearray(b'\x00\x00\x00\x00\x00')
print(type(b)) # 输出<class 'bytearray'>
|
当source参数是一个可迭代对象，那么这个迭代对象的元素都必须符合0<=x<256
1
2
3
|
b = bytearray([1, 2, 3, 4, 255])
print(b) # 输出bytearray(b'\x01\x02\x03\x04\xff')
print(type(b)) # 输出<class 'bytearray'>
|
无参数时
1
2
3
|
b = bytearray()
print(b) # 输出bytearray(b'')
print(type(b)) # 输出<class 'bytearray'>
|
bytearray是bytes的可变版本，bytes的大部分操作，bytearray都支持。
索引操作
通过索引获取的bytearray将是一个0到256之间的整数。
格式如下，i是索引值。i是正数，从左向右计算，第一个是0，第二个是1，依次类推。i是负数，从右向左计算，第一个是-1，第二个是-2，依次类推。
例如：
1
2
3
4
5
6
7
8
|
a = bytearray("abc",encoding='utf-8')
b = bytearray("你好",encoding='utf-8')
print(a)
print(b)
print(a[0]) # a[0]是"a"
print(b[0]) # b[0]是"\xe4"
print(b[-1]) # i是负数，从右向左计算。-1表示第一个。
|
执行以上程序会输出如下结果：
1
2
3
4
5
|
bytearray(b'abc')
bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
97
228
189
|
注意： 因为bytearray对象是整数序列（类似于元组），对于bytearray对象b，b[0]将是整数，而b[0:1]将是长度为1的bytearray对象。（这与字符串不同，在字符串中，索引和切片都将生成长度为1的字符串对象）
例如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
s = "abc"
b = bytearray("abc",encoding='utf-8')
s1 = s[0]
s2 = s[0:1]
b1 = b[0]
b2 = b[0:1]
print(type(s1))
print(s1)
print(type(s2))
print(s2)
print(type(b1))
print(b1)
print(type(b2))
print(b2)
s3 = s[1]
s4 = s[1:2]
b3 = b[1]
b4 = b[1:2]
print(type(s3))
print(s3)
print(type(s4))
print(s4)
print(type(b3))
print(b3)
print(type(b4))
print(b4)
|
执行以上程序会输出如下结果：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
<class 'str'>
a
<class 'str'>
a
<class 'int'>
97
<class 'bytearray'>
bytearray(b'a')
<class 'str'>
b
<class 'str'>
b
<class 'int'>
98
<class 'bytearray'>
bytearray(b'b')
|
切片操作
bytearray对象支持切片操作，语法格式如下：
bytearray对象[start:end]
start，end都是整数。索引值以 0 为开始值，如果是负数，则从尾部开始。-1为最末尾。
省略start，从0开始。
省略end，则获取剩余所有。
同时省略start和end，则复制当前的字节对象。
bytearray对象[start:end]获取索引值start开始，end结束(不包括end)的范围值。
例如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
a = bytearray("Hello World",encoding='utf-8')
a1 = a[0:2] #获取索引值从0到2(不包括2)的bytearray对象，结果是bytearray(b'He')
a2 = a[6:8] #获取索引值从6到8(不包括8)的bytearray对象，结果是bytearray(b'Wo')
a3 = a[6:-1] #获取索引值从6到-1(不包括-1)的bytearray对象，结果是bytearray(b'Worl')
a4 = a[:2] #获取索引值从0到2(不包括2)的bytearray对象，结果是bytearray(b'He')
a5 = a[6:] #获取索引值从6开始的所有bytearray对象，结果是bytearray(b'World')
a6 = a[:] #复制当前的bytearray对象bytearray(b'Hello World')
print(a1)
print(a2)
print(a3)
print(a4)
print(a5)
print(a6)
|
执行以上程序会输出如下结果：
1
2
3
4
5
6
|
bytearray(b'He')
bytearray(b'Wo')
bytearray(b'Worl')
bytearray(b'He')
bytearray(b'World')
bytearray(b'Hello World')
|
bytearray对象切片还有第三个参数step。表示步长。格式如下：
bytearray对象[start:end:step]
省略step参数时，默认是1，也就是获取索引从start开始，步长为1，到end结束的值。
例如：
1
2
3
4
5
6
7
8
9
10
|
a = bytearray("Hello World",encoding='utf-8')
a1 = a[0:6:2] #获取索引值从0到6(不包括6)，步长为2的bytearray对象，结果是bytearray(b'Hlo')
a2 = a[2:6:2] #获取索引值从2到6(不包括6)，步长为2的bytearray对象，结果是bytearray(b'lo')
a3 = a[::3] #步长为3的bytearray对象，结果是bytearray(b'HlWl')
a4 = a[0:-1:2] #获取索引值从0到-1(不包括-1)，步长为2的bytearray对象，结果是bytearray(b'HloWr')
print(a1)
print(a2)
print(a3)
print(a4)
|
执行以上程序会输出如下结果：
1
2
3
4
|
bytearray(b'Hlo')
bytearray(b'lo')
bytearray(b'HlWl')
bytearray(b'HloWr')
|
bytearray对象连接，复制
加号 + 是字节的连接符，将两边的bytearray对象连接起来。
实例，bytearray对象连接
1
2
3
4
5
6
7
8
|
a = bytearray("abc",encoding='utf-8')
b = bytearray("你好",encoding='utf-8')
print(a)
print(b)
c = a + b
print(c)
|
执行以上程序会输出如下结果：
1
2
3
|
bytearray(b'abc')
bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
bytearray(b'abc\xe4\xbd\xa0\xe5\xa5\xbd')
|
星号 * 表示复制当前字节，紧跟的数字为复制的次数。数字必须是正整数。
实例，bytearray对象复制
1
2
3
4
5
6
7
|
a = bytearray("abc",encoding='utf-8')
b = bytearray("你好",encoding='utf-8')
print(a)
print(b)
print(a * 2)
print(b * 2)
|
执行以上程序会输出如下结果：
1
2
3
4
|
bytearray(b'abc')
bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
bytearray(b'abcabc')
bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd\xe4\xbd\xa0\xe5\xa5\xbd')
|