Python代码：




```powershell
import os
def split_file(input_file, output_dir, chunk_size):
    with open(input_file, 'rb') as f:
        index = 0
        while True:
            chunk = f.read(chunk_size)
            if not chunk:
                break
            output_file = os.path.join(output_dir, f'chunk_{index}.dat')
            with open(output_file, 'wb') as out:
                out.write(chunk)
            index += 1
def merge_files(input_dir, output_file):
    files = os.listdir(input_dir)
    files.sort()
    with open(output_file, 'wb') as out:
        for file_name in files:
            file_path = os.path.join(input_dir, file_name)
            with open(file_path, 'rb') as f:
                chunk = f.read()
                out.write(chunk)
# 切分大文件
split_file('big_file.dat', 'output_dir', 10 * 1024 * 1024)  # 每个小文件大小为10GB
# 合并小文件
merge_files('output_dir', 'merged_file.dat')
```

【Python】大文件切分为小文件，小文件组合为大文件

# 概括





注意，在哪个平台运行打包，就会对应生成那个平台的可执行文件。比如我在windows中执行，我将会得到exe执行包。

使用PyInstaller打包Python代码成为可执行的exe文件非常简单。以下是基本的步骤：

**1、确保你已经安装了PyInstaller。如果没有安装，可以通过以下命令来安装：**

```powershell
pip install pyinstaller
```


**2、打开终端或命令提示符，并导航到你的Python代码所在的目录。**

**3、在终端或命令提示符中运行以下命令：**

```powershell
pyinstaller -F your_script.py
```

其中，your_script.py 是你要打包的Python脚本的文件名。

**4、PyInstaller将会自动分析你的脚本，并创建一个与你的脚本同名的文件夹。**

**5、在生成的文件夹中，你可能会看到一些额外的文件，例如.spec文件和一个名为dist的文件夹。**

**6、最终的可执行文件可以在dist文件夹中找到，文件名通常与你的脚本的文件名相同。**

现在，你就可以将生成的可执行文件(.exe)拷贝到其他机器上，并在不安装Python解释器的情况下运行你的代码了。


常用指令：

```powershell
Pyinstaller -F setup.py # 打包exe
Pyinstaller -F -w setup.py # 不带控制台的打包
Pyinstaller -F -i xx.ico setup.py # 打包指定exe图标打包
```

# 混合打包

参考：

https://blog.csdn.net/tangfreeze/article/details/112240342

https://pyinstaller.org/en/stable/spec-files.html#adding-files-to-the-bundle

我想将一些资源文件也打包进exe如何办？

运行：

```powershell
pyinstaller -F -w -i 2.ico  --add-data  ".\1.ico;."  setup.py
```

-i 图标路径

–icon=图标路径

-F 打包成一个exe文件

-w 使用窗口，无控制台

-c 使用控制台，无窗口

-D 创建一个目录，里面包含exe以及其他一些依赖性文件


# 重要！

完成打包后，setup.exe里面如果依赖了外部文件，应该注意python找文件的写法：

![在这里插入图片描述](/static/img/images/04384.png)

比如：

```python
import sys
import tkinter as tk
from os import path
from tkinter import ttk
import serial
import threading
# 先获取当前运行时临时目录路径
if getattr(sys, 'frozen', None):
    basedir = sys._MEIPASS
else:
    basedir = path.dirname(__file__)
ico_file = path.join(basedir, '1.ico')
```

【python】如何使用pyinstaller打包python代码成为可执行的exe，依赖文件加入

# 最终效果





![在这里插入图片描述](/static/img/images/04385.png)

# python环境

```powershell
pip install pyserial 
```

#  部分代码

