Python高级编程

常用API

1.文本文件的操作

  • 读取文本文件：使用read()

    # 使用 'read' 方法读取文件的所有内容
with open('example.txt', 'r') as file:  # 打开文件 example.txt，模式为只读 ('r')
  content = file.read()  # 读取文件的全部内容并存储到变量 content 中

print(content)  # 输出文件内容到控制台

  • 按行读取：使用readline()

    # 使用 'readline' 方法逐行读取文件
with open('example.txt', 'r') as file:  # 打开文件 example.txt，模式为只读 ('r')
    line = file.readline()  # 读取文件的第一行
    while line:  # 如果读取到的内容不为空（即未到达文件末尾）
        print(line, end='')  # 输出当前行内容，并避免自动换行
        line = file.readline()  # 继续读取下一行

  • 读取多行：使用readlines()

    # 使用 'readlines' 方法读取文件的所有行
with open('example.txt', 'r') as file:  # 打开文件 example.txt，模式为只读 ('r')
    lines = file.readlines()  # 将文件的每一行作为列表的一个元素返回 lines 是列表
    for line in lines:  # 遍历列表中的每一行
        print(line, end='')  # 输出当前行内容，并避免自动换行

  • 写入文本文件：使用write()

    # 使用 'write' 方法写入文件
with open('example.txt', 'w') as file:  # 打开文件 example.txt，模式为写入 ('w')
    file.write("Hello, world!")  # 向文件中写入字符串 "Hello, world!"

  • 写入多行文本文件：使用writelines()

    # 使用 'writelines' 方法写入文件
lines = ["Hello, world!", "Welcome to Python programming."]  # 定义要写入的行列表
with open('example.txt', 'w') as file:  # 打开文件 example.txt，模式为写入 ('w')
    file.writelines(line + '\n' for line in lines)  # 将每一行写入文件，并在每行末尾添加换行符

  • 日志文件读写[综合案例]

    • 写一段代码，模拟生成accuracy逐步上升、loss逐步下降的训练日志，并将日志信息记录到training_log.txt中
    import random

epoch = 100
accuracy = 0.5
loss = 0.9

# 打开文件并写入表头
with open('training_log.txt', 'w') as f:
    f.write('Epoch\tAccuracy\tLoss\n')

# 模拟训练过程
for epoch_i in range(1, epoch + 1):
    # 更新 accuracy 和 loss
    accuracy += random.uniform(0, 0.005)
    loss -= random.uniform(0, 0.005)
    
    # 确保 accuracy 不超过 1，loss 不低于 0
    accuracy = min(1, accuracy)
    loss = max(0, loss)
    
    # 将当前 epoch 的数据写入文件
    with open('training_log.txt', 'a') as f:  # 使用追加模式 ('a') 写入后续数据
        f.write(f'{epoch_i}\t{accuracy:.3f}\t{loss:.3f}\n')
    
    # 打印当前 epoch 的数据到控制台
    print(f'Epoch: {epoch_i}, Accuracy: {accuracy:.3f}, Loss: {loss:.3f}')

2.pandas表格处理

加载表格

  • 安装pandas

    pip install pandas

  • 读取csv表格

    import pandas as pd

# 定义数据文件路径
data_loc = r'./resources/yolov5s.csv'
# 读取 CSV 文件
data = pd.read_csv(data_loc)
# 打印数据内容
print(data)

  • 读取excel表格

    import pandas as pd

# 定义数据文件路径
data_loc = r'./resources/销售数据.xlsx'
# 读取 Excel 文件
data = pd.read_excel(data_loc)
# 打印数据内容
print(data)

  • 数据分组与排序

    import pandas as pd

# 定义数据文件路径
data_loc = r'./resources/销售数据.xlsx'  # 修正文件扩展名和字符串格式
# 读取 Excel 文件
data = pd.read_excel(data_loc)
# 打印数据的描述性统计信息
print(data.describe())

  • 输出头几行

    import pandas as pd

