小编给大家分享一下python中bytes、bytearray是什么意思，希望大家阅读完这篇文章之后都有所收获，下面让我们一起去探讨吧！
bytes、bytearray
python3引入两个新类型：
bytes，不可变，字节序列，可理解为字节组成的列表；
bytearray，字节数组，可变，所有数据都可转为字节数组来处理；
字符串与bytes：
字符串是字符组成的有序序列，字符可用编码来理解；
bytes是字节组成的有序的不可变序列；
bytearray是字节组成的有序的可变序列；
编码与解码：
字符串按照不同的字符集编码encode，返回字节序列bytes；
encode(encoding='utf-8',errors='strict')-->bytes
字节序列按照不同的字符集解码decode，返回字符串；
bytes.decode(encoding='utf-8',errors='strict')-->str
bytearray.decode(encoding='utf-8',errors='stric')-->str
bytes定义：
bytes()，空bytes，没用；
bytes(int)，指定字节的bytes，被0填充，int即size（最低位为1，奇数，用于判断奇偶数）；
bytes(iterable_of_ints)-->bytes，[0-255]的int组成的可迭代对象，常用；
bytes(string,encoding[,errors])-->bytes，等价于string.encode()；
bytes(bytes_or_buffer)-->bytes，immutable copy of bytes_or_buffer，从一个字节序列或者buffer复制出一个新的不可变的bytes对象；
使用b前缀定义，只允许基本ASCII使用字符形式，>b'abc9'，十六进制表示>b'\x41\x61'；
b'...'，是一种格式，用于表示字节序列，引号内的内容不能作为字符串；
例：
In [2]: bytes(range(100))
Out[2]: b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abc'
In [3]: bytes(range(1000)) #超过255
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
----> 1 bytes(range(1000))
ValueError: bytes must be in range(0, 256)
In [4]: bytes([1,3,5]) #1,3,5是ASCII前面的部分
Out[4]: b'\x01\x03\x05'
In [5]: bytes([91,93,95])
Out[5]: b'[]_'
In [7]: bytes('abc','utf8') #bytes(string,encoding[,errors])，编码写为utf8或utf-8都可
Out[7]: b'abc'
In [8]: bytes('abc','utf-8')
Out[8]: b'abc'
In [9]: s1='abc'.encode() #常用
In [10]: type(s1)
Out[10]: bytes
In [11]: s1.decode()
Out[11]: 'abc'
In [12]: s2=bytes(s1)
In [13]: s1 == s2 #==比较内容
Out[13]: True
In [14]: id(s1) is id(s2) #is比较内存地址
Out[14]: False
In [15]: type(s2)
Out[15]: bytes
bytes操作：
和str类似，都是不可变类型，所以方法很多都一样，只不过bytes的方法，输入是bytes，输出是bytes；
bytes.fromhex(string)，类方法，python中对象的方法（类方法）相当于c/c++中的静态方法，python中的静态方法是另一种概念，string必须是2个字符的十六进制形式，'6162 6a6b'空格将被忽略；
hex()，返回十六进制表示的字符串；
索引，b'abcdef'[2]-->int，返回该字节对应的数，int类型；
例：
In [16]: b'abcdef'.replace(b'f',b'k')
Out[16]: b'abcdek'
In [17]: b'abc'.find(b'b')
Out[17]: 1
In [18]: b'abc'.split(b'b')
Out[18]: [b'a', b'c']
In [19]: bytes.fromhex('6162 096a 6b00')
Out[19]: b'ab\tjk\x00'
In [20]: b'abc'.hex()
Out[20]: '616263'
In [21]: 'abc'.encode().hex()
Out[21]: '616263'
In [22]: b'abcdef'[2]
Out[22]: 99
bytearray定义：
bytearray()，空bytearray；
bytearray(int)，指定byte的bytes，被0填充；
bytearray(iterable_of_ints)-->bytearray，[0-255]的int组成的可迭代对象；
bytearray(string,encoding[,errors])-->bytearray，近似string.encode()，不过返回bytearray可变对象；
bytearray(bytes_or_buffer)，从一个字节序列或者buffer复制出一个新的可变的bytearray对象；
注意：b前缀定义的类型是bytes类型，没有前缀指定bytearray类型；
bytearray操作：
和bytes类型的方法相同，另多出一些可变类型的方法；
bytearray.fromhex(string)，string必须是2个字符的十六进制的形式，'6162 6a6b'空格将被忽略；
hex()，返回十六进制表示的字符串；
append(int)
insert(index,int)
extend(iterable_of_ints)，将一个可迭代的整数集合追加到当前bytearray；
pop(index=-1)，从指定索引上移除元素，默认从尾部移除；
remove(value)，找到第一个value移除，找不到抛异常ValueError；
注意：append(),insert(),extend(),pop(),remove()，这些方法使用int类型，值在[0,255]；
clear()，清空bytearray；
reverse()，翻转bytearray，就地修改；
例：
In [23]: bytearray(b'abcdef').replace(b'f',b'k')
Out[23]: bytearray(b'abcdek')
In [24]: bytearray(b'abc').find(b'b')
Out[24]: 1
In [25]: bytearray.fromhex('6162 09 6a 6b00')
Out[25]: bytearray(b'ab\tjk\x00')
In [26]: bytearray('abc'.encode()).hex()
Out[26]: '616263'
In [27]: b1=bytearray()
In [28]: b1.append(97)
In [29]: b1
Out[29]: bytearray(b'a')
In [30]: b1.append(98)
In [31]: b1
Out[31]: bytearray(b'ab')
In [33]: b1.insert(1,98)
In [34]: b1
Out[34]: bytearray(b'abb')
In [35]: b1.extend([65,66,67])
In [36]: b1
Out[36]: bytearray(b'abbABC')
In [37]: b1.remove(66)
In [38]: b1
Out[38]: bytearray(b'abbAC')
In [39]: b1.pop()
Out[39]: 67
In [40]: b1.reverse()
In [41]: b1
Out[41]: bytearray(b'Abba')
In [42]: b1.clear()
线性结构（排队、顺序结构、sequence序列）：可迭代for...in；len()，可获取长度，在外计数，O(1)，__双下划线开头的方法；通过下标可以访问；可切片；
学过的线性结构：list,tuple,str,bytes,bytearray;
切片：
通过索引区间访问线性结构的一段数据；
sequence[start:stop]，表示返回[start,stop]区间的子序列，不包括索引为stop的字符；
支持负索引；
start为0可以忽略，start一定要在stop的左边；
stop为末尾，可省；
超过上界（右边界），就取到末尾；超过下界（左边界），取到开头；注意有方向，理解为一维的x轴-------->，方向自左向右；
[:]，表示从头取到尾，全部元素被取出，等效于copy()方法；
[start:stop:step]，步长切片，step为步长，可以正负整数，默认是1，step要和start:stop同向，否则返回空序列；
例：
In [1]: s='www.magedu.com'
In [2]: s[4:10]
Out[2]: 'magedu'
In [3]: s[:10]
Out[3]: 'www.magedu'
In [4]: s[4:]
Out[4]: 'magedu.com'
In [5]: s[:]
Out[5]: 'www.magedu.com'
In [6]: s[:-1] #不包括最后一个字符
Out[6]: 'www.magedu.co'
In [7]: b1=b'www.magedu.com'
In [8]: b1[-40:40]
Out[8]: b'www.magedu.com'
In [9]: bytearray(b1)[-40:40]
Out[9]: bytearray(b'www.magedu.com')
In [10]: bytearray(b1)[-40:4]
Out[10]: bytearray(b'www.')
In [11]: bytearray(b1)[-10:-4]
Out[11]: bytearray(b'magedu')
In [12]: bytearray(b1)[-10:-12]
Out[12]: bytearray(b'')
In [13]: s
Out[13]: 'www.magedu.com'
In [14]: s[4:10:2]
Out[14]: 'mgd'
In [15]: s[4:10:-2]
Out[15]: ''
In [16]: s[-10:-4:-2]
Out[16]: ''
In [17]: s[-4:-10:2]
Out[17]: ''
In [18]: s[-4:-10:-2] #逆序找并反向打印
Out[18]: '.dg'
封装&解构：
与java中的装箱拆箱是两码事；
python特有语法，被很多语言学习和借鉴；
封装：
将多个值使用逗号分割，组合在一起；
本质上，返回一个元组，只是省略了小括号；
解构：
把线性结构的元素解开，并顺序的赋给其它变量；
左边接纳的变量数要和右边解开的元素个数一致；
解构是python提供的很好的功能，可方便提取复杂数据结构的值，配合_丢弃变量使用，会更加便利；
python3的解构：
使用*变量名接收，但不能单独使用，也不能使用>=2次，否则分不出到底分给哪个变量多些；
被*变量名收集后组成一个列表；
例：
In [1]: t1=(1,2) #定义为tuple
In [2]: t2=1,2 #将1和2封装成tuple，常用，语法糖，封装优先用tuple，解构优先用list
In [3]: type(t1)
Out[3]: tuple
In [4]: type(t2)
Out[4]: tuple
例：
In [6]: a=4
In [7]: b=5
In [8]: temp=a
In [9]: a=b
In [10]: b=temp #这三句相当于temp=b,a;a,b=temp相当于a,b=b,a
In [11]: a
Out[11]: 5
In [12]: b
Out[12]: 4
例：
In [13]: a=4
In [14]: b=5
In [15]: temp=b,a
In [16]: a,b=temp
In [17]: a
Out[17]: 5
In [18]: b
Out[18]: 4
例：
In [17]: a
Out[17]: 5
In [18]: b
Out[18]: 4
In [19]: a,b=b,a #常用，右边封装（先封装成tuple），左边解构（重新赋值）
In [20]: a
Out[20]: 4
In [21]: b
Out[21]: 5
例：
In [22]: lst=[3,5]
In [23]: first,second=lst
In [24]: print(first,second)
3 5
In [25]: a,b=1,2 #先封装再解构
In [26]: a,b=(1,2) #直接解构
In [27]: a,b=[1,2]
In [28]: a
Out[28]: 1
In [29]: b
Out[29]: 2
In [30]: a,b={10,20} #非线性结构
In [31]: a
Out[31]: 10
In [32]: b
Out[32]: 20
In [33]: a,b={'a':10,'b':20} #非线性结构，将字典的key传给a和b
In [34]: a
Out[34]: 'b'
In [35]: b
Out[35]: 'a'
In [36]: a,*b=1,2,3,4,5 #b为list
In [37]: a
Out[37]: 1
In [38]: b
Out[38]: [2, 3, 4, 5]
In [39]: [a,b]=(1,2) #左边虽是list结构，但没赋给变量，只将list结构中的a,b变量赋值了
In [40]: a
Out[40]: 1
In [41]: b
Out[41]: 2
In [42]: [a,b]=1,2
In [43]: (a,b)=30,40
In [44]: a
Out[44]: 30
In [45]: b
Out[45]: 40
In [46]: lst=list(range(1,101,2))
In [47]: head,*mid,tail=lst
In [48]: *lst2=lst #python3解构时*变量名不能单独使用，直接写为lst2=lst即可
File "
*lst2=lst
^
SyntaxError: starred assignment target must be in a list or tuple
In [51]: head,*mid1,*mid2,tail=lst #分不出到底*mid1多还是*mid2多
File "
head,*mid1,*mid2,tail=lst
^
SyntaxError: two starred expressions in assignment
_丢弃变量：
如果不关心一个变量，就可定义改变变量名字为_；
这是一个惯例，是一个不成文的规定，不是标准；
_是一个合法的标识符，也可以作为一个有效的变量使用，但定义为_就是希望不要被使用，除非你明确的知道这个数据需要使用；
_，这个变量本身无任何意义，没有任何可读性，所以不是用来给人使用的，python中很多库都使用这个变量，使用非常广泛，请不要在不明确变量作用域的情况下，使用_，导致和库中的_冲突；
例：
In [52]: head,*mid,tail='abcdefghijklmn'
In [53]: type(mid)
Out[53]: list
In [54]: lst=[9,8,7,6,5]
In [55]: head,*_,tail=lst
In [56]: print(_)
[8, 7, 6]
In [57]: _,*_,tail=lst #_为同一个变量，覆盖了，赋值即定义
In [58]: print(_)
[8, 7, 6]
看完了这篇文章，相信你对“python中bytes、bytearray是什么意思”有了一定的了解，如果想了解更多相关知识，欢迎关注创新互联行业资讯频道，感谢各位的阅读！
另外有需要云服务器可以了解下创新互联cdcxhl.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。