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






```python
import tkinter as tk
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from pylab import mpl
mpl.rcParams['font.sans-serif'] = ['FangSong']  # 指定默认字体
mpl.rcParams['axes.unicode_minus'] = False  # 解决保存图像是负号'-'显示为方块的问题
# 函数用于执行最小二乘法线性拟合
def linear_regression():
    x_values = [float(x) for x in x_entry.get().split()]
    y_values = [float(y) for y in y_entry.get().split()]
    A = np.vstack([x_values, np.ones(len(x_values))]).T
    m, c = np.linalg.lstsq(A, y_values, rcond=None)[0]
    # 清空画布
    ax[0].clear()
    ax[1].clear()
    # 绘制数据点
    ax[0].scatter(x_values, y_values, label='数据点')
    # 绘制最小二乘法拟合线
    ax[0].plot(x_values, m * np.array(x_values) + c, 'r', label='自己计算的')
    ax[0].set_title(f'自己计算的: Y = {m:.5f} * X + {c:.5f}')
    # 从斜率和截距输入框获取备选直线的参数
    lines_m = [float(m) for m in m_entry.get().split()]
    lines_c = [float(c) for c in c_entry.get().split()]
    # 绘制备选直线
    for i in range(len(lines_m)):
        ax[0].plot(x_values, lines_m[i] * np.array(x_values) + lines_c[i], label=f'直线 {i + 1}')
    # 计算备选直线中最好的拟合直线，得到是哪一条直线最好
    best_line_index = np.argmin([np.sum(np.square(y_values - (m * np.array(x_values) + c))) for m, c in
                                 zip(lines_m, lines_c)])
    ax[0].set_xlabel('X')
    ax[0].set_ylabel('Y')
    ax[0].legend()
    # 在ax[1]绘制最好的直线
    ax[1].scatter(x_values, y_values, label='数据点')
    ax[1].plot(x_values, lines_m[best_line_index] * np.array(x_values) + lines_c[best_line_index], 'r',
               label=f'直线 {best_line_index + 1}')
    ax[1].set_title(
        f'最佳备选线: Y = {lines_m[best_line_index]} * X + {lines_c[best_line_index]},Index: {best_line_index + 1}')
    ax[1].set_xlabel('X')
    ax[1].set_ylabel('Y')
    ax[1].legend()
    canvas.draw()
# 创建Tkinter窗口
root = tk.Tk()
root.title('最小二乘法线性拟合')
frame = tk.Frame(root)
frame.pack(padx=10, pady=10)
# 创建输入框和标签
x_label = tk.Label(frame, text='输入x值（用空格分隔）:')
x_label.pack()
x_entry = tk.Entry(frame)
x_entry.insert(0, '2 4 6 8 10')  # 设置默认值
x_entry.pack()
y_label = tk.Label(frame, text='输入y值（用空格分隔）:')
y_label.pack()
y_entry = tk.Entry(frame)
y_entry.insert(0, '10.046 20.090 30.155 40.125 50.074')  # 设置默认值
y_entry.pack()
m_label = tk.Label(frame, text='输入备选直线的斜率（用空格分隔）:')
m_label.pack()
m_entry = tk.Entry(frame)
m_entry.insert(0, '5.0 5.01 4.97 4.95 5.08')  # 设置默认值
m_entry.pack()
c_label = tk.Label(frame, text='输入备选直线的截距（用空格分隔）:')
c_label.pack()
c_entry = tk.Entry(frame)
c_entry.insert(0, '0.08 0.07 0.12 0.15 0.06')  # 设置默认值
c_entry.pack()
# 创建确认按钮
calculate_button = tk.Button(frame, text='确认', command=linear_regression)
calculate_button.pack()
# 创建大画布
fig, ax = plt.subplots(1, 2, figsize=(10, 5))
canvas = FigureCanvasTkAgg(fig, master=frame)
canvas.get_tk_widget().pack()
canvas.draw()
# 运行Tkinter主循环
root.mainloop()
```