# 定义数据文件路径
data_loc = r'./resources/销售数据.xlsx'  
# 读取 Excel 文件
data = pd.read_excel(data_loc)
# 显示数据的前几行
print(data.head())

  • 输出尾几行

    import pandas as pd

# 定义数据文件路径
data_loc = r'./resources/销售数据.xlsx'  # 修正文件扩展名和字符串格式
# 读取 Excel 文件
data = pd.read_excel(data_loc)
# 显示数据的最后几行
print(data.tail())  # 默认显示尾部 5 行

  • 定位第一行

    import pandas as pd

# 定义数据文件路径
data_loc = r'./resources/销售数据.xlsx'  
# 读取 Excel 文件
data = pd.read_excel(data_loc)
# 读取第一行的值（基于位置索引）
data_0 = data.iloc[0]  # 使用 iloc 方法获取第 0 行的数据
print(data_0)

  • 定位指定列

    import pandas as pd

# 定义数据文件路径
data_loc = r'./resources/销售数据.xlsx'
# 读取 Excel 文件
data = pd.read_excel(data_loc)
# 读取"大类编码"列全部值
data_1 = data.loc[:, "大类编码"]  # 使用 loc 方法获取指定列的数据
print(data_1)

  • 通过指定行和列，定位指定元素

    import pandas as pd

# 定义数据文件路径
data_loc = r'./resources/销售数据.xlsx'
# 读取 Excel 文件
data = pd.read_excel(data_loc)
# 读取第 1 行（索引为 0）,"大类编码"列对应的值
data_2 = data.loc[0, "大类编码"]  # 注意：Pandas 的索引从 0 开始，第 1 行对应索引 0
print(data_2)

  • 对行和列使用切片

    import pandas as pd

# 创建一个示例 DataFrame
data = {
    "大类编码": ["A001", "A002", "A003", "A004"],
    "产品名称": ["产品A", "产品B", "产品C", "产品D"],
    "销售数量": [10, 5, 8, 12],
    "单价（元）": [50, 80, 60, 70],
    "总销售额（元）": [500, 400, 480, 840]
}
df = pd.DataFrame(data)

# 使用 loc 对行和列进行切片
# 读取第 1 行到第 2 行（包含），以及 "大类编码" 到 "单价（元）" 列
result = df.loc[0:2, "大类编码":"单价（元）"]  # 注意：标签切片是包含结束位置的
print(result)

  • 提取符合要求的元素

    # 提取"销售数量"列中大于10的值
data_4 = data.loc[data["销售数量"] > 10]
print(data_4)

  • 数据分组与排序

    import pandas as pd

# 确保文件路径的引号匹配正确，使用双引号或单引号
file_loc = 'resources/销售数据.xlsx'
# 修正函数名的括号为英文字符，并确保大小写正确
data = pd.read_excel(file_loc)
# 按“商品类型”分组，并对“销售金额”列求和
data_extract = data.groupby("商品类型")['销售金额'].sum()
# 将结果重置索引，使“商品类型”成为普通列
data_extract = data_extract.reset_index()
# 打印结果
print(data_extract)

  • 将处理好的数据保存成excel

    import pandas as pd

# 修正文件路径的引号问题，并确保文件扩展名正确（x1sx 应为 xlsx）
file_loc = 'resources/销售数据.xlsx'
data = pd.read_excel(file_loc)
# 按“商品类型”分组，并对“销售金额”列求和
data_extract = data.groupby('商品类型')['销售金额'].sum()
# 将结果重置索引，使“商品类型”成为普通列
data_extract = data_extract.reset_index()
# 将结果保存为 CSV 文件，指定编码为 gbk，且不保存索引
data_extract.to_csv("处理好的表格.csv", encoding='gbk', index=False)
# 将结果保存为 Excel 文件，注意 to_excel 方法没有 encoding 参数
data_extract.to_excel("处理好的表格.xlsx",index=False)

3.Matplotlib画图处理

