Python中shutil.copy2的优势与应用场景举例详解

import shutil
import os
import time

src = "source.txt"
dst1 = "dest_copy.txt"
dst2 = "dest_copy2.txt"

# 创建测试文件
with open(src, "w") as f:
    f.write("test content")

# 等待一下，确保时间不同
time.sleep(1)

# 使用 copy() - 丢失时间戳
shutil.copy(src, dst1)

# 使用 copy2() - 保留时间戳
shutil.copy2(src, dst2)

# 检查时间戳
print(f"原始文件修改时间: {os.path.getmtime(src)}")
print(f"copy() 目标时间: {os.path.getmtime(dst1)}")  # 当前时间
print(f"copy2() 目标时间: {os.path.getmtime(dst2)}")  # 与原文件相同

# copy2() 实际上是这样工作的
def copy2_in_detail(src, dst):
    # 1. 拷贝文件内容
    shutil.copyfile(src, dst)
    
    # 2. 尝试拷贝权限
    shutil.copymode(src, dst)
    
    # 3. 尝试拷贝所有元数据（包括时间戳）
    shutil.copystat(src, dst)

import shutil
import os

def safe_copy2(src, dst):
    """安全拷贝文件，保留所有元数据"""
    try:
        # 确保目标目录存在
        os.makedirs(os.path.dirname(dst), exist_ok=true)
        
        # 使用copy2保留元数据
        shutil.copy2(src, dst)
        print(f"成功拷贝 {src} 到 {dst}，保留时间戳")
        
        # 验证拷贝结果
        if os.path.exists(dst):
            src_mtime = os.path.getmtime(src)
            dst_mtime = os.path.getmtime(dst)
            
            # 时间戳应该相同（或非常接近）
            return abs(src_mtime - dst_mtime) < 0.001
            
    except exception as e:
        print(f"拷贝失败: {e}")
        return false
    
    return true

# ❌ 不推荐的方式
os.system('cp source.txt dest.txt')
# 或
os.system('copy source.txt dest.txt')  # windows

# ✅ 推荐的方式
import shutil
shutil.copy2('source.txt', 'dest.txt')

import os
import shutil

# 1. 跨平台问题
os.system('cp file.txt backup/')  # linux/mac 正常
os.system('cp file.txt backup/')  # windows 报错: 'cp' 不是内部命令

# 2. 路径问题
file_path = "some file with spaces.txt"
os.system(f'cp {file_path} dest/')  # ❌ 有空格会出错
shutil.copy2(file_path, 'dest/')    # ✅ 正确处理

# 3. 安全问题
user_input = "source.txt; rm -rf /"  # 恶意输入
os.system(f'cp {user_input} dest/')  # ❌ 命令注入攻击！
shutil.copy2(user_input, 'dest/')    # ✅ 只当作文件路径

import subprocess

# ❌ 复杂且容易出错
subprocess.run(['cp', 'source.txt', 'dest.txt'])  # 非跨平台
subprocess.run(['copy', 'source.txt', 'dest.txt'], shell=true)  # windows

# ✅ 简单直接
shutil.copy2('source.txt', 'dest.txt')

# ❌ 低效且容易出错
with open('source.txt', 'rb') as src, open('dest.txt', 'wb') as dst:
    dst.write(src.read())  # 大文件会内存溢出！

# ✅ 自动处理大文件和优化
shutil.copy2('source.txt', 'dest.txt')  # 使用缓冲，支持大文件

# 同一份代码在所有平台运行
shutil.copy2('source.txt', 'dest.txt')  
# windows ✅ | linux ✅ | mac ✅

# 没有命令注入风险
filename = "test; rm -rf /"
shutil.copy2(filename, 'backup/')  # 安全：只当作文件名

import shutil

# 不只是拷贝文件
shutil.copy2('file.txt', 'dest.txt')      # 拷贝文件（保留元数据）
shutil.copytree('src_dir', 'dst_dir')     # 拷贝整个目录树
shutil.move('src', 'dst')                 # 移动文件/目录
shutil.rmtree('directory')                # 删除目录树
shutil.make_archive('backup', 'zip', 'dir')  # 创建压缩包

import shutil
import os

