【雕爷学编程】MicroPython手册之文件操作模块 BytesIO

MicroPython是为了在嵌入式系统中运行Python 3编程语言而设计的轻量级版本解释器。与常规Python相比，MicroPython解释器体积小(仅100KB左右)，通过编译成二进制Executable文件运行，执行效率较高。它使用了轻量级的垃圾回收机制并移除了大部分Python标准库，以适应资源限制的微控制器。

MicroPython主要特点包括:
1、语法和功能与标准Python兼容,易学易用。支持Python大多数核心语法。
2、对硬件直接访问和控制,像Arduino一样控制GPIO、I2C、SPI等。
3、强大的模块系统,提供文件系统、网络、图形界面等功能。
4、支持交叉编译生成高效的原生代码,速度比解释器快10-100倍。
5、代码量少,内存占用小,适合运行在MCU和内存小的开发板上。
6、开源许可,免费使用。Shell交互环境为开发测试提供便利。
7、内置I/O驱动支持大量微控制器平台，如ESP8266、ESP32、STM32、micro:bit、掌控板和PyBoard等。有活跃的社区。

MicroPython的应用场景包括:
1、为嵌入式产品快速构建原型和用户交互。
2、制作一些小型的可 programmable 硬件项目。
3、作为教育工具,帮助初学者学习Python和物联网编程。
4、构建智能设备固件,实现高级控制和云连接。
5、各种微控制器应用如物联网、嵌入式智能、机器人等。

使用MicroPython需要注意:
1、内存和Flash空间有限。
2、解释执行效率不如C语言。
3、部分库函数与标准版有差异。
4、针对平台优化语法,订正与标准Python的差异。
5、合理使用内存资源,避免频繁分配大内存块。
6、利用原生代码提升速度关键部位的性能。
7、适当使用抽象来封装底层硬件操作。

总体来说,MicroPython让Python进入了微控制器领域，是一项重要的创新，既降低了编程门槛，又提供了良好的硬件控制能力。非常适合各类物联网和智能硬件的开发。

MicroPython的BytesIO方法是用于创建一个类似文件对象的方法，它可以在内存中读写字节数据。它的主要特点有：

它接受一个可选的参数，表示要初始化的字节数据。参数可以是一个字节对象或一个整数序列，如b’hello’或[104, 101, 108, 108, 111]。如果不指定参数，默认为空字节对象。
它返回一个类似文件对象的对象，它具有文件对象的一些方法，如read、write、seek、tell、close等。它可以像操作文件一样操作内存中的字节数据。
它可以在不需要实际文件的情况下，实现一些文件操作的功能，如缓冲区、格式化、压缩等。它可以提高性能和效率，也可以避免磁盘空间的占用和损耗。

MicroPython的BytesIO方法的应用场景有：

缓冲数据：可以使用BytesIO方法来创建一个缓冲区对象，用于暂时存储一些字节数据，并在需要时进行读写操作。例如，可以将网络套接字或串口对象中接收到的数据写入到缓冲区对象中，并在合适的时机读取出来。
格式化数据：可以使用BytesIO方法来创建一个格式化对象，用于将一些复杂或结构化的数据转换为字节数据，并进行读写操作。例如，可以将一些数字或字符串数据按照指定的格式写入到格式化对象中，并使用struct模块来解析或打包。
压缩数据：可以使用BytesIO方法来创建一个压缩对象，用于将一些大量或冗余的数据压缩为字节数据，并进行读写操作。例如，可以将一些文本或图片数据写入到压缩对象中，并使用zlib模块来压缩或解压。

MicroPython的BytesIO方法需注意事项有：

创建对象时需要考虑初始化参数的类型和大小，否则可能会出现错误或异常。
操作对象时需要考虑对象的模式和状态，否则可能会导致数据丢失或错误。
操作对象时可能会出现异常，需要使用try-except语句来捕获和处理。

MicroPython的BytesIO方法几个实际运用程序案例如下：

案例1：将网络套接字中接收到的数据写入到缓冲区对象中，并在收到换行符时读取出来并打印：:

import uos
import usocket
from uio import BytesIO

# 创建一个TCP套接字对象
s = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM)

# 绑定到本地地址和端口80
s.bind(('0.0.0.0', 80))

# 监听连接请求
s.listen(1)

# 接受一个连接请求，返回一个新的套接字对象和客户端地址
conn, addr = s.accept()

# 打印客户端地址
print('Connected by', addr)

# 创建一个缓冲区对象
buffer = BytesIO()

# 循环直到套接字关闭
while True:
    # 从套接字中读取1024个字节
    data = conn.read(1024)
    # 如果没有数据，跳出循环
    if not data:
        break
    # 将数据写入到缓冲区对象中
    buffer.write(data)
    # 如果数据中包含换行符
    if b'\n' in data:
        # 定位到缓冲区对象的开头
        buffer.seek(0)
        # 读取缓冲区对象的全部内容，并解码为字符串
        line = buffer.read().decode('utf-8')
        # 打印内容
        print(line)
        # 清空缓冲区对象
        buffer = BytesIO()

# 关闭套接字和缓冲区对象
conn.close()
s.close()
buffer.close()

案例2：将一些数字或字符串数据按照指定的格式写入到格式化对象中，并使用struct模块来解析或打包：:

import uos
from uio import BytesIO
import struct

# 创建一个格式化对象
format = BytesIO()

# 定义要写入的数据
data = [1, 2.0, 'hello']

# 定义数据的格式，分别为一个无符号字节、一个浮点数、一个5字节的字符串
fmt = 'Bfd5s'

# 将数据按照格式打包为字节对象
bytes = struct.pack(fmt, *data)

