【Python基础知识库】Python中bytes与bytearray

心已赠人 2023-02-23 03:39 13阅读 0赞

> 常识普及：通常在常用的ASCII、utf-8 和unicode 编码中，像 a 这样一个英文字符，在内存中占一个字节。一个汉字在ASCII和unicode编码里占两个字节，在utf-8 编码中占三个字节。一个字节有八位，也就是八个数字，也叫8个bit 。计算机中的最小储存单位就是bit，bit是二进制的，所以计算机中的数据全都是0和1，没有其他的数字。

*  bytes
    
     *  bytes是字节组成的有序的不可变序列
     *  字符串按照不同的字符集编码encode返回直接序列bytes
        
         *  `encode(encoding="utf-8", errors="strict") -> str`
     *  字节序列bytes按照不同的字符集解码decode返回字符串
        
         *  `bytes.decode(encoding="utf-8", errors="strict") -> str`
     *  bytes的语法：`class bytes([source[, encoding[, errors]]])`
        
         *  若没有输入任何参数，默认就是初始化数组为0个元素：`b = bytes()` \# 空bytes
         *  若source为整数，则返回一个长度为source的初始化数组：`b = bytes(3)` \# b’\\x00\\x00\\x00’ 创造三个空字节，每个字节为空
         *  若source为字符串，这找找指定的encoding讲字符串转换为字节序列：`b = bytes('hello', encoding="utf-8")` \# b’hello’
         *  若source为可迭代类型，这元素必须为\[0,255\]中的整数：`b = bytes([1, 2, 3, 4])` \# b’\\x01\\x02\\x03\\x04’
         *  若source为与buffer接口一致的对象，从一个字节序列或者buffer复制出一个新的不可变的bytes对象：
        
            # 复制bytes对象
            b1 = bytes([0x61, 0x62])
            b2 = b1
            print(b1, b2)
            print(id(b1), id(b2))
            print(b1 is b2)
            
            # 结果
            '''
            b'ab' b'ab'
            3162472152320 3162472152320
            True
            '''
     *  空bytes对象创建方式：
        
         *  通过构造函数创建空bytes：`b = bytes()`
         *  通过空字符串创建空bytes：`b = b''`
     *  bytes操作：与字符串操作基本一样(string)，都是不可变类型
        
         *  替换：`b'Python'.replace(b'P', b'p')` \# 里面的参数也是bytes类型的
         *  查找：`b'Python'.find(b'o')` \# 返回匹配到字节的索引号，未找到返回-1
         *  十六进制数字组成的字符串转换为bytes
        
            # 十六进制数字组成的字符串
            s = '49 20 6c 69 6b 65 20 50 79 74 68 6f 6e'  # 空格是无效的，要空格需要用ASCII编码
            b = bytes.fromhex(s)
            print(b)
            
            # 结果
            '''
            b'I like Python'
            '''
            
            # 字符串转化为十六进制表达
            hex_str = 'I like Python'.encode().hex()
            print(hex_str)
            res = []
            for i in range(len(hex_str)):
                if i % 2 == 0:
                    if i == 0:
                        res.append(hex_str[i])
                    else:
                        w = ' ' + hex_str[i]
                        res.append(w)
                else:
                    res.append(hex_str[i])
            
            print("".join(res))
            
            # 结果
            '''
            49206c696b6520507974686f6e
            49 20 6c 69 6b 65 20 50 79 74 68 6f 6e
            '''
        
         *  将一个字节数组bytes妆花为整数：`int.from_bytes(bytes, byteorder`
        
            # 大端模式将bytes -> int
            num = int.from_bytes(b'abcd', 'big')
            print(num, hex(num))
            
            # 大端模式将int -> bytes
            print(num.to_bytes(4, 'big'))  # 第一个参数是给定字节数，不够会在前面补空字符的ASCII码
            
            b = 97
            print(b.to_bytes(1, 'big'))
            
            # 结果
            '''
            1633837924 0x61626364
            b'abcd'
            b'a'
            '''
     *  字节序：
        
         *  大端模式(big-endian)：尾巴放在大地址端
            
             *  Mac OS使用大端模式
             *  Java虚拟机是大端模式
             *  网络传输更多使用大端模式
         *  小端模式(little-endian)：尾巴放在低地址端
            
             *  Intel X86 CPU使用小端模式
             *  Windows、Linux使用小端模式
 *  bytearray
    
     *  bytearray是字节组成的有序的可变数组
     *  字节数组bytearray按照不同的字符集解码decode返回字符串
        
         *  `bytearray.decode(encoding="utf-8", errors="strict") -> str`
     *  bytearray()方法语法：`class bytearray([source[, encodeing[, errors]]])`，返回一个元素可变的新字节数组，每个元素值必须是\[0,256\]内的整数，其他类型不行
        
         *  若没有输入任何参数，默认就是初始化数组为0个元素：`b = bytearray()` \# b’’ 空bytearray
         *  若source为整数，则返回一个长度为 source 的初始化数组：`b = bytearray(3)` \# bytearray(b’\\x00\\x00\\x00’)
         *  若source为字符串，则按照指定的 encoding 将字符串转换为字节序列：`b = bytearray('python', encoding="utf-8")` \# bytearray(b’python’)
         *  若source为可迭代类型，则元素必须为\[0 ,255\]中的整数：  
            `b = bytearray([1, 2, 3])` \# bytearray(b’\\x01\\x02\\x03’)
         *  若source为与buffer接口一致的对象，从一个字节序列或者buffer复制出一个新的不可变的bytes对象：
        
            # 复制bytes对象
            b1 = bytearray([0x61, 0x62])
            b2 = b1
            print(b1, b2)
            print(id(b1), id(b2))
            print(b1 is b2)
            
            # 结果
            '''
            bytearray(b'ab') bytearray(b'ab')
            1992609708832 1992609708832
            True
            '''
        
         *  bytearray操作：与bytes类型方法相同
         *  替换：`bytearray(b'Python').replace(b'P', b'p')` \# 里面的参数也是bytes类型的
         *  查找：`bytearray(b'Python').find(b'o')` \# 返回匹配到字节的索引号，未找到返回-1
         *  十六进制数字组成的字符串转换为bytearray
        
            # 十六进制数字组成的字符串
            s = '49 20 6c 69 6b 65 20 50 79 74 68 6f 6e'  # 空格是无效的，要空格需要用ASCII编码
            b = bytearray.fromhex(s)
            print(b)
            
            # 结果
            '''
            bytearray(b'I like Python')
            '''
            
            # 字符串转化为十六进制表达
            hex_str = bytearray('I like Python'.encode()).hex()
            print(hex_str)
            res = []
            for i in range(len(hex_str)):
                if i % 2 == 0:
                    if i == 0:
                        res.append(hex_str[i])
                    else:
                        w = ' ' + hex_str[i]
                        res.append(w)
                else:
                    res.append(hex_str[i])
            
            print("".join(res))
            
            # 结果
            '''
            49206c696b6520507974686f6e
            49 20 6c 69 6b 65 20 50 79 74 68 6f 6e
            '''
     *  索引
    
        # 索引返回的是该字节对应的ASCII编码
        b1 = bytearray(b'abcdef')
        print(b1)
        print(b1[0])  # 当取单个字符时，返回的字符所对应的ASCII编码
        print(b1[:3])  # 当取字符序列的时候，返回的是对应的字符片段
        
        # 结果
        '''
        bytearray(b'abcdef')
        97
        bytearray(b'abc')
        '''
    
     *  bytearray增加、插入元素
        
         *  尾部追加元素：
        
            b = bytearray(b'abcd')
            b.append(101)  # 这里参数是[0,255]内的整数
            print(b)
            
            # 结果
            '''
            bytearray(b'abcde')
            '''
        
         *  指定索引位置插入元素：
        
            b = bytearray(b'abcd')
            b.insert(0, 65)  # 这里第一个参数是索引位置，第二个参数是[0,255]内的整数
            print(b)
            
            # 结果
            '''
            bytearray(b'Aabcd')
            '''
     *  bytearray追加可迭代的整数集合，在\[0,255\]范围内
        
            b = bytearray(b'abcd')
            b.extend(range(101, 104))  # 101、102、103
            print(b)
            
            # 结果
            '''
            bytearray(b'abcdefg')
            '''
     *  bytearray移除元素
        
         *  指定索引移除， 索引为空时，默认为-1，表示从移除尾部第一个：
        
            b = bytearray(b'abcd')
            b.pop()
            print(b)
            b.pop(0)
            print(b)
            
            # 结果
            '''
            bytearray(b'abc')
            bytearray(b'bc')
            '''
        
         *  找到第一个value移除，找不到则抛出ValueError异常：
        
            b = bytearray(b'abcd')
            b.remove(99)  # 移除c
            print(b)
            
            # 结果
            '''
            bytearray(b'abd')
            '''
     *  bytearray清空元素
    
        b = bytearray(b'abcd')
        b.clear()
        print(b)
        
        # 结果
        '''
        bytearray(b'')
        '''
    
     *  bytearray元素反转
    
        b = bytearray(b'abcd')
        b.reverse()
        print(b)
        
        # 结果
        '''
        bytearray(b'dcba')
        '''