try:
    # 会自动创建目标目录（如果指定了目录路径）
    os.makedirs('path/to/dest', exist_ok=true)
    shutil.copy2('source.txt', 'path/to/dest/')
    
    # 如果文件不存在，会抛出明确的异常
except filenotfounderror as e:
    print(f"文件不存在: {e}")
except permissionerror as e:
    print(f"权限错误: {e}")
except shutil.samefileerror:
    print("不能拷贝到自身")
except exception as e:
    print(f"其他错误: {e}")

# shutil内部使用优化算法
def how_shutil_works():
    """
    实际上shutil这样工作：
    1. 使用合适的缓冲区大小（默认16kb）
    2. 逐块读取写入，避免内存溢出
    3. 使用系统级优化（如sendfile在linux上）
    4. 自动处理符号链接等特殊情况
    """

import shutil
import os

def backup_files(source_dir, backup_dir):
    """跨平台备份文件"""
    os.makedirs(backup_dir, exist_ok=true)
    
    for filename in os.listdir(source_dir):
        src = os.path.join(source_dir, filename)
        dst = os.path.join(backup_dir, filename)
        
        if os.path.isfile(src):
            # 使用shutil - 自动处理所有平台差异
            shutil.copy2(src, dst)  # ✅ 保留时间戳
            print(f"备份: {src} -> {dst}")
            
# 这段代码在windows/linux/mac都能运行

import shutil
import tempfile

def safe_process_file(filename):
    """安全处理用户上传的文件"""
    # 创建临时工作副本
    with tempfile.namedtemporaryfile(delete=false) as tmp:
        temp_path = tmp.name
    
    # 安全拷贝用户文件
    shutil.copy2(filename, temp_path)  # ✅ 无命令注入风险
    
    # 处理临时文件...
    process(temp_path)
    
    # 清理
    os.unlink(temp_path)

import shutil
import os
from datetime import datetime

def archive_old_logs(log_dir, archive_dir, days_old=30):
    """归档旧日志文件"""
    cutoff = datetime.now().timestamp() - (days_old * 86400)
    
    for root, dirs, files in os.walk(log_dir):
        for file in files:
            filepath = os.path.join(root, file)
            
            # 检查文件时间
            if os.path.getmtime(filepath) < cutoff:
                # 保持目录结构
                rel_path = os.path.relpath(filepath, log_dir)
                dest_path = os.path.join(archive_dir, rel_path)
                
                # 创建目标目录
                os.makedirs(os.path.dirname(dest_path), exist_ok=true)
                
                # 移动文件（保留所有属性）
                shutil.move(filepath, dest_path)
                print(f"已归档: {rel_path}")

import subprocess

# 1. 需要特定shell功能时
if need_special_shell_feature:
    subprocess.run('rsync -avz source/ dest/', shell=true)  # rsync高级特性
    
# 2. 需要异步拷贝时
import asyncio
import aiofiles  # 第三方库

async def async_copy():
    async with aiofiles.open('src.txt', 'rb') as src:
        async with aiofiles.open('dst.txt', 'wb') as dst:
            await dst.write(await src.read())

import os

# 创建目录（包括中间目录）
os.makedirs("path/to/my/directory")

# ✅ 目录存在时不会报错
os.makedirs("my_folder", exist_ok=true)

# 效果：
# - 如果目录不存在：创建目录
# - 如果目录已存在：什么都不做，继续执行

# ❌ 目录存在时会报错
os.makedirs("my_folder")  # 等同于 exist_ok=false

# 效果：
# - 如果目录不存在：创建目录
# - 如果目录已存在：抛出 fileexistserror 异常

import os
import shutil
from datetime import datetime

def backup_file(src_file, backup_root="backups"):
    """安全的备份函数"""
    # 创建带日期的备份目录
    date_str = datetime.now().strftime("%y-%m-%d")
    backup_dir = os.path.join(backup_root, date_str)
    
    # ✅ 使用 exist_ok=true - 目录已存在也不报错
    os.makedirs(backup_dir, exist_ok=true)
    
    # 生成备份文件名
    backup_path = os.path.join(backup_dir, os.path.basename(src_file))
    
    # 执行备份
    shutil.copy2(src_file, backup_path)
    return backup_path

# 多次调用也不会出错
backup_file("data.txt")  # 第一次：创建目录
backup_file("data.txt")  # 第二次：目录已存在，正常继续

