# 环境





```shell
pip install jupyter 
```

# 使用

在你想访问的目录下执行：


```c
jupyter notebook --ip=0.0.0.0
```

jupyter 给出提示：

```c
[I 2023-07-28 14:32:43.589 ServerApp] Package notebook took 0.0000s to import
[I 2023-07-28 14:32:43.597 ServerApp] Package jupyter_lsp took 0.0081s to import
[W 2023-07-28 14:32:43.597 ServerApp] A `_jupyter_server_extension_points` function was not found in jupyter_lsp. Instead, a `_jupyter_server_extension_paths` function was found and will be used for now. This function name will be deprecated in future releases of Jupyter Server.
[I 2023-07-28 14:32:43.601 ServerApp] Package jupyter_server_terminals took 0.0034s to import
[I 2023-07-28 14:32:43.601 ServerApp] Package jupyterlab took 0.0000s to import
[I 2023-07-28 14:32:43.639 ServerApp] Package notebook_shim took 0.0000s to import
[W 2023-07-28 14:32:43.640 ServerApp] A `_jupyter_server_extension_points` function was not found in notebook_shim. Instead, a `_jupyter_server_extension_paths` function was found and will be used for now. This function name will be deprecated in future releases of Jupyter Server.
[I 2023-07-28 14:32:43.640 ServerApp] jupyter_lsp | extension was successfully linked.
[I 2023-07-28 14:32:43.643 ServerApp] jupyter_server_terminals | extension was successfully linked.
[I 2023-07-28 14:32:43.647 ServerApp] jupyterlab | extension was successfully linked.
[I 2023-07-28 14:32:43.651 ServerApp] notebook | extension was successfully linked.
[I 2023-07-28 14:32:43.654 ServerApp] Writing Jupyter server cookie secret to /home/xd/.local/share/jupyter/runtime/jupyter_cookie_secret
[I 2023-07-28 14:32:43.827 ServerApp] notebook_shim | extension was successfully linked.
[I 2023-07-28 14:32:43.930 ServerApp] notebook_shim | extension was successfully loaded.
[I 2023-07-28 14:32:43.932 ServerApp] jupyter_lsp | extension was successfully loaded.
[I 2023-07-28 14:32:43.933 ServerApp] jupyter_server_terminals | extension was successfully loaded.
[I 2023-07-28 14:32:43.934 LabApp] JupyterLab extension loaded from /ssd/xd/miniconda3/envs/py38_diffusers_1/lib/python3.8/site-packages/jupyterlab
[I 2023-07-28 14:32:43.934 LabApp] JupyterLab application directory is /ssd/xd/miniconda3/envs/py38_diffusers_1/share/jupyter/lab
[I 2023-07-28 14:32:43.935 LabApp] Extension Manager is 'pypi'.
[I 2023-07-28 14:32:43.937 ServerApp] jupyterlab | extension was successfully loaded.
[I 2023-07-28 14:32:43.939 ServerApp] notebook | extension was successfully loaded.
[I 2023-07-28 14:32:43.939 ServerApp] Serving notebooks from local directory: /ssd/xd/workplace
[I 2023-07-28 14:32:43.939 ServerApp] Jupyter Server 2.7.0 is running at:
[I 2023-07-28 14:32:43.939 ServerApp] http://gpu20:8888/tree?token=490e738359e9e3a73247822c61620bacdfcae0038a9a721e
[I 2023-07-28 14:32:43.939 ServerApp]     http://127.0.0.1:8888/tree?token=490e738359e9e3a73247822c61620bacdfcae0038a9a721e
[I 2023-07-28 14:32:43.939 ServerApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[W 2023-07-28 14:32:43.948 ServerApp] No web browser found: Error('could not locate runnable browser').
```


记住这提示里的token：

490e738359e9e3a73247822c61620bacdfcae0038a9a721e

# 访问

windows电脑浏览器访问：

http://101.20.31.20:8888


默认端口8888，前面的ip需要填写你Linux服务器的IP。

【Python】jupyter Linux服务器使用

基础环境：





```c
sudo apt-get install ffmpeg
```


# m4a


要将M4A文件转换为MP3文件，你可以使用Python中的第三方库`pydub`。`pydub`使得音频处理变得非常简单。在开始之前，请确保你已经安装了`pydub`库，如果没有，可以通过以下命令安装：

```bash
pip install pydub
```

接下来，你可以使用以下代码将M4A文件转换为MP3文件：

```python
from pydub import AudioSegment
def m4a_to_mp3(m4a_file, mp3_file):
    # Load the M4A file
    audio = AudioSegment.from_file(m4a_file, format="m4a")
    # Export the audio as MP3
    audio.export(mp3_file, format="mp3")
if __name__ == "__main__":
    input_m4a_file = "input_file.m4a"   # Replace with the path to your M4A file
    output_mp3_file = "output_file.mp3" # Replace with the desired output MP3 file path
    m4a_to_mp3(input_m4a_file, output_mp3_file)
```

将上述代码中的`input_m4a_file`替换为你要转换的M4A文件路径，`output_mp3_file`替换为你希望输出的MP3文件路径。然后运行代码，它将加载M4A文件并将其转换为MP3格式。请注意，转换过程可能需要一些时间，具体取决于文件大小和你的计算机性能。

提醒：在进行音频格式的转换时，请遵守相关版权法规和使用规定，确保你有权处理和使用这些文件。




# aac

要将AAC文件转换为MP3文件，你可以使用Python中的`pydub`库，它提供了一个简单的方法来进行音频格式转换。在开始之前，请确保已经安装了`pydub`库，如果没有，可以通过以下命令安装：

```bash
pip install pydub
```

接下来，你可以使用以下代码将AAC文件转换为MP3文件：

```python
from pydub import AudioSegment
def aac_to_mp3(aac_file, mp3_file):
    # Load the AAC file
    audio = AudioSegment.from_file(aac_file, format="aac")
    # Export the audio as MP3
    audio.export(mp3_file, format="mp3")
if __name__ == "__main__":
    input_aac_file = "input_file.aac"   # Replace with the path to your AAC file
    output_mp3_file = "output_file.mp3" # Replace with the desired output MP3 file path
    aac_to_mp3(input_aac_file, output_mp3_file)
```

将上述代码中的`input_aac_file`替换为你要转换的AAC文件路径，`output_mp3_file`替换为你希望输出的MP3文件路径。然后运行代码，它将加载AAC文件并将其转换为MP3格式。请注意，转换过程可能需要一些时间，具体取决于文件大小和你的计算机性能。

同样地，在进行音频格式的转换时，请确保你有权处理和使用这些文件，遵守相关版权法规和使用规定。

【Python】将M4A\AAC录音文件转换为MP3文件

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 串口调试助手，支持中英文编码

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