Matplotlib画图

  • 如何安装

    pip install matplotlib

  • 折线图

    Figure_1

    import numpy as np
import matplotlib
matplotlib.use('TkAgg')  # 使用 TkAgg 后端
import matplotlib.pyplot as plt


# 创建一个 x 值的数组，从 -2π 到 2π，步长为 0.01
x = np.arange(-2 * np.pi, 2 * np.pi, 0.01)

# 计算每个 x 值对应的 sin(x) 值
y = np.sin(x)

# 使用 matplotlib 来绘制图像
plt.figure()  # 创建一个新的图像窗口
plt.plot(x, y)  # 绘制折线图
plt.title('sin(x)')  # 设置图像的标题
plt.xlabel('x')  # 设置 x 轴的标签
plt.ylabel('sin(x)')  # 设置 y 轴的标签
plt.grid(True)  # 显示网格
plt.show()  # 显示图像

    image-20250302185842753

    import matplotlib
matplotlib.use('TkAgg')  # 使用 TkAgg 后端
import pandas as pd
import matplotlib.pyplot as plt

# 数据文件路径
data_loc = r'resources/yolov5s.csv'
# 读取 CSV 文件
data = pd.read_csv(data_loc, index_col=0)
# 提取训练框损失数据
train_bbox_loss = data['      train/box_loss']
# 创建 x 轴列表
x_list = [i for i in range(len(train_bbox_loss))]
# 绘制折线图
plt.plot(x_list, train_bbox_loss)
# 设置图表标题和坐标轴标签
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('YOLov5s')
# 显示网格
plt.grid(True)
# 显示图表
plt.show()

    image-20250302190036786

    # 导入必要的库
import pandas as pd  # 用于数据处理和分析
import matplotlib  # 用于绘图
matplotlib.use('TkAgg')  # 设置 Matplotlib 使用 TkAgg 后端，以便在某些环境中正确显示图形
import matplotlib.pyplot as plt  # 导入 pyplot 模块，用于绘制图表

# 定义 CSV 文件路径
file_1_loc = 'resources/yolov5l.csv'  # YOLOv5-Large 模型的数据文件路径
file_2_loc = 'resources/yolov5m.csv'  # YOLOv5-Medium 模型的数据文件路径
file_3_loc = 'resources/yolov5s.csv'  # YOLOv5-Small 模型的数据文件路径

# 读取 CSV 文件并加载到 Pandas DataFrame 中
file_1 = pd.read_csv(file_1_loc)  # 加载 YOLOv5-Large 的数据
file_2 = pd.read_csv(file_2_loc)  # 加载 YOLOv5-Medium 的数据
file_3 = pd.read_csv(file_3_loc)  # 加载 YOLOv5-Small 的数据

# 提取每个模型的训练 box_loss 数据列
file_1_train_box_loss = file_1['      train/box_loss']  # 提取 YOLOv5-Large 的 box_loss 数据
file_2_train_box_loss = file_2['      train/box_loss']  # 提取 YOLOv5-Medium 的 box_loss 数据
file_3_train_box_loss = file_3['      train/box_loss']  # 提取 YOLOv5-Small 的 box_loss 数据

# 创建 x 轴数据列表，表示 epoch 的索引
x_list = [i for i in range(len(file_1_train_box_loss))]  # 假设所有模型的 epoch 数量相同

# 绘制 box_loss 曲线
plt.plot(x_list, file_1_train_box_loss, label='yolov5l')  # 绘制 YOLOv5-Large 的 box_loss 曲线
plt.plot(x_list, file_2_train_box_loss, label='yolov5m')  # 绘制 YOLOv5-Medium 的 box_loss 曲线
plt.plot(x_list, file_3_train_box_loss, label='yolov5s')  # 绘制 YOLOv5-Small 的 box_loss 曲线

# 添加图表标题和坐标轴标签
plt.xlabel("Epoch")  # 设置 x 轴标签为 "Epoch"
plt.ylabel("Loss")  # 设置 y 轴标签为 "Loss"
plt.title("Train box_loss")  # 设置图表标题为 "Train box_loss"