```python
import tkinter as tk
from tkinter import ttk
import serial
import threading
class info_window:
    def __init__(self, in_str, parent):
        self.parent = parent  # 保存父窗口对象
        self.window = tk.Toplevel(parent)
        self.window.title("提示")
        self.window.iconbitmap('1.ico')
        self.window.geometry("220x60")
        label = tk.Label(self.window, text=in_str)
        buttonOK = tk.Button(self.window, text="OK", command=self.button_ok)
        label.pack(side=tk.TOP)
        buttonOK.pack(side=tk.BOTTOM)
        # 移动到parent屏幕中央
        self.window.update()
        x = self.parent.winfo_x() + (self.parent.winfo_width() - self.window.winfo_reqwidth()) / 2
        y = self.parent.winfo_y() + (self.parent.winfo_height() - self.window.winfo_reqheight()) / 2
        self.window.geometry("+%d+%d" % (x, y))
    def button_ok(self):
        self.window.destroy()
class main_gui:
    def __init__(self):
        self.window = tk.Tk()
        self.window.title("代做QQ742971636")
        self.window.iconbitmap('1.ico')
        self.uartState = False  # is uart open or not
        self.is_running = True
        # 帧布：1
        config_frame = tk.Frame(self.window)
        config_frame.grid(row=1, column=1)
        label_com = tk.Label(config_frame, text="COMx: ")
        self.COM = tk.StringVar(value="COM4")
        ertryCOM = tk.Entry(config_frame, textvariable=self.COM)
        label_com.grid(row=1, column=1, padx=5, pady=3)
        ertryCOM.grid(row=1, column=2, padx=5, pady=3)
        label_baudrate = tk.Label(config_frame, text="波特率: ")
        self.Baudrate = tk.IntVar(value=9600)
        ertryBaudrate = tk.Entry(config_frame, textvariable=self.Baudrate)
        label_baudrate.grid(row=1, column=3, padx=5, pady=3)
        ertryBaudrate.grid(row=1, column=4, padx=5, pady=3)
        labelParity = tk.Label(config_frame, text="校验位: ")
        self.Parity = tk.StringVar(value="NONE")
        comboParity = ttk.Combobox(config_frame, width=17, textvariable=self.Parity)
        comboParity["values"] = ("NONE", "ODD", "EVEN", "MARK", "SPACE")
        comboParity["state"] = "readonly"
        labelParity.grid(row=2, column=1, padx=5, pady=3)
        comboParity.grid(row=2, column=2, padx=5, pady=3)
        labelStopbits = tk.Label(config_frame, text="停止位: ")
        self.Stopbits = tk.StringVar(value="1")
        comboStopbits = ttk.Combobox(config_frame, width=17, textvariable=self.Stopbits)
        comboStopbits["values"] = ("1", "1.5", "2")
        comboStopbits["state"] = "readonly"
        labelStopbits.grid(row=2, column=3, padx=5, pady=3)
        comboStopbits.grid(row=2, column=4, padx=5, pady=3)
        labelDatabits = tk.Label(config_frame, text="数据位: ")
        self.Databits = tk.StringVar(value="8")
        comboDatabits = ttk.Combobox(config_frame, width=17, textvariable=self.Databits)
        comboDatabits["values"] = ("8", "7", "6", "5")
        comboDatabits["state"] = "readonly"
        labelDatabits.grid(row=3, column=1, padx=5, pady=3)
        comboDatabits.grid(row=3, column=2, padx=5, pady=3)
        # 帧布：2
        frame_open_serial = tk.Frame(self.window)
        frame_open_serial.grid(row=2, column=1)
        self.buttonSS = tk.Button(frame_open_serial, text="打开串口", command=self.open_serial)
        self.buttonSS.pack(side=tk.BOTTOM)
        # serial object
        self.ser = serial.Serial()
        self.read_data_from_serialThread = threading.Thread(target=self.read_data_from_serial)
        self.read_data_from_serialThread.start()
        # 帧布：3
        rev_frame = tk.Frame(self.window)
        rev_frame.grid(row=3, column=1)
        labelOutText = tk.Label(rev_frame, text="接收数据:")
        labelOutText.grid(row=1, column=1, padx=3, pady=2, sticky=tk.W)
        rev_frameSon = tk.Frame(rev_frame)
        rev_frameSon.grid(row=2, column=1)
        scrollbarRecv = tk.Scrollbar(rev_frameSon)
        scrollbarRecv.pack(side=tk.RIGHT, fill=tk.Y)
        self.OutputText = tk.Text(rev_frameSon, wrap=tk.WORD, width=60, height=20, yscrollcommand=scrollbarRecv.set)
        self.OutputText.pack()
        # 帧布：4
        clear_frame = tk.Frame(self.window)
        clear_frame.grid(row=4, column=1)
        self.buttonClear = tk.Button(clear_frame, text="清空", command=self.clear_received_data)
        self.buttonClear.pack(side=tk.BOTTOM)
        # 帧布：5
        transfer_frame = tk.Frame(self.window)
        transfer_frame.grid(row=5, column=1)
        labelInText = tk.Label(transfer_frame, text="发送数据:")
        labelInText.grid(row=1, column=1, padx=3, pady=2, sticky=tk.W)
        transfer_frameSon = tk.Frame(transfer_frame)
        transfer_frameSon.grid(row=2, column=1)
        scrollbarTrans = tk.Scrollbar(transfer_frameSon)
        scrollbarTrans.pack(side=tk.RIGHT, fill=tk.Y)
        self.InputText = tk.Text(transfer_frameSon, wrap=tk.WORD, width=60, height=5, yscrollcommand=scrollbarTrans.set)
        self.InputText.insert(tk.END, "qq742971636代码测试\r\n")
        self.InputText.pack()
        # 帧布：6
        send_frame = tk.Frame(self.window)
        send_frame.grid(row=6, column=1)
        self.buttonSend = tk.Button(send_frame, text="发送", command=self.send_data_to_serial)
        self.buttonSend.pack(side=tk.BOTTOM)
        self.window.protocol("WM_DELETE_WINDOW", self.on_closing)
        self.window.mainloop()
    def clear_received_data(self):
        self.OutputText.delete('1.0', tk.END)
    def open_serial(self):
        if self.uartState:
            self.ser.close()
            self.buttonSS["text"] = "打开串口"
            self.uartState = False
        else:
            # restart serial port
            self.ser.port = self.COM.get()
            self.ser.baudrate = self.Baudrate.get()
            strParity = self.Parity.get()
            if strParity == "NONE":
                self.ser.parity = serial.PARITY_NONE
            elif strParity == "ODD":
                self.ser.parity = serial.PARITY_ODD
            elif strParity == "EVEN":
                self.ser.parity = serial.PARITY_EVEN
            elif strParity == "MARK":
                self.ser.parity = serial.PARITY_MARK
            elif strParity == "SPACE":
                self.ser.parity = serial.PARITY_SPACE
            strStopbits = self.Stopbits.get()
            if strStopbits == "1":
                self.ser.stopbits = serial.STOPBITS_ONE
            elif strStopbits == "1.5":
                self.ser.stopbits = serial.STOPBITS_ONE_POINT_FIVE
            elif strStopbits == "2":
                self.ser.stopbits = serial.STOPBITS_TWO
            # 数据位8位
            strDatabits = self.Databits.get()
            if strDatabits == "8":
                self.ser.bytesize = serial.EIGHTBITS
            elif strDatabits == "7":
                self.ser.bytesize = serial.SEVENBITS
            elif strDatabits == "6":
                self.ser.bytesize = serial.SIXBITS
            elif strDatabits == "5":
                self.ser.bytesize = serial.FIVEBITS
            try:
                self.ser.open()
            except:
                infromStr = "不能打开串口 " + self.ser.port
                info_window(infromStr, self.window)
            if self.ser.isOpen():  # open success
                self.buttonSS["text"] = "关闭串口"
                self.uartState = True
## 实验报告：串口通信图形用户界面设计与实现
### 背景
本实验旨在设计和实现一个基于Python的图形用户界面（GUI），用于通过串口进行数据传输和接收。该界面允许用户配置串口参数，如端口号、波特率、校验位、停止位和数据位，并实现数据的发送与接收。串口通信在嵌入式系统、物联网设备以及工业控制等领域中广泛应用，能够实现不同设备之间的可靠通信。
### 器件与工具
1. 计算机
2. Python 3.x
3. Tkinter库（用于GUI开发）
4. PySerial库（用于串口通信）
5. 串口设备（如开发板、传感器等）
### 硬件连接
1. 将计算机通过USB连接到串口设备。
2. 确认串口设备的端口号（如COM4）。
3. 根据设备的规格设置合适的波特率、校验位、停止位和数据位。
### 设计原理
本实验通过Tkinter库创建一个图形用户界面，用户可以在界面中配置串口参数并进行数据的发送和接收。PySerial库用于实现串口通信。界面包括以下功能模块：
1. 串口配置模块：用户可以选择端口号、波特率、校验位、停止位和数据位。
2. 串口控制模块：打开和关闭串口。
3. 数据接收模块：显示接收到的数据。
4. 数据发送模块：用户输入要发送的数据并发送到串口。
### 电路原理
电路连接较为简单，计算机通过USB接口与串口设备相连。串口设备的TX（发送）引脚连接到计算机的RX（接收）引脚，RX引脚连接到计算机的TX引脚，GND引脚连接到计算机的GND引脚。
### 程序原理
程序使用Tkinter库创建主窗口和各个子窗口，使用PySerial库实现串口的打开、关闭、读写操作。程序包括以下几个主要部分：
#### 串口配置
串口配置部分通过创建文本框和下拉菜单，供用户输入和选择端口号、波特率、校验位、停止位和数据位。以下代码片段展示了如何创建这些配置选项：
```python