最小二乘法，可视化UI界面

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






python

```python
from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.staticfiles import StaticFiles
from fastapi.responses import HTMLResponse
from typing import List
import requests
app = FastAPI()
# 配置静态文件目录
app.mount("/static", StaticFiles(directory="static"), name="static")
# HTML页面路由
@app.get("/", response_class=HTMLResponse)
async def get_upload_page():
    return """
    <!DOCTYPE html>
    <html>
    <head>
        <title>Image Upload</title>
    </head>
    <body>
        <h1>Image Upload</h1>
        <form method="post" enctype="multipart/form-data">
            <input type="file" name="file">
            <button type="submit">Upload</button>
        </form>
        <div id="descriptions"></div>
        <script src="/static/main.js"></script>
    </body>
    </html>
    """
# 文件上传端点
@app.post("/upload")
async def file_(file: bytes = File(...)):  # 如果要上传多个文件 files: List[bytes] = File(...)
    """使用File类 文件内容会以bytes的形式读入内存 适合于上传小文件"""
    return {"file_size": len(file)}  # 返回文件大小
if __name__ == "__main__":
    import uvicorn
    uvicorn.run('main:app', host='0.0.0.0', port=8000, reload=True, workers=1)
```


js

```js
document.addEventListener('DOMContentLoaded', () => {
  const form = document.querySelector('form');
  const fileInput = document.querySelector('input[type="file"]');
  const descriptions = document.getElementById('descriptions');
  form.addEventListener('submit', async (e) => {
    e.preventDefault();
    const formData = new FormData();
    formData.append('file', fileInput.files[0]);
    try {
      const response = await fetch('/upload', {
        method: 'POST',
        body: formData,
      });
      if (response.ok) {
        const data = await response.json();
        descriptions.innerHTML = `File size: ${data.file_size} bytes`;
      } else {
        descriptions.innerHTML = 'Upload failed';
      }
    } catch (error) {
      console.error('Error:', error);
      descriptions.innerHTML = 'An error occurred';
    }
  });
});
```


结果网页：

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

【Python Fastapi】js上传文件，fastapi处理，js显示回传信息

我是windows系统，pip install cython_bbox无法编译。





解决：

安装`pip install cpython`

安装VS2019企业版，为了windows能编译一些乱七八糟的，我一般都装个这个。

```shell
key
BF8Y8-GN2QH-T84XB-QVY3B-RC4DF
```

下载源码：`https://github.com/samson-wang/cython_bbox/tree/master`

执行安装：

```
cd C:\Users\xjsd\Downloads\cython_bbox-master\cython_bbox-master
pip install .
```

日志：

```
(py38) C:\Users\xjsd\Downloads\lap-master\lap-master>cd C:\Users\xjsd\Downloads\cython_bbox-master\cython_bbox-master
(py38) C:\Users\xjsd\Downloads\cython_bbox-master\cython_bbox-master>pip install .
Looking in indexes: https://pypi.tuna.tsinghua.edu.cn/simple
Processing c:\users\xjsd\downloads\cython_bbox-master\cython_bbox-master
  Preparing metadata (setup.py) ... done
Requirement already satisfied: Cython in c:\users\xjsd\.conda\envs\py38\lib\site-packages (from cython-bbox==0.1.3) (3.0.2)
Requirement already satisfied: numpy in c:\users\xjsd\.conda\envs\py38\lib\site-packages (from cython-bbox==0.1.3) (1.24.4)
Building wheels for collected packages: cython-bbox
  Building wheel for cython-bbox (setup.py) ... done
  Created wheel for cython-bbox: filename=cython_bbox-0.1.3-cp38-cp38-win_amd64.whl size=29288 sha256=ecd828eb5c0cdba3e3b4931d9acb1719cd0869ba675321ae59eba43b85f1368c
  Stored in directory: c:\users\xjsd\appdata\local\pip\cache\wheels\a2\15\10\68bac8f727391b0efe795d418657f56c18299c9404c06ad0ae
Successfully built cython-bbox
Installing collected packages: cython-bbox
Successfully installed cython-bbox-0.1.3
```


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