# 添加网格以提高可读性
plt.grid()

# 添加图例以区分不同模型的曲线
plt.legend()  # 自动根据 plot 函数中的 label 参数生成图例

# 显示图表
plt.show()

  • 散点图

image-20250302190607699

# 导入必要的库
import matplotlib
matplotlib.use('TkAgg')  # 使用 TkAgg 后端
import matplotlib.pyplot as plt  # 用于绘制图表
import numpy as np  # 用于数值计算

# 创建数据
num_points = 100  # 定义点的数量
x = np.random.rand(num_points)  # 随机生成 x 坐标 (范围在 [0, 1] 之间)
y = np.random.rand(num_points)  # 随机生成 y 坐标 (范围在 [0, 1] 之间)
colors = np.random.rand(num_points)  # 随机生成每个点的颜色值 (范围在 [0, 1] 之间)
sizes = 1000 * np.random.rand(num_points)  # 随机生成每个点的大小 (范围在 [0, 1000] 之间)
alphas = np.random.rand(num_points)  # 随机生成每个点的透明度 (范围在 [0, 1] 之间)

# 创建散点图
plt.scatter(
    x, y,  # 数据点的 x 和 y 坐标
    c=colors,  # 每个点的颜色值
    s=sizes,  # 每个点的大小
    alpha=0.5,  # 设置全局透明度为 0.5（也可以使用 alphas 参数实现逐点透明度）
    cmap='viridis'  # 使用 'viridis' 色彩映射来表示颜色值
)

# 显示颜色条
plt.colorbar()  # 添加颜色条以显示颜色与值的对应关系

# 显示图像
plt.show()  # 展示最终的散点图

  • 柱状图

    image-20250302200324030

    # 导入必要的库
import matplotlib
matplotlib.use('TkAgg')  # 使用 TkAgg 后端
import matplotlib.pyplot as plt  # 用于绘制图表
import numpy as np  # 用于数值计算

# 数据
labels = ['A', 'B', 'C', 'D', 'E']  # 标签
values = [3, 7, 2, 5, 8]  # 对应的值

# 设置标签的位置
x = np.arange(len(labels))  # 创建等间距的 x 轴位置

# 绘制柱状图
plt.bar(
    x,  # x 轴位置
    values,  # y 轴高度
    color='blue',  # 柱子的颜色
    align='center',  # 柱子对齐方式
    alpha=0.7  # 柱子的透明度
)

# 设置图表的标题和轴标签
plt.title('Simple Bar Chart')  # 图表标题
plt.xlabel('Labels')  # x 轴标签
plt.ylabel('Values')  # y 轴标签

# 设置 x 轴的标签
plt.xticks(x, labels)  # 将 x 轴的位置替换为对应的标签

# 显示图像
plt.show()  # 展示图表

  • 饼状图

    image-20250302200544694

    import matplotlib.pyplot as plt  # 导入matplotlib的pyplot模块
import matplotlib
matplotlib.use('TkAgg')  # 使用 TkAgg 后端
# 数据
sizes = [15, 30, 45, 10]  # 各部分的大小
labels = ['A', 'B', 'C', 'D']  # 各部分的标签
colors = ['yellow', 'red', 'green', 'orange']  # 各部分的颜色
explode = (0.1, 0, 0, 0)  # 突出显示第一个部分（离圆心的距离）

# 绘制扇形图
plt.pie(
    sizes,  # 数据
    explode=explode,  # 突出显示的部分
    labels=labels,  # 标签
    colors=colors,  # 颜色
    autopct='%1.1f%%',  # 显示百分比，保留一位小数
    shadow=True,  # 添加阴影效果
    startangle=140  # 设置起始角度
)

# 设置为等比例，这样扇形图就是一个圆
plt.axis('equal')

# 显示图像
plt.show()  # 展示图表