config_frame = tk.Frame(self.window)

config_frame.grid(row=1, column=1)

label_com = tk.Label(config_frame, text="COMx: ")

self.COM = tk.StringVar(value="COM4")

ertryCOM = tk.Entry(config_frame, textvariable=self.COM)

label_com.grid(row=1, column=1, padx=5, pady=3)

ertryCOM.grid(row=1, column=2, padx=5, pady=3)

label_baudrate = tk.Label(config_frame, text="波特率: ")

self.Baudrate = tk.IntVar(value=9600)

ertryBaudrate = tk.Entry(config_frame, textvariable=self.Baudrate)

label_baudrate.grid(row=1, column=3, padx=5, pady=3)

ertryBaudrate.grid(row=1, column=4, padx=5, pady=3)
```
#### 串口控制
串口控制部分包括打开和关闭串口的功能，通过点击按钮触发相应的事件。以下代码展示了如何实现串口的打开和关闭：
```python

def open_serial(self):

    if self.uartState:

        self.ser.close()

        self.buttonSS["text"] = "打开串口"

        self.uartState = False

    else:

        self.ser.port = self.COM.get()

        self.ser.baudrate = self.Baudrate.get()

        self.ser.open()

        if self.ser.isOpen():

            self.buttonSS["text"] = "关闭串口"

            self.uartState = True