def create_unique_workspace(base_dir="workspace"):
    """创建唯一的工作目录"""
    import time
    
    # 生成唯一目录名
    timestamp = int(time.time())
    unique_dir = os.path.join(base_dir, f"workspace_{timestamp}")
    
    # ❗ 使用 exist_ok=false 确保目录是新的
    try:
        os.makedirs(unique_dir, exist_ok=false)
        print(f"创建了新工作目录: {unique_dir}")
        return unique_dir
    except fileexistserror:
        print(f"目录已存在（理论上不会发生）: {unique_dir}")
        raise  # 重新抛出异常

# 每次调用都会创建新目录
create_unique_workspace()

# ⚠️ 有风险的代码
if not os.path.exists("my_dir"):
    os.makedirs("my_dir")  # 这里可能有其他进程创建了目录

# ✅ 安全的代码
try:
    os.makedirs("my_dir", exist_ok=false)
except fileexistserror:
    # 目录已经被其他进程创建了
    print("目录已被其他进程创建，继续执行")

def safe_makedirs(path, mode=0o755):
    """安全创建目录并设置权限"""
    try:
        os.makedirs(path, mode=mode, exist_ok=true)
        
        # 确保权限正确（即使目录已存在）
        os.chmod(path, mode)
        
    except permissionerror:
        print(f"权限不足，无法创建或修改: {path}")
        raise
    except exception as e:
        print(f"创建目录失败: {e}")
        raise

# 使用
safe_makedirs("/opt/myapp/logs")

# 1. 确保目录存在的场景
os.makedirs("logs", exist_ok=true)
os.makedirs("cache", exist_ok=true)
os.makedirs("uploads", exist_ok=true)

# 2. 初始化脚本（幂等操作）
def init_application():
    """应用初始化 - 可以安全地多次调用"""
    directories = ["config", "data", "logs", "tmp"]
    for dir_name in directories:
        os.makedirs(dir_name, exist_ok=true)
    
# 3. 临时文件目录
import tempfile
temp_dir = tempfile.mkdtemp()  # 已经创建了
os.makedirs(temp_dir, exist_ok=true)  # 不会重复创建

# 1. 检测目录是否是新创建的
def setup_new_project(project_path):
    """设置新项目 - 要求目录不存在"""
    try:
        os.makedirs(project_path, exist_ok=false)
        print(f"新项目目录已创建: {project_path}")
    except fileexistserror:
        print(f"错误：项目目录已存在: {project_path}")
        raise

# 2. 避免意外覆盖
def create_backup_dir(date_str):
    """创建日期备份目录 - 如果已存在说明有问题"""
    backup_dir = f"backup_{date_str}"
    try:
        os.makedirs(backup_dir, exist_ok=false)
    except fileexistserror:
        print(f"警告：今天的备份已存在！")
        choice = input("是否覆盖？(y/n): ")
        if choice.lower() != 'y':
            return none
    return backup_dir

import os
import errno

def ensure_directory(path, mode=0o755):
    """
    确保目录存在（如果不存在则创建）
    类似于 mkdir -p 但更加安全
    """
    try:
        os.makedirs(path, mode=mode, exist_ok=true)
        return true
    except oserror as e:
        # 处理可能的错误
        if e.errno != errno.eexist:  # 不是"已存在"的错误
            print(f"无法创建目录 {path}: {e}")
            raise
        return false

# 使用
ensure_directory("project/data/cache")

import os
import shutil
import atexit

class temporarydirectorymanager:
    """临时目录管理器"""
    
    def __init__(self, base_dir="tmp"):
        self.base_dir = base_dir
        self.created_dirs = set()
        atexit.register(self.cleanup)
    
    def get_dir(self, name):
        """获取或创建目录"""
        path = os.path.join(self.base_dir, name)
        
        # 创建目录（如果已存在也没关系）
        os.makedirs(path, exist_ok=true)
        self.created_dirs.add(path)
        
        return path
    
    def cleanup(self):
        """清理所有创建的目录"""
        for dir_path in self.created_dirs:
            if os.path.exists(dir_path):
                try:
                    shutil.rmtree(dir_path)
                except exception as e:
                    print(f"清理目录失败 {dir_path}: {e}")