4.OpenCV影像处理

  • 如何安装

    pip install opencv-python

  • 加载图片和展示图片

    import os
import cv2
import numpy as np

# 检查文件是否存在
file_path = r'.\resources\未标题-1.png'
if not os.path.exists(file_path):
    print(f"文件不存在: {file_path}")
else:
    print("文件存在")

# 自定义 imread 函数支持非 ASCII 路径
def IMREAD_COLOR(path):
    return cv2.imdecode(np.fromfile(path, dtype=np.uint8), cv2.IMREAD_COLOR)

def IMREAD_GRAYSCALE(path):
    return cv2.imdecode(np.fromfile(path, dtype=np.uint8), cv2.IMREAD_GRAYSCALE)

# 加载图像
image_color = IMREAD_COLOR(file_path)
image_gray = IMREAD_GRAYSCALE(file_path)
# 检查图像是否加载成功
if image_color is None:
    print(f"无法加载图像: {file_path}")
else:
    print("图像加载成功")
    cv2.imshow('Grayscale Image', image_gray)  # 显示灰度图像
    cv2.imshow('Color Image', image_color)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

  • 图像数据处理:图片缩放

    import cv2

# 读取图片
image = cv2.imread('resources/123.png')

# 检查图片是否正确加载
if image is None:
    print("Error: Could not load image.")
    exit()

# 获取图片的原始尺寸
original_height, original_width = image.shape[:2]

# 计算新的尺寸
new_width = int(original_width / 2)
new_height = int(original_height / 2)

# 使用 cv2.resize 进行图片缩放
resized_image = cv2.resize(image, (new_width, new_height), interpolation=cv2.INTER_AREA)

# 显示原始图片和缩放后的图片
cv2.imshow('Original Image', image)
cv2.imshow('Resized Image', resized_image)

# 等待用户按键，然后关闭窗口
cv2.waitKey(0)
cv2.destroyAllWindows()

  • 图片翻转

    import cv2

# 读取图片
image = cv2.imread('resources/123.png')

# 检查图片是否正确加载
if image is None:
    print("Error: Could not load image.")
    exit()

# 使用 cv2.rotate() 函数旋转图片
rotated_90 = cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE)  # 顺时针旋转 90 度
rotated_180 = cv2.rotate(image, cv2.ROTATE_180)         # 顺时针旋转 180 度
rotated_270 = cv2.rotate(image, cv2.ROTATE_90_COUNTERCLOCKWISE)  # 顺时针旋转 270 度

# 显示原始图片和旋转后的图片
cv2.imshow('Original', image)
cv2.imshow('90 Degree', rotated_90)
cv2.imshow('180 Degree', rotated_180)
cv2.imshow('270 Degree', rotated_270)

# 等待用户按键，然后关闭窗口
cv2.waitKey(0)
cv2.destroyAllWindows()

  • 图片保存

    import cv2

# 读取图片
image = cv2.imread('resources/123.png')

# 如果图像不为空，则保存图像
if image is not None:
    cv2.imwrite('output_image.png', image)
else:
    print("无法读取图像")

  • 视频读取

    import cv2

# 创建一个 VideoCapture 对象，参数 0 表示使用默认的摄像头
cap = cv2.VideoCapture(0)

while True:
    # 读取一帧
    ret, frame = cap.read()

    # 如果读取成功，显示这一帧
    if ret:
        cv2.imshow('Frame', frame)

    # 按 'q' 键退出循环
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 释放资源并关闭窗口
cap.release()
cv2.destroyAllWindows()

  • 视频保存

    import cv2

# 定义视频捕获对象
cap = cv2.VideoCapture(0)

# 检查是否成功打开摄像头
if not cap.isOpened():
    print("Error: Could not open camera.")
    exit()

# 获取摄像头的帧宽度和帧高度
frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

# 定义视频编码器和输出文件
fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # 或者使用 'XVID'
out = cv2.VideoWriter('output.mp4', fourcc, 20.0, (frame_width, frame_height))

