python中bytes、bytearray是什么意思

小编给大家分享一下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)

<ipython-input-3-a7e270a52df2> in <module>()

----> 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 "<ipython-input-48-90c12e6f75df>", line 1

    *lst2=lst

             ^

SyntaxError: starred assignment target must be in a list or tuple

In [51]: head,*mid1,*mid2,tail=lst   #分不出到底*mid1多还是*mid2多

  File "<ipython-input-51-7380bcea7c56>", line 1

    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是什么意思”有了一定的了解，如果想了解更多相关知识，欢迎关注亿速云行业资讯频道，感谢各位的阅读！