numpy装1.23版本，重启pycharm。

Python，如何安装cython_bbox

Linux可以：





```shell
pip install cpython
pip install git+git://github.com/gatagat/lap.git
```

windows可以：

下载`https://github.com/gatagat/lap` 后解压，

安装`pip install cpython`

安装VS2019企业版：

```shell
key
BF8Y8-GN2QH-T84XB-QVY3B-RC4DF
```

执行安装：

```
(py38) C:\Users\xjsd>cd C:\Users\xjsd\Downloads\lap-master\lap-master
(py38) C:\Users\xjsd\Downloads\lap-master\lap-master>python setup.py install
```

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

也可以：

```
pip install . # 安装当前路径的包
```

完成后：

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

又发现新版不好用，下个`https://github.com/gatagat/lap/tree/v0.4.0` 老版本的。

Python，如何安装lap，pip安装lap出现问题

CUDA可用，共有 1 个GPU设备可用。





当前使用的GPU设备索引：0

当前使用的GPU设备名称：NVIDIA T1000

GPU显存总量：4.00 GB

已使用的GPU显存：0.00 GB

剩余GPU显存：4.00 GB

PyTorch版本：1.10.1+cu102

```python
import torch
# 检查CUDA是否可用
cuda_available = torch.cuda.is_available()
if cuda_available:
    # 获取GPU设备数量
    num_gpu = torch.cuda.device_count()
    # 获取当前使用的GPU索引
    current_gpu_index = torch.cuda.current_device()
    # 获取当前GPU的名称
    current_gpu_name = torch.cuda.get_device_name(current_gpu_index)
    # 获取GPU显存的总量和已使用量
    total_memory = torch.cuda.get_device_properties(current_gpu_index).total_memory / (1024 ** 3)  # 显存总量(GB)
    used_memory = torch.cuda.memory_allocated(current_gpu_index) / (1024 ** 3)  # 已使用显存(GB)
    free_memory = total_memory - used_memory  # 剩余显存(GB)
    print(f"CUDA可用，共有 {num_gpu} 个GPU设备可用。")
    print(f"当前使用的GPU设备索引：{current_gpu_index}")
    print(f"当前使用的GPU设备名称：{current_gpu_name}")
    print(f"GPU显存总量：{total_memory:.2f} GB")
    print(f"已使用的GPU显存：{used_memory:.2f} GB")
    print(f"剩余GPU显存：{free_memory:.2f} GB")
else:
    print("CUDA不可用。")
# 检查PyTorch版本
print(f"PyTorch版本：{torch.__version__}")
import torch
print(f"CUDA版本：{torch.version.cuda}")
```


windows先装显卡驱动，再装CUDA10.2，最后装了pytorch。

pip install torch==1.10.1+cu102 torchvision==0.13.1+cu102 torchaudio==0.12.1 --extra-index-url https://download.pytorch.org/whl/cu102


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



