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是什么意思”有了一定的了解，如果想了解更多相關知識，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！