Python-VBA函数之旅-bytearray函数

目录

1、bytearray函数：

1-1、Python：

1-2、VBA：

2、相关文章：

个人主页：非风V非雨-CSDN博客

        bytearray函数在Python中提供了一种可变字节序列的表示方式，这在实际编程中有多种应用场景。常见的应用场景有：

1、二进制数据处理：当需要处理二进制数据时，bytearray()是一个很好的选择。你可以使用它来存储和操作二进制数据，例如，读取或写入文件、网络通信中的数据包等。

2、内存中的缓冲区：bytearray()可以用作内存中的缓冲区，存储临时数据，并在需要时进行修改或传输。这在处理大量数据或需要频繁修改数据的场景中非常有用。

3、网络编程：在网络编程中，经常需要处理字节流。使用bytearray()可以方便地构建、修改和发送字节数据。

4、图像和视频处理：图像和视频数据通常以字节流的形式存储和传输。使用bytearray()可以方便地读取、修改和保存这些数据的特定部分，例如，修改图像的像素值或视频的编码参数。

5、序列化与反序列化：bytearray()可以用来存储序列化后的数据，如将对象转换为字节流进行存储或传输。反序列化时，可以从bytearray()中读取数据并还原为原始对象。

6、加密与解密：在加密和解密算法中，bytearray()可以用来存储和处理加密数据。你可以使用bytearray()来执行加密操作，并将加密后的数据存储在bytearray()中，或者从bytearray()中读取加密数据进行解密。

7、自定义协议：当实现自定义的通信协议时，bytearray()可以用来构建和解析协议中的字节数据。你可以使用bytearray()来定义协议的数据结构，并根据协议规范进行数据的编码和解码。

        这些只是bytearray()的一些常见应用场景，实际上，在处理与字节序列相关的任何任务时，bytearray()都可以作为一个灵活且强大的工具来使用。它的可变性使得它能够在需要时轻松地进行修改和调整，而不需要创建新的字节序列对象。

