4、Python函数、模块、文件与文件夹操作

1.Python函数

1.1函数

1.1.1参数传递

形参和实参

# 形参是函数定义时的参数，实参是函数调用时的参数

def create_model(layers, units):  # layers和units是形参
    print(f"Creating a model with {layers} layers and {units} units in each layer.")

# 调用函数
create_model(3, 128)  # 3 和 128 是实参

位置参数

# 位置参数的顺序很重要

def create_model(layers, units):
    print(f"Creating a model with {layers} layers and {units} units in each layer.")

# 调用函数
create_model(3, 128)
create_model(128, 3)

关键字参数

# 使用关键字参数调用函数

def create_model(layers, units):  
    print(f"Creating a model with {layers} layers and {units} units in each layer.")

# 调用函数
create_model(units=128, layers=3)  # 使用关键字参数，顺序不重要
create_model(layers=3, units=128)

默认参数

# 使用默认参数值

def create_model(layers=3, units=128):
    print(f"Creating a model with {layers} layers and {units} units in each layer.")

# 调用函数
create_model()  # 使用默认值

可变参数

# 使用可变参数接受多个参数值

def add_layers(model, *layers):
    for layer in layers:
        print(f"Adding layer {layer} to model {model}.")

# 调用函数
add_layers("Model1", "conv", "relu", "softmax")

1.1.2函数返回值

通过return返回

# 函数返回模型的信息

def create_model(layers, units):
    info = f"Creating a model with {layers} layers and {units} units in each layer."
    return info

# 调用函数
model_info = create_model(3, 128)
print(model_info)

1.1.3变量作用域

全局变量

# 全局变量

MODEL_NAME = "CNN"

def print_model_name():
    print(f"The model name is {MODEL_NAME}")

# 调用函数
print_model_name()

局部变量

# 局部变量

def create_model():
    model_name = "RNN"  # 局部变量
    print(f"Creating a model named {model_name}")

# 调用函数
create_model()

print(model_name)  # 此行代码会报错

1.1.4匿名函数

冒号前面是输入，冒号后面是输出

# 使用lambda创建匿名函数

calculate_unites = lambda layers: layers * 128

# 调用函数
units = calculate_unites(3)
print(f"Total units: {units}")

1.2综合案例：使用函数创建模型

创建一个函数，输入包括：

        输入图像尺寸（channels, height, width）元组

        卷积核大小（默认为3）

        边缘补零，padding（默认为0）

        卷积步长（默认为1）

最终需要返回卷积后图像的尺寸