# 将字节对象写入到格式化对象中
format.write(bytes)

# 定位到格式化对象的开头
format.seek(0)

# 读取格式化对象的全部内容，并按照格式解析为数据
data = struct.unpack(fmt, format.read())

# 打印数据
print(data)

# 关闭格式化对象
format.close()

案例3：将一些文本数据写入到压缩对象中，并使用zlib模块来压缩或解压：:

import uos
from uio import BytesIO
import zlib

# 创建一个压缩对象
compress = BytesIO()

# 定义要写入的文本数据，并编码为字节对象
text = 'This is a long and redundant text that can be compressed'
bytes = text.encode('utf-8')

# 将字节对象写入到压缩对象中
compress.write(bytes)

# 定位到压缩对象的开头
compress.seek(0)

# 读取压缩对象的全部内容，并使用zlib模块来压缩为字节对象
compressed = zlib.compress(compress.read())

# 打印压缩前后的字节长度
print('The length of original bytes is', len(bytes))
print('The length of compressed bytes is', len(compressed))

# 使用zlib模块来解压字节对象，并解码为文本数据
text = zlib.decompress(compressed).decode('utf-8')

# 打印文本数据
print('The text is', text)

# 关闭压缩对象
compress.close()

案例4：内存中读写数据：

from io import BytesIO

# 创建一个BytesIO对象
buffer = BytesIO()

# 写入数据到缓冲区
buffer.write(b"Hello, MicroPython!")

# 从缓冲区读取数据
data = buffer.getvalue()

# 打印读取的数据
print(data)

在这个例子中，我们使用io模块的BytesIO函数创建一个BytesIO对象，即内存中的缓冲区。然后，我们使用write方法将字节数据(b"Hello, MicroPython!")写入缓冲区。接下来，我们使用getvalue方法从缓冲区中读取数据，并将其存储在变量data中。最后，我们打印出读取的数据。

案例5：读取二进制文件：:

from io import BytesIO

# 读取二进制文件到BytesIO对象
with open("data.bin", "rb") as file:
    data = file.read()
    buffer = BytesIO(data)

# 从缓冲区读取数据
buffer.seek(0)
content = buffer.read()

# 打印读取的数据
print(content)

在这个例子中，我们使用io模块的BytesIO函数创建一个BytesIO对象，即内存中的缓冲区。首先，我们使用open函数以二进制模式(“rb”)打开一个名为"data.bin"的文件，并使用read方法读取文件的内容，并将其存储在变量data中。然后，我们将data数据传递给BytesIO对象的构造函数，创建一个填充了文件数据的缓冲区。接下来，我们使用seek方法将读取指针移动到缓冲区的开头，然后使用read方法从缓冲区中读取数据，并将其存储在变量content中。最后，我们打印出读取的数据。

案例6：写入二进制数据到文件：:

from io import BytesIO

# 创建一个BytesIO对象
buffer = BytesIO()

# 写入二进制数据到缓冲区
buffer.write(b"\x41\x42\x43\x44")

# 将缓冲区数据写入文件
with open("data.bin", "wb") as file:
    file.write(buffer.getvalue())

在这个例子中，我们使用io模块的BytesIO函数创建一个BytesIO对象，即内存中的缓冲区。然后，我们使用write方法将二进制数据(b"\x41\x42\x43\x44")写入缓冲区。接下来，我们使用open函数以二进制模式(“wb”)打开一个名为"data.bin"的文件，并使用write方法将缓冲区的数据写入文件。通过使用BytesIO对象，我们可以将数据暂时存储在内存中，并将其写入文件。

案例7：写入和读取二进制数据

import io

# 创建一个 BytesIO 对象
stream = io.BytesIO()

# 写入二进制数据
stream.write(b'Hello, World!')

# 将写入的数据读取出来
data = stream.getvalue()
print(data)

在这个例子中，我们创建了一个 BytesIO 对象 stream。然后，我们使用 write() 方法将二进制数据写入到 stream 中（使用 b’…’ 表示字节字符串）。最后，我们使用 getvalue() 方法获取写入的数据，并将其存储在 data 变量中。然后，我们打印出 data。

案例8：从字节串中读取二进制数据

import io

# 创建一个 BytesIO 对象，并将字节串作为初始数据
data = b'Hello, World!'
stream = io.BytesIO(data)

# 从 stream 中读取数据
read_data = stream.read()
print(read_data)

在这个例子中，我们创建了一个 BytesIO 对象 stream，并将字节串 data 作为初始数据传递给它。然后，我们使用 read() 方法从 stream 中读取数据，并将其存储在 read_data 变量中。最后，我们打印出 read_data。

案例9：在 BytesIO 对象中进行文件操作

import io

# 创建一个 BytesIO 对象
stream = io.BytesIO()

# 将文件内容写入 BytesIO 对象
with open('data.txt', 'rb') as file:
    stream.write(file.read())

# 将 BytesIO 对象的内容写入另一个文件
with open('output.txt', 'wb') as file:
    file.write(stream.getvalue())

在这个例子中，我们创建了一个 BytesIO 对象 stream。然后，我们使用 open() 函数打开一个文件 data.txt，并将其内容以二进制方式读取，并使用 write() 方法将内容写入 stream。接下来，我们使用 open() 函数打开另一个文件 output.txt，以二进制方式写入 stream 的内容（使用 getvalue() 方法获取 stream 的内容）。这样，文件 output.txt 就包含了与 data.txt 相同的内容。

这些案例展示了 MicroPython 中 io.BytesIO 类的实际应用，用于读写二进制数据。BytesIO 对象提供了类似于文件的接口，可以在内存中方便地进行二进制数据的存储和读取操作。