1、bytearray函数：
1-1、Python：
  1. # 1.函数：bytearray
  2. # 2.功能：用于处理可变字节序列，即创建可修改的字节数组
  3. # 3.语法：bytearray(source, encoding, errors)
  4. # 4.参数：
  5. # 4-1、source>>>
  6. # 1、整数，包括正整数、0和负整数
  7. # 2、字符串
  8. # 3、可迭代对象，包括但不限于以下类型：
  9. # 3-1、序列类型：
  10.         # list(列表)：有序的元素集合
  11.         # tuple(元组)：不可变的有序的元素集合
  12.         # str(字符串)：字符的有序集合
  13.         # bytes(字节序列)：字节的有序集合
  14.         # bytearray(可变字节序列)：可变的字节的有序集合
  15.         # range(范围对象)：表示一个不可变的整数序列
  16.         # memoryview(内存视图)：用于在不需要复制数据的情况下访问对象的内存
  17. # 3-2、集合类型：
  18.         # set(集合)：无序且不包含重复元素的集合
  19.         # frozenset(冻结集合)：不可变的无序且不包含重复元素的集合
  20. # 3-3、字典与字典视图：
  21.         # dict(字典)：无序的键值对集合
  22.         # dict的keys()、values()、items()方法返回的视图对象
  23. # 3-4、文件对象：
  24.         # 打开的文件对象也是可迭代的，可以通过迭代逐行读取文件内容
  25. # 3-5、自定义可迭代对象：
  26.         # 任何定义了__iter__()方法的对象都可以被视为可迭代对象。这个方法应该返回一个迭代器对象
  27. # 3-6、生成器：
  28.         # 生成器函数和生成器表达式创建的生成器对象也是可迭代的
  29. # 3-7、其他内置类型：
  30.         # 某些内置的数据类型或函数返回的对象也可能是可迭代的，比如map、filter、zip等函数返回的对象
  31. # 4-2、encoding>>>表示进行转换时采用的字符编码，默认为UTF-8编码
  32. # 4-3、errors>>>表示错误处理方式(报错级别)，常见的报错级别有：
  33. # 1、strict：严格级别(默认级别)，字符编码有报错时即抛出异常
  34. # 2、ignore：忽略级别，字符编码有报错，忽略掉
  35. # 3、replace：替换级别，字符编码有报错，替换成符号“？”
  36. # 5.返回值：返回一个新的可变字节数组(若3个参数均未提供，则返回长度为0的字节数组)
  37. # 6.说明：
  38. # 6-1、如果参数source为字符串，那么参数encoding也必须提供，否则将提示TypeError错误。详情如下：
  39.        # TypeError: string argument without an encoding
  40.        # print(bytearray("myelsa"))
  41. # 6-2、如果参数source为可迭代对象，那么可迭代对象的元素必须为0-255的范围内的整数，否则将抛出异常。详情如下：
  42.        # ValueError: byte must be in range(0, 256)
  43.        # print(bytearray([1024, 8, 6]))
  44.        # TypeError: 'float' object cannot be interpreted as an integer
  45.        # print(bytearray([3.14, 1.5, 6.0]))
  46. # 6-3、bytearray()函数与bytes()函数的主要区别：前者产生的对象元素可以修改，而后者不能修改
  47. # 7.示例：
  48. # 应用1：二进制数据处理(增、删、改、查等操作)
  49. # 初始化bytearray
  50. data = bytearray([0x01, 0x02, 0x03, 0x04, 0x05])
  51. # 打印原始数据
  52. print("原始数据:", data)
  53. # 增加数据
  54. data.append(0x06)
  55. print("增加数据后的数据:", data)
  56. # 删除数据
  57. del data[2]
  58. print("删除数据后的数据:", data)
  59. # 修改数据
  60. data[3] = 0x07
  61. print("修改数据后的数据:", data)
  62. # 查找数据
  63. index = data.find(0x04)
  64. if index != -1:
  65.     print("找到数据0x04的索引为:", index)
  66. else:
  67.     print("未找到数据0x04")
  68. # 增加数据后的数据: bytearray(b'\x01\x02\x03\x04\x05\x06')
  69. # 删除数据后的数据: bytearray(b'\x01\x02\x04\x05\x06')
  70. # 修改数据后的数据: bytearray(b'\x01\x02\x04\x07\x06')
  71. # 找到数据0x04的索引为: 2
  72.  
  73. # 应用2：内存中的缓冲区(包括初始化、写入数据、读取数据、修改数据、追加数据、切片操作以及清空缓冲区)
  74. # 创建一个bytearray作为内存缓冲区
  75. buffer = bytearray(10)  # 初始化一个大小为10的内存缓冲区
  76. # 向内存缓冲区中写入数据
  77. buffer[0] = 1  # 写入一个字节
  78. buffer[1] = 2
  79. buffer[2:5] = [3, 4, 5]  # 写入多个字节
  80. # 打印缓冲区的内容
  81. print("缓冲区内容:", buffer)
  82. # 读取缓冲区中的数据
  83. first_byte = buffer[0]
  84. print("第一个字节:", first_byte)
  85. # 修改缓冲区中的数据
  86. buffer[3] = 6
  87. print("修改后的缓冲区内容:", buffer)
  88. # 在缓冲区中追加数据
  89. buffer.extend([7, 8, 9])
  90. print("追加数据后的缓冲区内容:", buffer)
  91. # 缓冲区切片操作
  92. sub_buffer = buffer[2:7]  # 获取一个子缓冲区
  93. print("子缓冲区内容:", sub_buffer)
  94. # 缓冲区大小
  95. print("缓冲区大小:", len(buffer))
  96. # 清空缓冲区
  97. del buffer[:]
  98. print("清空后的缓冲区内容:", buffer)
  99. # 缓冲区内容: bytearray(b'\x01\x02\x03\x04\x05\x00\x00\x00\x00\x00')
  100. # 第一个字节: 1
  101. # 修改后的缓冲区内容: bytearray(b'\x01\x02\x03\x06\x05\x00\x00\x00\x00\x00')
  102. # 追加数据后的缓冲区内容: bytearray(b'\x01\x02\x03\x06\x05\x00\x00\x00\x00\x00\x07\x08\t')
  103. # 子缓冲区内容: bytearray(b'\x03\x06\x05\x00\x00')
  104. # 缓冲区大小: 13
  105. # 清空后的缓冲区内容: bytearray(b'')
  106.  
  107. # 应用3：网络编程
  108. import socket
  109. # 创建TCP客户端
  110. def create_tcp_client(server_address, port):
  111.     client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  112.     client_socket.connect((server_address, port))
  113.     return client_socket
  114. # 构建二进制消息
  115. def build_message(data):
  116.     # 假设我们有一个简单的协议，其中每个消息都以一个长度字节开始
  117.     length = len(data).to_bytes(1, byteorder='big')
  118.     message = bytearray(length) + bytearray(data, 'utf-8')
  119.     return message
  120. # 解析二进制消息
  121. def parse_message(message):
  122.     # 假设消息的第一个字节是长度
  123.     length = message[0]
  124.     data = message[1:length + 1].decode('utf-8')
  125.     return data
  126. # 发送消息并接收响应
  127. def send_receive_message(client_socket, message):
  128.     client_socket.sendall(message)
  129.     response = client_socket.recv(4096)  # 假设响应不会超过4096字节
  130.     return response
  131. # 主函数
  132. if __name__ == "__main__":
  133.     SERVER_ADDRESS = 'localhost'
  134.     PORT = 12345
  135.     MESSAGE = "Hello, Python!"
  136.     # 创建TCP客户端
  137.     client_socket = create_tcp_client(SERVER_ADDRESS, PORT)
  138.     # 构建二进制消息
  139.     binary_message = build_message(MESSAGE)
  140.     # 发送消息并接收响应
  141.     response = send_receive_message(client_socket, binary_message)
  142.     # 解析响应
  143.     response_data = parse_message(response)
  144.     # 打印响应
  145.     print("Received response:", response_data)
  146.     # 关闭连接
  147.     client_socket.close()
  148.  
  149. # 应用4：图像和视频处理(注意：运行此程序，需要确保已经安装了pillow库)
  150. from PIL import Image
  151. import io
  152. # 读取图像文件到bytearray
  153. def read_image_to_bytearray(image_path):
  154.     with open(image_path, 'rb') as file:
  155.         byte_data = bytearray(file.read())
  156.     return byte_data
  157. # 将bytearray写回到图像文件
  158. def write_bytearray_to_image(byte_data, output_path):
  159.     with open(output_path, 'wb') as file:
  160.         file.write(byte_data)
  161. # 读取图像并显示
  162. def display_image(image_path):
  163.     image = Image.open(image_path)
  164.     image.show()
  165. # 主函数
  166. if __name__ == "__main__":
  167.     # 使用原始字符串或双反斜杠来处理Windows文件路径
  168.     input_image_path = r'E:\python_workspace\pythonProject\input.jpg'
  169.     output_image_path = r'E:\python_workspace\pythonProject\output.jpg'
  170.     try:
  171.         # 读取图像到bytearray
  172.         image_bytearray = read_image_to_bytearray(input_image_path)
  173.         # 显示原始图像
  174.         display_image(input_image_path)
  175.         # 将bytearray写回到新的图像文件
  176.         write_bytearray_to_image(image_bytearray, output_image_path)
  177.         # 显示从bytearray写回的图像，以验证内容是否正确
  178.         display_image(output_image_path)
  179.     except Exception as e:
  180.         print(f"An error occurred: {e}")
  181.  
  182. # 应用5：序列化与反序列化
  183. import struct
  184. def serialize_integers(integers):
  185.     # 创建一个空的bytearray
  186.     byte_data = bytearray()
  187.     # 将每个整数转换为4字节的二进制数据并添加到bytearray中
  188.     for integer in integers:
  189.         # 使用struct来将整数打包为4字节的二进制数据
  190.         packed_integer = struct.pack('i', integer)
  191.         byte_data.extend(packed_integer)
  192.     return byte_data
  193. def deserialize_integers(byte_data):
  194.     integers = []
  195.     # 以4字节为单位从bytearray中读取数据，并解包为整数
  196.     while byte_data:
  197.         # 使用struct来将4字节的二进制数据解包为整数
  198.         unpacked_integer = struct.unpack('i', byte_data[:4])[0]
  199.         integers.append(unpacked_integer)
  200.         # 移除已处理的4字节数据
  201.         byte_data = byte_data[4:]
  202.     return integers
  203. # 主函数
  204. if __name__ == '__main__':
  205.     # 用于序列化与反序列化整数列表
  206.     original_integers = [3, 5, 6, 8, 10, 11, 24]
  207.     # 序列化整数列表为bytearray
  208.     serialized_data = serialize_integers(original_integers)
  209.     print("Serialized bytearray:", serialized_data)
  210.     # 反序列化bytearray为整数列表
  211.     deserialized_integers = deserialize_integers(serialized_data)
  212.     print("Deserialized integers:", deserialized_integers)
  213.     # 验证反序列化后的数据是否与原始数据相同
  214.     assert original_integers == deserialized_integers
  215.     print("Serialization and deserialization successful!")
  216. # Serialized bytearray: bytearray(b'\x03\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x08\x00\x00\x00\n\x00\x00\x00\x0b\x00\x00\x00\x18\x00\x00\x00')
  217. # Deserialized integers: [3, 5, 6, 8, 10, 11, 24]
  218. # Serialization and deserialization successful!
  219.  
  220. # 应用6：加密与解密(注意：运行此程序，需确保已经安装了加密算法库pycryptodome)
  221. from Crypto.Cipher import AES
  222. from Crypto.Util.Padding import pad, unpad
  223. from Crypto.Random import get_random_bytes
  224. def encrypt_data(key, plaintext):
  225.     # AES加密要求密钥长度为16（AES128）、24（AES192）或32（AES256）字节
  226.     # 如果密钥长度不足，可以通过某种方式（如哈希函数）扩展它
  227.     # 这里我们假设key已经是合适的长度
  228.     cipher = AES.new(key, AES.MODE_CBC)
  229.     # 对明文进行填充，使其长度为16的倍数
  230.     padded_plaintext = pad(plaintext, AES.block_size)
  231.     # 加密填充后的明文
  232.     ciphertext = cipher.encrypt(padded_plaintext)
  233.     # 获取初始化向量（IV），它用于CBC模式
  234.     iv = cipher.iv
  235.     # 返回IV和密文，通常将它们拼接在一起
  236.     return iv + ciphertext
  237. def decrypt_data(key, encrypted_data):
  238.     # 分离IV和密文
  239.     iv = encrypted_data[:AES.block_size]
  240.     ciphertext = encrypted_data[AES.block_size:]
  241.     # 使用相同的IV和密钥创建解密器
  242.     cipher = AES.new(key, AES.MODE_CBC, iv=iv)
  243.     # 解密密文
  244.     decrypted_padded_text = cipher.decrypt(ciphertext)
  245.     # 去除填充
  246.     decrypted_text = unpad(decrypted_padded_text, AES.block_size)
  247.     return decrypted_text
  248. # 主函数
  249. if __name__ == '__main__':
  250.     key = get_random_bytes(16)  # 生成一个随机的16字节AES密钥
  251.     plaintext = b"I love python very much"  # 明文消息，必须是bytes类型
  252.     # 加密
  253.     encrypted_data = encrypt_data(key, plaintext)
  254.     print("Encrypted data:", encrypted_data)
  255.     # 解密
  256.     decrypted_text = decrypt_data(key, encrypted_data)
  257.     print("Decrypted text:", decrypted_text)
  258.     # 验证解密后的文本是否与原始明文相同
  259.     assert plaintext == decrypted_text
  260.     print("Encryption and decryption successful!")
  261. # Encrypted data: b'\x0f`\xdd\x95\x1bA\x1d.\xc7\x1d\xb6\xa1<60\xbf\xac\x99\x86\x92\x08\xc6@\xa5\x0c\xcc\x96\x00L>\x8f\x95\x03\xc5P\x8d\x11\xd0=\x14\xf6\xa5p\xf8\xc4\x141o'
  262. # Decrypted text: b'I love python very much'
  263. # Encryption and decryption successful!
  264.  
  265. # 应用7：自定义协议
  266. def encode_message(data):
  267.     # 将数据编码为字节
  268.     data_bytes = data.encode('utf-8')
  269.     # 计算消息长度，并转换为4字节的整数表示(如果需要支持更长的消息，应增加字节数)
  270.     length = len(data_bytes).to_bytes(4, 'big')
  271.     # 构建完整的消息：消息头(长度)+ 消息体
  272.     message = bytearray(length) + bytearray(data_bytes)
  273.     return message
  274. def decode_message(message_bytes):
  275.     # 检查消息长度是否至少为4字节(消息头长度)
  276.     if len(message_bytes) < 4:
  277.         raise ValueError("消息太短，无法包含有效的标头!")
  278.     # 提取消息头中的长度信息
  279.     length = int.from_bytes(message_bytes[:4], 'big')
  280.     # 检查消息体长度是否与头部指定的长度一致
  281.     if len(message_bytes) != 4 + length:
  282.         raise ValueError("消息正文长度与标头中指定的长度不匹配!")
  283.     # 提取消息体
  284.     data_bytes = message_bytes[4:4 + length]
  285.     # 将字节解码为字符串
  286.     data = data_bytes.decode('utf-8')
  287.     return data
  288. # 主函数
  289. if __name__ == '__main__':
  290.     # 编码和解码消息
  291.     original_data = "Hello, Python!"
  292.     encoded_message = encode_message(original_data)
  293.     print("Encoded message:", encoded_message)
  294.     decoded_data = decode_message(encoded_message)
  295.     print("Decoded data:", decoded_data)
  296.     # 验证解码后的数据是否与原始数据相同
  297.     assert original_data == decoded_data
  298.     print("Encoding and decoding successful!")
  299. # Encoded message: bytearray(b'\x00\x00\x00\x0eHello, Python!')
  300. # Decoded data: Hello, Python!
  301. # Encoding and decoding successful!