while True:
    # 读取一帧
    ret, frame = cap.read()

    if not ret:
        print("Failed to grab frame.")
        break

    # 将当前帧写入输出视频文件
    out.write(frame)

    # 显示当前帧
    cv2.imshow('Frame', frame)

    # 按 'q' 键退出循环
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 释放资源
cap.release()
out.release()
cv2.destroyAllWindows()

  • 综合案例

    • 用OpenCV打开一段视频，将每一帧画面压缩成540p，对画面进行垂直翻转，转为黑白，然后添加高斯噪声，把处理好的每一帧画面保存成一个mp4文件
    import cv2
import numpy as np

# 定义高斯噪声函数
def add_gaussian_noise(image, mean=0, sigma=25):
    """
    向图像添加高斯噪声
    :param image: 输入图像 (灰度图像)
    :param mean: 高斯噪声的均值
    :param sigma: 高斯噪声的标准差
    :return: 添加噪声后的图像
    """
    # 生成与图像大小相同的高斯噪声
    noise = np.random.normal(mean, sigma, image.shape).astype(np.int16)
    # 将噪声叠加到图像上
    noisy_image = np.clip(image.astype(np.int16) + noise, 0, 255).astype(np.uint8)
    return noisy_image

# 打开视频文件
video_path = 'resources\\11111.mp4'  # 替换为您的视频文件路径
cap = cv2.VideoCapture(video_path)

# 检查是否成功打开视频文件
if not cap.isOpened():
    print("Error: Could not open video file.")
    exit()

# 获取视频的帧宽度和高度，并设置输出分辨率为 540p (960x540)
frame_width = 960
frame_height = 540

# 定义视频编码器和输出文件
output_path = 'output_video.mp4'  # 输出文件路径
fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # 使用 mp4v 编码器
out = cv2.VideoWriter(output_path, fourcc, 20.0, (frame_width, frame_height), isColor=False)

while True:
    # 读取一帧
    ret, frame = cap.read()
    if not ret:
        print("End of video or failed to grab frame.")
        break
    # 1. 将画面压缩到 540p 分辨率 (960x540)
    resized_frame = cv2.resize(frame, (frame_width, frame_height))
    # 2. 对画面进行垂直翻转
    flipped_frame = cv2.flip(resized_frame, 0)  # 参数 0 表示垂直翻转
    # 3. 将画面转换为黑白 (灰度图像)
    gray_frame = cv2.cvtColor(flipped_frame, cv2.COLOR_BGR2GRAY)
    # 4. 添加高斯噪声
    noisy_frame = add_gaussian_noise(gray_frame)
    # 5. 将处理好的帧写入输出视频文件
    out.write(noisy_frame)
    # 显示处理后的帧（可选）
    cv2.imshow('Processed Frame', noisy_frame)
    # 按 'q' 键退出循环
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
# 释放资源
cap.release()
out.release()
cv2.destroyAllWindows()

print(f"处理完成，输出文件已保存为 {output_path}")

5.pickle文件操作

pickle文件操作

  • 保存数据与加载数据

    import pickle

# 示例数据
data = {
    'name': 'John',  # 使用半角冒号和引号
    'age': 30,
    'is_student': False,
    'grades': [85, 90, 78, 92]
}

# 使用 pickle 保存数据
with open('data.pkl', 'wb') as file:  # 使用半角括号和引号
    pickle.dump(data, file)

# 使用 pickle 加载数据
with open('data.pkl', 'rb') as file:  # 使用半角括号和引号
    loaded_data = pickle.load(file)

print(loaded_data)  # 输出加载的数据

  • 综合案例

    • 用Pickle完成以下功能：

      当训练人工智能算法时，往往需要很长的时间，当训练中断时，如果能提前做好权重保存功能，能很快的恢复上次进度，以继续进行训练

    import pickle  # 用于序列化和反序列化对象