```
#### 数据接收与显示
数据接收部分通过创建一个线程不断读取串口数据，并将数据显示在文本框中：
```python

self.read_data_from_serialThread = threading.Thread(target=self.read_data_from_serial)

self.read_data_from_serialThread.start()

def read_data_from_serial(self):

    while self.is_running:

        if self.ser.isOpen():

            data = self.ser.read_all()

            if data:

                self.OutputText.insert(tk.END, data.decode('utf-8'))

                self.OutputText.see(tk.END)
```
#### 数据发送
数据发送部分允许用户在文本框中输入要发送的数据，并通过点击按钮发送数据到串口：
```python

def send_data_to_serial(self):

    if self.ser.isOpen():

        data = self.InputText.get("1.0", tk.END).strip()

        self.ser.write(data.encode('utf-8'))
```

### 实验结果

通过上述设计和实现，成功开发了一个功能完整的串口通信图形用户界面。用户可以方便地配置串口参数，打开和关闭串口，发送和接收数据。该界面运行稳定，能够满足基本的串口通信需求。

### 结论

本实验通过使用Tkinter和PySerial库，实现了一个简单但功能强大的串口通信图形用户界面。该界面为用户提供了友好的操作方式，便于进行串口通信的配置和数据传输。未来可以在此基础上扩展更多功能，如增加日志记录、数据分析等。

### 参考文献

- Python官方文档

- Tkinter库使用手册

- PySerial库使用手册


资源

https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2

【python】基于TK Tkinter pyserial 串口调试助手，支持中英文编码

在C++中将cv::Mat保存为文件，然后在Python中加载为NumPy数组，可以使用OpenCV和NumPy库来完成。以下是一个示例代码，展示了如何执行这些步骤：





C++ 代码（使用OpenCV保存图像）：

```python
#include <opencv2/opencv.hpp>
int main()
{
    cv::Mat outimg;  // 假设你已经创建了名为 outimg 的 cv::Mat 对象
    // 保存为文件
    cv::FileStorage fs("outimg.yml", cv::FileStorage::WRITE);
    fs << "outimg" << outimg;
    fs.release();
    return 0;
}
```

Python 代码（使用NumPy加载数据）：

```python
import numpy as np
import cv2
# 加载数据
fs = cv2.FileStorage("outimg.yml", cv2.FILE_STORAGE_READ)
outimg = fs.getNode("outimg").mat()
fs.release()
# 将数据转换为 NumPy 数组
outimg_np = np.array(outimg)
# 打印数组
print(outimg_np)
```

这段代码将保存名为 "outimg.yml" 的文件，然后使用 Python 读取该文件并将其转换为 NumPy 数组。你可以根据需要修改文件名和路径。确保在 C++ 程序中创建的 cv::Mat 对象命名为 outimg，以便与 Python 中的节点名称相匹配。

如何在C++中把cv::Mat outimg（元素全部是0到1之间的浮点数）存为一个文件，然后使用python打开成numpy数据

opencv中的模糊方法使用




```python
import cv2
import numpy as np
def Gaussian(image):
    # 进行高斯模糊
    ksize = (11, 11)  # 模糊核的大小
    sigmaX = 5  # X方向的标准差，设为0表示从ksize计算
    image = cv2.GaussianBlur(image, ksize, sigmaX)
    image = cv2.GaussianBlur(image, ksize, sigmaX)
    return image