1-2、VBA：
  1. Rem 模拟Python中bytearray函数应用2：内存中的缓冲区(包括初始化、写入数据、读取数据、修改数据、追加数据、切片操作以及清空缓冲区)
  2. Sub TestRun_1()
  3.     Dim buffer() As Byte
  4.     Dim n As Byte, m As Byte
  5.     Dim first_byte As Byte
  6.     Dim sub_buffer() As Byte
  7.     Dim i As Integer
  8.     Dim j As Integer
  9.       
  10.     ' 初始化大小为10的缓冲区(索引从0到9)
  11.     ReDim buffer(9)
  12.       
  13.     ' 填充缓冲区的前5个字节
  14.     For n = 0 To 4
  15.         buffer(n) = n + 1
  16.     Next n
  17.       
  18.     ' 打印缓冲区内容
  19.     Debug.Print "缓冲区内容:"
  20.     For i = LBound(buffer) To UBound(buffer)
  21.         If buffer(i) <> 0 Then
  22.             Debug.Print Hex(buffer(i)),
  23.         End If
  24.     Next i
  25.     Debug.Print
  26.       
  27.     ' 读取第一个字节
  28.     first_byte = buffer(0)
  29.     Debug.Print "第一个字节:", Hex(first_byte)
  30.       
  31.     ' 修改缓冲区的第4个字节
  32.     buffer(3) = 6
  33.       
  34.     ' 打印修改后的缓冲区内容
  35.     Debug.Print "修改后的缓冲区内容:"
  36.     For i = LBound(buffer) To UBound(buffer)
  37.         If buffer(i) <> 0 Then
  38.             Debug.Print Hex(buffer(i)),
  39.         End If
  40.     Next i
  41.     Debug.Print
  42.       
  43.     ' 在缓冲区末尾追加3个字节
  44.     ReDim Preserve buffer(UBound(buffer) + 2)
  45.     buffer(UBound(buffer) - 2) = 7
  46.     buffer(UBound(buffer) - 1) = 8
  47.     buffer(UBound(buffer)) = 9
  48.     Next
  49.       
  50.     ' 打印追加数据后的缓冲区内容
  51.     Debug.Print "追加数据后的缓冲区内容:"
  52.     For i = LBound(buffer) To UBound(buffer)
  53.         If buffer(i) <> 0 Then
  54.             Debug.Print Hex(buffer(i)),
  55.         End If
  56.     Next i
  57.     Debug.Print
  58.       
  59.     ' 创建子缓冲区并复制指定范围的数据
  60.     ReDim sub_buffer(UBound(buffer) - LBound(buffer) - 3)
  61.     j = 0
  62.     For i = 2 To 5
  63.         sub_buffer(j) = buffer(i)
  64.         j = j + 1
  65.     Next i
  66.       
  67.     ' 打印子缓冲区内容
  68.     Debug.Print "子缓冲区内容:"
  69.     For i = LBound(sub_buffer) To UBound(sub_buffer)
  70.         Debug.Print Hex(sub_buffer(i)),
  71.     Next i
  72.     Debug.Print
  73.       
  74.     ' 打印缓冲区大小
  75.     Debug.Print "缓冲区大小:", UBound(buffer) - LBound(buffer) + 1
  76.       
  77.     ' 清空缓冲区
  78.     ReDim buffer(0)
  79.       
  80.     ' 打印清空后的缓冲区内容(实际上为空，无需循环打印)
  81.     Debug.Print "清空后的缓冲区内容:"
  82. End Sub
  83. '缓冲区内容:
  84. '1             2             3             4             5
  85. '第一个字节:   1
  86. '修改后的缓冲区内容:
  87. '1             2             3             6             5
  88. '追加数据后的缓冲区内容:
  89. '1             2             3             6             5             7             8             9
  90. '子缓冲区内容:
  91. '3             6             5             0             0             0             0             0             0
  92. '缓冲区大小:    12
  93. '清空后的缓冲区内容:
  94. '

注意：1-2中的代码需粘贴到你的VBA编辑器中，按F5执行对应的Sub程序即可输出结果。 

2、相关文章：

2-1、 Python-VBA函数之旅-bin()函数

2-2、Python-VBA函数之旅-bool()函数 

2-3、Python-VBA函数之旅-bytes()函数 

2-4、Python-VBA函数之旅-callable()函数​​​​​​​ 

Python算法之旅：Algorithm

Python函数之旅：Function

个人主页：非风V非雨-CSDN博客

欢迎志同道合者一起交流学习，我的QQ:94509325/微信：

文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览60120 人正在系统学习中
遨游码海，我心飞扬
微信名片
注：本文转载自blog.csdn.net的神奇夜光杯的文章"https://myelsa1024.blog.csdn.net/article/details/137591235"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！