计算方法为：

        new_height = ((height + 2* padding - kernel)  // stride) + 1

        new_width = ((width + 2 * padding - kernel) // stride) + 1

最后将channels, new_height, new_width组成新的元组output_size进行返回

def create_cnn(input_size, kernel=3, padding=0, stride=1):
    """
    创建一个卷积神经网络层

    参数：
    - input_size：输入图像的尺寸，形式为 (channels, height, width)
    - kernel：卷积核的大小，默认为 3
    - padding：填充大小，默认为 0
    - stride：步长，默认为 1

    返回：
    - output_size：卷积操作后输出图像的尺寸，形式为 (channels, new_height, new_width)
    """

    # 从输入尺寸中获取通道数和图像大小
    channels, height, width = input_size

    # 计算卷积操作后的输出图像尺寸
    new_height = ((height + 2 * padding - kernel) // stride) + 1
    new_width = ((width + 2 * padding - kernel) // stride) + 1

    # 输出图像的尺寸
    output_size = (channels, new_height, new_width)

    return output_size

# 示例用法：
input_size = (3, 64, 64)  # 3通道，64x64的图像
output_size = create_cnn(input_size, stride=2, padding=1)
print(output_size)

2.Python模块

使用 pip list 查看已安装的模块

pip list

使用 pip install 安装想要的模块

pip install numpy

安装时可以指定想要安装的版本

pip install numpy==1.25

使用 import 导入模块

import numpy

如果模块名很长，可以用 import ... as ... 给模块起一个别名

import numpy as np

简单案例：统计用户输入时长

functions.py

def add(x, y):
    """加法"""
    return x + y

def sub(x, y):
    """减法"""
    return x - y

learn_import.py

import time
import random as r
from functions import *

a = r.randint(1, 5)
b = r.randint(1, 5)

tik = time.time()

data = int(input(f"请输入{a} + {b} 的结果："))

result = add(a, b)

if data == result:
    print("恭喜回答成功")
else:
    print("回答错误")

tok = time.time()

print(tok - tik)

3.Python文件与文件操作

3.1文件操作

3.1.1复制单个文件

import shutil

file_1_loc = "resources/保存目录1/fire.jpg"
file_1_save_loc = "resources/保存目录2/fire_copy.jpg"

shutil.copyfile(file_1_loc, file_1_save_loc)

3.1.2复制多个文件

import shutil

# 源目录和目标目录
src = "resources/fire_yolo_format"
dst = "resources/fire_yolo_format_new"

# 使用copytree复制目录
shutil.copytree(src, dst)

print(f"Directory copied from {src} to {dst}")

 还可以复制时忽略特定格式

import shutil

# 源目录和目标目录
src = "resources/fire_yolo_format"
dst = "resources/fire_yolo_format_new_1"

# 使用copytree复制目录
shutil.copytree(src, dst, ignore=shutil.ignore_patterns("*.txt"))
# ignore=shutil.ignore_patterns("*.txt") 不去复制txt文件

print(f"Directory copied from {src} to {dst}")

3.1.3移动文件

移动文件既剪切文件，使用使用shutil.move(src, dst) 剪切文件

import shutil

file_1_loc = "resources/保存目录1/fire_label.txt"
file_1_save_loc = "resources/保存目录2/fire_label.txt"

shutil.move(file_1_loc, file_1_save_loc)

3.1.4删除文件

import os

file_loc = r'resources/保存目录1/fire.jpg'

os.remove(file_loc)

3.2文件夹操作

3.2.1创建文件夹

import os

dir_name = "my_dir"

if os.path.exists(dir_name):  # 文件或文件夹是否已经存在 os.path.exists
    print("文件夹已经存在！")
else:
    os.mkdir(dir_name)  # 创建一级目录
    print("文件夹已经创建完毕！")

 创建多级文件夹

import os

# 创建多级目录
os.makedirs("my_dir_1\\my_dir_2\\my_dir_3")

3.2.2遍历文件夹

import os

root_dir = 'resources\\fire_yolo_format'

file_full_path_list = []  # 接受文件完整路径的列表
for root, dirs, files in os.walk(root_dir):  # 路径遍历 os.walk
    for file_i in files:
        file_i_full_path = os.path.join(root, file_i)  # 路径拼接 os.path.join
        file_full_path_list.append(file_i_full_path)

print(file_full_path_list)

3.2.3删除空白文件夹

os.rmdir 只能删除空的文件夹

import os

dir_path = "my_dir_1"

if os.path.exists(dir_path):
    print("删除文件夹"+dir_path)
    os.rmdir(dir_path)
    print("删除完成")
else:
    print("文件夹"+dir_path+"不存在")

3.2.4删除非空文件夹

import os
import shutil

dir_name = "my_dir_1"

if os.path.exists(dir_name):
    shutil.rmtree(dir_name)  # 文件夹里有东西也一并删除
    print("文件夹已经删除！")
else:
    os.mkdir(dir_name)
    print("文件夹不存在！")

3.3综合案例：YOLO标注文件清洗

YOLO标注文件清洗

训练一个人工智能算法需要一个庞大的数据集，这个数据集需要进行人为标注。

但由于出现意外，造成部分数据丢失，使得标注文件和图片文件的文件名前缀不能一一对应。

需要写一段代码，将可以文件名前缀一一对应的文件保存到一个新的文件夹中，以完成数据的清洗。

# 文件清洗
# 将 'resources/fire_yolo_format' 当中标签名和图片名匹配的文件，按原排放顺序保存到新的文件夹 'resources/clean_data'
# 需要用代码创建文件夹


import os
import shutil

def get_info(root_from):
    file_full_path_list = []
    for root, _, files in os.walk(root_from):
        for file_i in files:
            file_i_full_path = os.path.join(root, file_i)

            file_i_full_path_list = file_i_full_path.split("\\")

            file_i_short_path = os.path.join(file_i_full_path_list[-2], file_i_full_path_list[-1])

            file_i_name = file_i_short_path.split(".")[0]

            file_full_path_list.append(file_i_name)

    return file_full_path_list

root_path_from = "resources/fire_yolo_format"
root_path_save = "resources/clean_data"

root_images_from = os.path.join(root_path_from, "images")
root_labels_from = os.path.join(root_path_from, "labels")

root_images_save = os.path.join(root_path_save, "images")
root_labels_save = os.path.join(root_path_save, "labels")

# 创建保存的文件夹
dir_list_1 = ["images", "labels"]
dir_name_list = ["test", "train", "val"]

for dir_1_i in dir_list_1:
    for dir_2_i in dir_name_list:
        dir_i_full_path = os.path.join(root_path_save, dir_1_i, dir_2_i)
        if not os.path.exists(dir_i_full_path):
            os.makedirs(dir_i_full_path)

image_full_path_list = get_info(root_images_from)
print(image_full_path_list)

label_full_path_list = get_info(root_labels_from)
print(label_full_path_list)

image_set = set(image_full_path_list)
label_set = set(label_full_path_list)

intersection_set = image_set & label_set
print(len(image_set))
print(len(label_set))
print(len(intersection_set))

print(intersection_set)

# 复制交集中的文件到新的文件夹
for intersection_i in intersection_set:
    intersection_i_image_full_path_from = os.path.join(root_images_from, intersection_i) + ".jpg"
    intersection_i_label_full_path_from = os.path.join(root_labels_from, intersection_i) + ".txt"

    intersection_i_image_full_path_save = os.path.join(root_images_save, intersection_i) + ".jpg"
    intersection_i_label_full_path_save = os.path.join(root_labels_save, intersection_i) + ".txt"

    shutil.copy(intersection_i_image_full_path_from, intersection_i_image_full_path_save)
    shutil.copy(intersection_i_label_full_path_from, intersection_i_label_full_path_save)