```python
import torch
import os
import subprocess

def check_gpu_availability():
    print("==== Checking GPU Availability ====")
    if torch.cuda.is_available():
        print(f"GPU is available. Number of GPUs: {torch.cuda.device_count()}")
        for i in range(torch.cuda.device_count()):
            print(f"GPU {i}: {torch.cuda.get_device_name(i)}")
    else:
        print("No GPU available. Please check your hardware or drivers.")
        return False
    return True

def check_cuda_and_cudnn():
    print("\n==== Checking CUDA and cuDNN Availability ====")
    if torch.cuda.is_available():
        print(f"CUDA version: {torch.version.cuda}")
        print(f"cuDNN version: {torch.backends.cudnn.version()}")
        print(f"cuDNN enabled: {torch.backends.cudnn.enabled}")
    else:
        print("CUDA or cuDNN not available. Please check the installation.")

def test_gpu_computation():
    print("\n==== Testing Simple Computation on GPU ====")
    try:
        
        device = torch.device("cuda:2")
        a = torch.randn(50, 50, device=device)
        b = torch.randn(50, 50, device=device)
        c = torch.matmul(a, b)
        print("Matrix multiplication on GPU successful.")
    except Exception as e:
        print(f"Error during computation on GPU: {e}")

def check_gpu_memory():
    print("\n==== Checking GPU Memory Usage ====")
    try:
        gpu_memory = torch.cuda.memory_summary()
        print(gpu_memory)
    except Exception as e:
        print(f"Error retrieving GPU memory info: {e}")

def run_nvidia_smi():
    print("\n==== Running nvidia-smi Command ====")
    try:
        # Run the nvidia-smi command and capture the output
        result = subprocess.run(["nvidia-smi"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
        if result.returncode == 0:
            print(result.stdout)
        else:
            print(f"Error running nvidia-smi: {result.stderr}")
    except Exception as e:
        print(f"Error running nvidia-smi command: {e}")

def main():
    print("==== Starting GPU Health Check ====")
    
    # Step 1: Check GPU availability
    if not check_gpu_availability():
        return
    
    # Step 2: Check CUDA and cuDNN versions
    check_cuda_and_cudnn()
    
    # Step 3: Test GPU computation
    test_gpu_computation()
    
    # Step 4: Check GPU memory usage
    check_gpu_memory()
    
    # Step 5: Run nvidia-smi to check GPU status
    run_nvidia_smi()
    
    print("\n==== GPU Health Check Completed ====")

if __name__ == "__main__":
    main()

```

【Python】pytorch，CUDA是否可用，查看显卡显存剩余容量

# conda





```c
conda config --set ssl_verify no
conda config --set proxy_servers.http <VPN 服务器地址>:<VPN 服务器端口>
conda config --set proxy_servers.https <VPN 服务器地址>:<VPN 服务器端口>
```


```c
conda install <package_name>
```


# pip

```c
pip --proxy <VPN 服务器地址>:<VPN 服务器端口> install requests
```

example.


```c
 pip install --proxy http://127.0.0.1:10809 -r req.txt
```

给conda、pip提提速，给他一个vpn，还世界清静

# 环境





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

在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中的模糊方法使用

确认你的socks端口：





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

然后程序可以这么写：

```python
import requests
import socks
import socket
# 创建 SOCKS5 代理连接
socks.set_default_proxy(socks.SOCKS5, "127.0.0.1", 10808)
socket.socket = socks.socksocket
# 发送请求
response = requests.get("https://www.flickr.com/search/?text=%E5%8F%AF%E7%88%B1%E7%9A%84", proxies={"https": "socks5://127.0.0.1:10808"})
print(response.text)
```

【Python】Python程序中使用request库连接外国网站的方法

