python 拷贝版本

方案一： 直接套用脚本，需可以看懂一些脚本逻辑

这个函数使用 multiprocessing 模块来创建多个进程，并将每个进程分配到不同的目标目录中进行 txt 文件拷贝。每个进程都会执行 copy_txt_files 函数来拷贝指定目录中的 txt 文件。

在所有进程的执行过程中，记录开始时间和结束时间，并计算出拷贝所需的总时间。最后输出拷贝文件的总时间。

需要注意的是，多进程直接对全局变量进行读写会产生竞争条件，这里我们并没有用到全局变量，因此不需要对变量加锁。此外，子进程启动通常比线程启动需要更多的时间和资源，因此在选择使用多进程还是多线程时，需要根据实际情况进行选择

import shutil
import os
import multiprocessing
import time

def copy_folder(source_folder, dest_folders):
    """
    将文件夹 source_folder 复制到多个目标文件夹 dest_folders。
    如果目标文件夹已经存在，则先清空目标文件夹，然后复制。
    """
    for dest_folder in dest_folders:
        try:
            if os.path.exists(dest_folder):
                shutil.rmtree(dest_folder)
            shutil.copytree(source_folder, dest_folder)
            print(f"成功将 {source_folder} 复制到 {dest_folder}")
        except Exception as e:
            print(f"复制 {source_folder} 到 {dest_folder} 时发生错误:e}")

if __name__ == "__main__":
    # 需要复制的原始文件夹
    source_folder = "source/folder"
    
    # 需要复制到的多个目标文件夹
    dest_folders = ["/path/folder_1", "/path/folder_2", "/path/folder_3"]
    
    # 计算每个进程需要拷贝的目标文件夹数量
    processes_num = len(dest_folders)
    folders_per_process = len(dest_folders) // processes_num
    
    # 创建进程列表
    processes = []
    for i in range(processes_num):
        start = i * folders_per_process
        end = start + folders_per_process
        if i == processes_num - 1:
            end = len(dest_folders)
        process = multiprocessing.Process(target=copy_folder, args=(source_folder, dest_folders[start:end]))
        processes.append(process)
    
    # 记录开始时间
    start_time = time.time()
    
    # 启动所有进程
    for process in processes:
        process.start()
    
    # 等待所有进程结束
    for process in processes:
        process.join()
    
    # 记录结束时间并输出用时
    end_time = time.time()
    print(f"复制用时: {end_time - start_time} 秒")

方案二：直接调用封装脚本（写用例，执行脚本即可）

脚本实现封装后，只需要在MultiProcessCopy.yaml文件中写用例即可，此后执行Multiprocess_Copy.py脚本即实现多进程拷贝文件夹下所有指定的文件如（.txt、.exe等结尾的文件）到指定目录

目录介绍：

MultiProcessCopy.yaml配置拷贝文件的源地址和目标地址

source_folder: 原始文件夹路径

dest_folders: 需存放目标文件夹，可多个同时填写

endswith：特殊文件以什么结尾的 如 .txt .exe .dll 等等

num_process： 进程数，自定义

MultiProcess:
  source_folder: \\127.0.0.1\exportdir
  dest_folders:
    - \\127.0.0.2\d$\p
    - \\127.0.0.2\d$\p
  endswith: .txt
  num_process: 5

PublicConfig.py脚本： 配置读取信息，方便调用

import os
from Public_Utils.util_yaml import YamlReader

class YamlPath:
    def __init__(self):
        current = os.path.abspath(__file__)
        self.base_dir = os.path.dirname(os.path.dirname(current))

    def get_multiprocess_file(self):
        _config_path = self.base_dir + os.sep + "Public_Config\Public_yaml"
        self._config_file = _config_path + os.sep + "MultiProcessCopy.yaml"
        return self._config_file

class ConfigYaml:
    def __init__(self):   #初始yaml读取配置文件
        self.multiprocess_config= YamlReader(YamlPath().get_multiprocess_file()).yaml_data()

    def get_multiprocess_yaml(self):
        return self.multiprocess_config['MultiProcess']

if __name__ == '__main__':
    pass

Multiprocess_Copy.py执行脚本

import multiprocessing
import os
import shutil
import time
from Public_Config.PublicConfig import ConfigYaml

class MultiProcess:

    def copy_special_files(sefl,source_dir, target_dir):

            txt_files = [f for f in os.listdir(source_dir) if os.path.isfile(os.path.join(source_dir, f)) and f.endswith(ConfigYaml().get_multiprocess_yaml()['endswith'])]
            for txt_file in txt_files:
                shutil.copy(os.path.join(source_dir, txt_file), os.path.join(target_dir, txt_file))
            """
            拷贝 txt 文件的函数，被进线程调用
            参数：
            source_dir：源目录路径
            target_dir：目标目录路径
            """

    def copy_all_sepcial_files(self,num_process):
        source_dir = ConfigYaml().get_multiprocess_yaml()['source_folder']  # 需要复制的原始文件夹
        target_dirs = ConfigYaml().get_multiprocess_yaml()['dest_folders']  # 需要复制到的目标文件夹
        #创建多个线程并启动
        processes = []
        start_time = time.time()
        for target_dir in target_dirs:
            t = multiprocessing.Process(target=self.copy_special_files,args=(source_dir,target_dir))
            t.daemon = True
            t.start()
            processes.append(t)

        #等待所有进程结束
        for t in processes:
            t.join()
        end_time = time.time()
        elapsed_time = end_time - start_time
        print(f"拷贝总共花费{elapsed_time:.2f}秒")

if __name__ == '__main__':
    MultiProcess().copy_all_sepcial_files(num_process = ConfigYaml().get_multiprocess_yaml()['num_process'])

util_yaml.py

import os
import yaml

class YamlReader:
    #初始化，判断文件是否存在
    def __init__(self,yaml_file):
        if os.path.exists(yaml_file):
            self.yaml_file = yaml_file
        else:
            raise FileNotFoundError("yaml文件不存在")
        self._data = None
        self._data_all = None

    def yaml_data(self):  #yaml文件读取 --单个文档读取
        #第一次调用data,读取yaml文档，如果不是，直接返回之前保存的数据
        if not self._data:
            with open(self.yaml_file,'rb') as f:
                self._data = yaml.safe_load(f)
        return self._data

    def yaml_data_all(self):  #多个文档的读取
        if not self._data_all:
            with open(self.yaml_file,'rb') as f:
                self._data_all = yaml.safe_load_all(f)
        return self._data_all