def blur(image):
    # 进行均值模糊
    ksize = (11, 11)  # 模糊核的大小
    image = cv2.blur(image, ksize)
    image = cv2.blur(image, ksize)
    return image
def medianBlur(image):
    # 进行中值模糊
    ksize = 11  # 模糊核的大小
    image = cv2.medianBlur(image, ksize)
    image = cv2.medianBlur(image, ksize)
    return image
def bilateralFilter(image):
    # 进行双边滤波
    d = 15  # 领域直径
    sigmaColor = 75  # 色彩空间的标准差
    sigmaSpace = 75  # 坐标空间的标准差
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    return image
def medianBlur(image):
    # 进行双边滤波
    d = 15  # 领域直径
    sigmaColor = 75  # 色彩空间的标准差
    sigmaSpace = 75  # 坐标空间的标准差
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    return image
def filter2D(image):
    # 自定义模糊核
    kernel = np.ones((5, 5), dtype=np.float32) / 25  # 5x5的均匀权重的模糊核
    # 进行自定义模糊
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    return image
# 读取图像
image = cv2.imread('image.jpg')
image = filter2D(image)
# 显示模糊后的图像
cv2.imshow('Gaussian Blur', image)
cv2.waitKey(0)
cv2.destroyAllWindows()
```

【OpenCV】opencv中的模糊方法使用

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。