import time    # 用于模拟耗时操作
import os      # 用于检查文件是否存在
import numpy as np  # 用于生成随机权重矩阵


# 模拟耗时的权重计算过程
def calculate_weights():
    """
    模拟一个耗时的权重计算过程。
    返回一个10x10的随机权重矩阵。
    """
    print("开始计算权重...")
    time.sleep(5)  # 模拟耗时操作（例如复杂的计算）
    weights = np.random.rand(10, 10)  # 随机生成一个10x10的浮点数矩阵作为权重
    print("权重计算完成.")
    return weights


# 保存权重和当前epoch到文件
def save_weights(weights, epoch, filename='weights.pkl'):
    """
    将权重和当前epoch保存到指定的文件中。
    参数：
    - weights: 权重矩阵
    - epoch: 当前训练的epoch
    - filename: 文件名，默认为'weights.pkl'
    """
    data = {'weights': weights, 'epoch': epoch}  # 将权重和epoch打包成字典
    with open(filename, 'wb') as f:  # 以二进制写入模式打开文件
        pickle.dump(data, f)  # 使用pickle将数据序列化并保存到文件
    print(f"权重和epoch已保存到{filename}.")


# 从文件加载权重和epoch
def load_weights(filename='weights.pkl'):
    """
    从指定的文件中加载权重和epoch。
    参数：
    - filename: 文件名，默认为'weights.pkl'
    返回：
    - weights: 加载的权重矩阵
    - epoch: 加载的epoch值
    """
    with open(filename, 'rb') as f:  # 以二进制读取模式打开文件
        data = pickle.load(f)  # 使用pickle从文件中反序列化数据
    print(f"权重和epoch已从{filename}加载.")
    return data['weights'], data['epoch']  # 返回权重和epoch


# 主程序
def main():
    """
    主程序逻辑：
    1. 检查是否存在保存的权重文件。
    2. 如果存在，则加载权重和epoch；否则重新计算权重并从第一个epoch开始。
    3. 继续训练剩余的epochs，并在每个epoch结束后保存权重和epoch信息。
    """
    weights_file = 'weights.pkl'  # 权重文件名
    total_epochs = 100  # 假设总共需要训练100个epochs

    # 如果权重文件存在，则加载权重和epoch
    if os.path.exists(weights_file):  # 检查文件是否存在
        weights, start_epoch = load_weights(weights_file)  # 加载权重和epoch
    else:
        # 如果文件不存在，则从第一个epoch开始，并计算初始权重
        weights = calculate_weights()  # 计算初始权重
        start_epoch = 0  # 从第0个epoch开始

    # 继续训练剩余的epochs
    for epoch in range(start_epoch, total_epochs):  # 从start_epoch开始训练到total_epochs
        print(f"开始训练epoch {epoch}...")
        # 这里可以加入实际的训练代码
        time.sleep(1)  # 模拟训练过程（每个epoch耗时1秒）
        print(f"完成训练epoch {epoch}.")

        # 每个epoch结束后保存权重和epoch信息
        save_weights(weights, epoch, weights_file)


if __name__ == '__main__':
    """
    程序入口点。
    如果该脚本作为主程序运行，则调用main()函数启动训练过程。
    """
    main()

PyQt

1.PyQt构建用户界面

  • 安装Pyqt5

    pip install PyQt5

  • 安装QtDesigner

    pip install pyqt tools

    在 PyCharm 中配置 Qt Designer 作为外部工具的步骤如下：

    1. 打开 PyCharm，依次点击菜单栏中的 File -> Settings -> Tools -> External Tools，进入外部工具设置界面。
    2. 点击界面右上角的加号（+），新增一个外部工具。
    3. 在 Name 字段中输入工具名称，例如 Qt Designer（名称可自定义，方便识别即可）。
    4. 在 Program 字段中，指定 designer.exe 的完整路径。该文件通常位于 Python 安装目录下的 Lib\site-packages\pyqt5_tools 文件夹中。
最近更新：:
Contributors: yanpeng_