# 使用
tmp_mgr = temporarydirectorymanager()
cache_dir = tmp_mgr.get_dir("cache")  # 自动创建

import os

class appdirectories:
    """应用目录结构管理"""
    
    def __init__(self, app_name="myapp"):
        # 定义所有需要的目录
        self.dirs = {
            'config': f"~/.{app_name}/config",
            'data': f"~/.{app_name}/data",
            'cache': f"~/.{app_name}/cache",
            'logs': f"~/.{app_name}/logs",
            'temp': f"/tmp/{app_name}"
        }
        
        # 展开用户目录
        self.dirs = {k: os.path.expanduser(v) for k, v in self.dirs.items()}
    
    def setup(self, force=false):
        """初始化所有目录"""
        for name, path in self.dirs.items():
            try:
                if force:
                    # 强制模式：删除后重新创建
                    if os.path.exists(path):
                        shutil.rmtree(path)
                    os.makedirs(path)
                else:
                    # 普通模式：如果已存在则跳过
                    os.makedirs(path, exist_ok=true)
                    
                print(f"✓ {name}: {path}")
            except exception as e:
                print(f"✗ 创建目录失败 {name}: {e}")
                raise

# 使用
app_dirs = appdirectories("myapp")
app_dirs.setup()  # 第一次运行：创建目录
app_dirs.setup()  # 第二次运行：目录已存在，安全跳过

在python的shutil模块中，有多个用于拷贝文件的函数，其中copy2是常用的一个。它的好处在于，它不仅拷贝文件的内容，还会尝试保留文件的元数据（如修改时间、访问时间等）。下面我将详细解释copy2与其他拷贝函数的区别，以及为什么选择copy2。

shutil模块中与拷贝相关的函数主要有：

shutil.copy

shutil.copy2

shutil.copyfile

shutil.copyfileobj

1. shutil.copy
用法：shutil.copy(src, dst)

功能：将文件从src复制到dst。如果dst是一个目录，则文件将被复制到该目录中，并保留原文件名。如果dst是一个文件，则将被覆盖。

特点：它只拷贝文件内容，并且不会保留文件的元数据（如时间戳）。在unix系统上，它还会丢失文件的权限（因为默认使用copy2，但注意：实际上copy在unix上使用copy2，而在windows上使用copyfile和copymode，但文档说它不保留所有元数据，特别是时间戳）。

2. shutil.copy2
用法：shutil.copy2(src, dst)

功能：与copy类似，但会尝试保留文件的元数据，包括修改时间和访问时间等。

特点：在unix系统上，它使用os.utime来设置时间，并尝试保留其他元数据（如权限）。在windows上，它也会尝试设置时间，但注意windows上文件创建时间等可能不会被保留（实际上，copy2在windows上使用copyfile和copystat，而copystat在windows上会设置最后修改时间和最后访问时间）。

3. shutil.copyfile
用法：shutil.copyfile(src, dst)

功能：只拷贝文件内容，不拷贝任何元数据。而且，dst必须是文件名，不能是目录。

特点：这是最基础的拷贝，只拷贝数据。

4. shutil.copyfileobj
用法：shutil.copyfileobj(src_fileobj, dst_fileobj, length=16*1024)

功能：在两个文件对象之间拷贝数据。例如，可以用于拷贝已经打开的文件。

为什么选择copy2？
如果你希望保留文件的元数据（特别是修改时间），那么应该使用copy2。例如，当你备份文件时，保留原始文件的修改时间可能会很有用。

如果你只是需要拷贝文件内容，不关心元数据，那么使用copy或copyfile也可以。

为什么不是copy1或copy3？
在shutil模块中，并没有copy1和copy3这两个函数。只有copy和copy2，以及copyfile和copyfileobj。所以，copy2的命名是因为它比copy多了一个保留元数据的步骤（可以理解为copy的增强版），而copyfile是更基础的版本。

总结
使用shutil.copy2的好处是：在拷贝文件时，会尽可能保留文件的元数据（如修改时间、访问时间等）。

如果你不需要保留元数据，可以使用shutil.copy。

如果只需要拷贝数据，甚至不需要拷贝权限，可以使用shutil.copyfile。

根据你的需求选择适当的拷贝函数。如果你在备份或需要保持文件时间属性的场景下，copy2是更好的选择。