pyheif github： [https://github.com/carsales/pyheif](https://github.com/carsales/pyheif)





Ubuntu Linux Python 3.7 安装 pyheif：

```sh
 pip install pyheif pillow
```

转单张图片：

```python
from PIL import Image
import pyheif
heif_file = pyheif.read("1.HEIC")
image = Image.frombytes(
    heif_file.mode,
    heif_file.size,
    heif_file.data,
    "raw",
    heif_file.mode,
    heif_file.stride,
)
# 保存为同名jpg
image.save("1.jpg")
```

将某个目录下的所有HEIC文件转为jpg，并删除原jpg：

```python
import os
from PIL import Image
import pyheif
src = r"/mnt/d/download/0207后提交（v1.0.2模型反馈）"
def find_all_files(directory):
    for root, dirs, files in os.walk(directory):
        for file in files:
            yield os.path.join(root, file)
files = find_all_files(src)
for file in files:
    if file.endswith(".HEIC"):
        print(file)
        # 读取heic文件
        heif_file = pyheif.read(file)
        image = Image.frombytes(
            heif_file.mode,
            heif_file.size,
            heif_file.data,
            "raw",
            heif_file.mode,
            heif_file.stride,
        )
        # 保存为同名jpg
        image.save(file.replace("HEIC", "jpg"))
        # 删除
        os.remove(file)
```

上述代码实现了一个将指定目录下所有.HEIC格式的图片文件转换成同名.jpg格式并删除原文件的功能。

首先导入了必要的库：os（用于文件和目录操作）、Pillow中的Image（用于图像处理）、以及pyheif（用于读取HEIC格式的图片文件）。

然后定义了一个函数 find_all_files，该函数使用 os.walk 遍历指定目录下的所有文件和子目录，并通过 yield 逐一返回文件路径。

接下来，通过调用 find_all_files 函数，获取指定目录下的所有文件路径，然后循环处理每个文件。如果文件路径以 .HEIC 结尾，说明该文件是HEIC格式的图片文件，于是就调用 pyheif.read 读取该文件，并使用 Image.frombytes 将读取的HEIC数据转换为Pillow中的Image对象。随后，将Image对象保存为同名.jpg文件，并使用 os.remove 删除原文件。

注意：此代码需要在支持读取HEIC格式的Python环境下运行，否则会出现无法识别.HEIC文件的错误。

Python HEIC图片转jpg

参考：[https://labuladong.github.io/algo/di-yi-zhan-da78c/shou-ba-sh-48c1d/wo-xie-le--9c7a4/](https://labuladong.github.io/algo/di-yi-zhan-da78c/shou-ba-sh-48c1d/wo-xie-le--9c7a4/)






#  1 基本介绍

二分查找法（Binary Search）是一种在**有序数组**中查找某一特定元素的搜索算法。其基本思想是，首先将整个有序数列分成前后两部分，判断在哪个部分中可能会找到要查找的数，然后递归地在那个部分中查找。

具体来说，首先选择数列的中间元素。如果要查找的数比中间元素小，则在数列的左半部分继续查找；如果要查找的数比中间元素大，则在数列的右半部分继续查找；如果相等，则找到了要查找的数。这样一直递归进行，直到找到要查找的数或者整个数列被查找完。

二分查找法的时间复杂度为 O(log n)，其中 n 是数列中的元素个数。由于其在有序数列中查找元素的时间复杂度较低，因此常用于大规模有序数列的查找。

> 二分查找并不简单，Knuth 大佬（发明 KMP 算法的那位）都说二分查找：思路很简单，细节是魔鬼。

- 有哪些细节：

> while循环中使用 low <= high 还是 low < high ？ 

> if条件里写<还是<=? 是low = mid +1？

> 还是low = mid ？



# 2 基本的二分查找

基本的二分查找中有序数组里的元素没有重复数值，而二分查找的目的就是找到符合条件的下标。

比如想在有序数组 arr = [1, 2, 3, 4, 5, 6, 7, 8, 9] 中找到元素5的index，该如何写python代码呢：

```python
def binary_search(arr, x):
    low = 0
    high = len(arr) - 1
    while low <= high:  # 结束条件是 low > high， 为什么不用<符号呢：因为当low=high时，还需要判断一次，不然[low,high]就会被漏掉
        mid = (low + high) // 2  # 和mid=low+(high-low)//2是一样的结果，low+(high-low)//2可以防止大数溢出
        if arr[mid] < x:
            low = mid + 1  # 在区间 [mid+1, high] 中查找
        elif arr[mid] > x:
            high = mid - 1  # 在区间 [low, mid-1] 中查找
        elif arr[mid] == x:
            return mid
    return -1
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
x = 5
result = binary_search(arr, x)
if result != -1:
    print(f"Element is present at index {result}")
else:
    print("Element is not present in array")
```

# 3 左边界 vs 右边界，查找相等的元素

当有序数组中存在重复值，即是由多个元素可以满足条件，返回哪一个下标更合适呢？

比如 arr = [1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9]， 找数值5，那么左边界index是4，右边界index是6。 

如果有序数组中有重复值，并且你想找到左边界的下标，你可以在二分查找的基础上，做一些改变来实现这个功能。

下面的代码展示了左边界和右边界的代码：

```python
def binary_search_leftright(arr, x):
    low = 0
    high = len(arr) - 1
    result = -1
    while low <= high:  # 结束条件是 low > high， 为什么不用<符号呢：因为当low=high时，还需要判断一次，不然[low,high]就会被漏掉
        mid = (low + high) // 2  # 和mid=low+(high-low)//2是一样的结果，low+(high-low)//2可以防止大数溢出
        if arr[mid] < x:
            low = mid + 1  # 在区间 [mid+1, high] 中查找
        elif arr[mid] > x:
            high = mid - 1  # 在区间 [low, mid-1] 中查找
        elif arr[mid] == x:
            result = mid  # 记录符合条件的下标
            # high = mid - 1  # 在区间 [low, mid-1] 中查找，这就很灵性，意味着找到了，但是还要继续找，而且趋势是往左找. 即找左边界。
            low = mid + 1  # 在区间 [mid+1, high] 中查找，这就很灵性，意味着找到了，但是还要继续找，而且趋势是往右找. 即找右边界。
    return result
arr = [1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9]
x = 5
result = binary_search_left(arr, x)
if result != -1:
    print(f"Element is present at index {result}")
else:
    print("Element is not present in array")
```

# 4 难度升级，找到 x<6 的右边界

在 arr = [4, 4, 5, 5, 6, 6, 7, 8, 9] 中找到一个元素x，满足x<6，且x是右边界元素：
```python
def binary_search_right(arr, x):
    low = 0
    high = len(arr) - 1
    while low < high:
        mid = (low + high) // 2
        if arr[mid] < x:
            low = mid + 1  # 继续在[mid+1, high]中查找，因为想找右边界
        else:
            high = mid  # 为什么不是mid-1呢?
    if arr[high] >= x:
        return high - 1
    else:
        return high
arr = [4, 4, 5, 5, 6, 6, 7, 8, 9]
x = 6
result = binary_search_right(arr, x)
print(result)
```

函数返回 high - 1 或者返回high。


- 如果将条件改为while low <= high呢，这样不可以吗？

> 如果你将循环的条件改为 while low <= high，在数组中查找小于目标值的右边界的时候是会有问题的。

> 

> 当low==high时，如果arr[high] >= x 那么最终返回值就是high -1,而实际上并不是小于目标值的右边界。

> 

> 因此，在二分查找中查找右边界时，循环条件应该是 low < high.

> 

> 这样当循环结束时，high指向的就是第一个大于等于目标值的位置，而high - 1就是小于目标值的右边界

> 

> 所以，在二分查找中查找右边界时，循环条件应该是 low < high 而非 low <= high,这是为了确保查找的正确性

> 

> 除此之外，还可能发生死循环。


- 那为什么是high = mid ，而不是high = mid -1？

> 在查找小于目标值的右边界时，如果循环条件是 low < high, 当 arr[mid] >= x 时,如果 high = mid -1 会使得 high 不满足循环条件,从而导致循环终止，而不是移动到小于目标值的右边界。

> 

> 而赋值high = mid会使得high = mid或者 high =

> mid-1,这样high总是满足循环条件且正确地找到了第一个大于等于目标值的位置,而high-1就是小于目标值的右边界。

> 

> 所以如果你想在查找小于目标值的右边界时，应该让 high = mid。这样可以保证查找的正确性。


# 5 找到 x>5 的左边界

在 arr = [4, 4, 5, 5, 6, 6, 7, 8, 9] 中找到一个元素x，满足x>5，且x是左边界元素：

```python
def binary_search_left(arr, x):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] <= x:
            low = mid + 1
        else:
            high = mid - 1
    return low
arr = [4, 4, 5, 5, 6, 6, 7, 8, 9]
x = 5
result = binary_search_left(arr, x)
print(result)
```

或者：

```python
def binary_search_left(arr, x):
    low = 0
    high = len(arr)
    while low < high:
        mid = (low + high) // 2
        if arr[mid] <= x:
            low = mid + 1
        else:
            high = mid 
    return low
```


# 6 总结模板

当使用 "while low <= high" 时，要想结束循环，就需要更严格的判断，从而就不需要再单独对low 和high 进行特判。

如果要查找左边界（x>5的左边界）：

```python
def binary_search_left(arr, x):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] <= x: # 如果是x>=5，这里就需要改变查找区间
            low = mid + 1
        else:
            high = mid - 1
    return low
```

如果要查找右边界（x<6的右边界）：

```python
def binary_search_right(arr, x):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] < x: # 如果是x<=6，这里就需要改变查找区间
            low = mid + 1
        else:
            high = mid - 1
    return high
```

【算法题目】一文搞懂二分查找法

# 代码





PyMuPDF的版本不同，似乎方法也不同，所以建议指定一个版本。

安装：

```sh
pip install PyMuPDF==1.21.1
```

代码：

```python
import os
import fitz
# 提取每一页的图片对象单独保存
def muExtractImages(pdf_name, pic_save_path):
    doc = fitz.open(pdf_name)
    for itm,page in enumerate(doc):
        try:
            tupleImage = page.get_images()
            for xref0 in tupleImage:  # 取第一个元组
                xref = xref0[0]  # 最终取得xref  ok
                img = doc.extract_image(xref)  # 获取文件扩展名，图片内容 等信息
                imageFilename = os.path.join(pic_save_path, str(itm) + '_' + str(xref) + '.' + img['ext'])
                imgout = open(imageFilename, 'wb')  # byte方式新建图片
                imgout.write(img["image"])  # 当前提取的图片写入磁盘
                imgout.close()
        except:
            continue
    doc.close()
# 将每一页作为图片，保存到某个目录
def pdf_image(pdf_name, pic_save_path):
    img_paths = []
    doc = fitz.open(pdf_name)
    for i, pg in enumerate(doc.pages()):
        page = pg  # 获得每一页的对象
        trans = fitz.Matrix(3.0, 3.0)
        pm = page.get_pixmap(matrix=trans, alpha=False)  # 获得每一页的流对象
        img_path = str(i + 1) + '.jpg'
        img_path = os.path.join(pic_save_path, img_path)
        pm.save(img_path)
        img_paths.append(img_path)
    doc.close()
    return img_paths
if __name__ == '__main__':
    file_path = r'F:\BaiduNetdiskDownload\语文-状元笔记\语文-状元笔记\1.pdf'  # pdf_name 文件路径
    dir_path = r'F:\BaiduNetdiskDownload\语文-状元笔记\语文-状元笔记\1'  # 存放图片的文件夹
    muExtractImages(file_path, dir_path)
```

# PyMuPDF介绍

PyMuPDF是一个用于操作PDF文件的Python库。它是基于MuPDF库的Python绑定，提供了一组高级功能，可以用于读取，修改和写入PDF文件。

主要特性：

支持多种PDF版本，包括PDF 1.7（Acrobat 8.0）

支持读取加密和签名的PDF文件

支持修改PDF文件的内容，包括文本，图像，链接和表单

支持创建新的PDF文件或合并现有的PDF文件

支持渲染PDF页面为图像，包括多种格式（如PNG，JPEG，TIFF）

支持对PDF文件进行搜索和提取文本

Python PyMuPDF 提取PDF文件中的图片到指定目录保存，PDF将每一页都保存为图片

参考：[https://blog.csdn.net/faithmy509/article/details/80235631](https://blog.csdn.net/faithmy509/article/details/80235631)





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

Python：

```python
import math
# 逆时针旋转angle
def rotate(angle, pointP, pointQ):
    x2, y2 = pointQ  # 旋转中心点
    x1, y1 = pointP  # 旋转前的点
    x = x2 + (x1 - x2) * math.cos(angle) - (y1 - y2) * math.sin(angle)
    y = y2 + (x1 - x2) * math.sin(angle) + (y1 - y2) * math.cos(angle)
    return [x, y]
```

【Python】opencv图形旋转，坐标点旋转，坐标绕原点旋转

额外介绍一点别的，如何docker 快速启动一个PaddleOCR的能力见这里：[https://qq742971636.blog.csdn.net/article/details/135109278](https://qq742971636.blog.csdn.net/article/details/135109278)






python包：`pip install baidu-aip`

详细教程：[https://www.jianshu.com/p/e10dc43c38d0](https://www.jianshu.com/p/e10dc43c38d0)

我的代码：
```python
import json
import os
import shutil
import cv2
from aip import AipOcr
from tqdm import tqdm
# """ 你的 APPID AK SK  图2的内容"""
APP_ID = '27145052'
API_KEY = '26T8PoG7inAFTF3MF99E0Pbg  '
SECRET_KEY = 'CCbIfR0f9wLMgPXs3c0G6MTYwawpwZXi '
client = AipOcr(APP_ID, API_KEY, SECRET_KEY)
def get_file_content(filePath):
    with open(filePath, 'rb') as fp:
        return fp.read()
rootpath = r"C:\Users\dong.xie\Desktop\xsz111\学生证\u=693650192"
print(rootpath)
res = {}
files = os.listdir(rootpath)
for file in tqdm(files):
    try:
        fname = os.path.join(rootpath, file)
        image = get_file_content(fname)
        """ 调用通用文字识别, 图片参数为本地图片 """
        results = client.general(image)
        res[fname] = results
    except:
        print("error", fname)
```


最好的方式还是ocr+docker：

[https://github.com/PaddlePaddle/PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR)

【Python】快捷调用百度ocr能力

原因是png图片里面的profile ，好像又听说高版本的png在做什么。






解决方式很简单，重写一下这个图。


下面程序会读取 r"/ssd/xd/datasets/multilabelsTask/"下面的所有jpg和png图，多进程方式地重写一下图片，注意，如果opencv打不开这个图，这个图会被删除：
```python
import multiprocessing
import os
import cv2
import numpy as np
def listPathAllfiles(dirname):
    result = []
    for maindir, subdir, file_name_list in os.walk(dirname):
        for filename in file_name_list:
            apath = os.path.join(maindir, filename)
            result.append(apath)
    return result
def overwrite(files1):
    for fname in files1:
        try:
            if fname.endswith(".jpg"):
                img = cv2.imdecode(np.fromfile(fname, dtype=np.uint8), 1)  # img是矩阵
                cv2.imencode('.jpg', img)[1].tofile(fname)
            elif fname.endswith(".png"):
                img = cv2.imdecode(np.fromfile(fname, dtype=np.uint8), 1)  # img是矩阵
                cv2.imencode('.png', img)[1].tofile(fname)
        except:
            os.remove(fname)
            print(fname)
if __name__ == '__main__':
    root = r"/ssd/xd/datasets/multilabelsTask/"
    files = listPathAllfiles(root)
    p = multiprocessing.Pool()  # 创建一个包含2个进程的进程池
    # split files to several parts
    for i in range(0, len(files), 10000):
        p.apply_async(func=overwrite, args=(files[i:i + 1000],))  # 往池子里加一个异步执行的子进城
    p.close()  # 等子进程执行完毕后关闭进程池
    p.join()  # 主进程等待
```