import shutil
import os
import time

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

# 創(chuàng)建測試文件
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() 目標(biāo)時間: {os.path.getmtime(dst1)}")  # 當(dāng)前時間
print(f"copy2() 目標(biāo)時間: {os.path.getmtime(dst2)}")  # 與原文件相同

# copy2() 實際上是這樣工作的
def copy2_in_detail(src, dst):
    # 1. 拷貝文件內(nèi)容
    shutil.copyfile(src, dst)
    
    # 2. 嘗試拷貝權(quán)限
    shutil.copymode(src, dst)
    
    # 3. 嘗試拷貝所有元數(shù)據(jù)（包括時間戳）
    shutil.copystat(src, dst)

import shutil
import os

def safe_copy2(src, dst):
    """安全拷貝文件，保留所有元數(shù)據(jù)"""
    try:
        # 確保目標(biāo)目錄存在
        os.makedirs(os.path.dirname(dst), exist_ok=True)
        
        # 使用copy2保留元數(shù)據(jù)
        shutil.copy2(src, dst)
        print(f"成功拷貝 {src} 到 {dst}，保留時間戳")
        
        # 驗證拷貝結(jié)果
        if os.path.exists(dst):
            src_mtime = os.path.getmtime(src)
            dst_mtime = os.path.getmtime(dst)
            
            # 時間戳應(yīng)該相同（或非常接近）
            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' 不是內(nèi)部命令

# 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/')    # ? 只當(dāng)作文件路徑

import subprocess

# ? 復(fù)雜且容易出錯
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())  # 大文件會內(nèi)存溢出！

# ? 自動處理大文件和優(yōu)化
shutil.copy2('source.txt', 'dest.txt')  # 使用緩沖，支持大文件

# 同一份代碼在所有平臺運行
shutil.copy2('source.txt', 'dest.txt')  
# Windows ? | Linux ? | Mac ?

# 沒有命令注入風(fēng)險
filename = "test; rm -rf /"
shutil.copy2(filename, 'backup/')  # 安全：只當(dāng)作文件名

import shutil

# 不只是拷貝文件
shutil.copy2('file.txt', 'dest.txt')      # 拷貝文件（保留元數(shù)據(jù)）
shutil.copytree('src_dir', 'dst_dir')     # 拷貝整個目錄樹
shutil.move('src', 'dst')                 # 移動文件/目錄
shutil.rmtree('directory')                # 刪除目錄樹
shutil.make_archive('backup', 'zip', 'dir')  # 創(chuàng)建壓縮包

import shutil
import os

try:
    # 會自動創(chuàng)建目標(biāo)目錄（如果指定了目錄路徑）
    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"權(quán)限錯誤: {e}")
except shutil.SameFileError:
    print("不能拷貝到自身")
except Exception as e:
    print(f"其他錯誤: {e}")

# shutil內(nèi)部使用優(yōu)化算法
def how_shutil_works():
    """
    實際上shutil這樣工作：
    1. 使用合適的緩沖區(qū)大小（默認(rèn)16KB）
    2. 逐塊讀取寫入，避免內(nèi)存溢出
    3. 使用系統(tǒng)級優(yōu)化（如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):
    """安全處理用戶上傳的文件"""
    # 創(chuàng)建臨時工作副本
    with tempfile.NamedTemporaryFile(delete=False) as tmp:
        temp_path = tmp.name
    
    # 安全拷貝用戶文件
    shutil.copy2(filename, temp_path)  # ? 無命令注入風(fēng)險
    
    # 處理臨時文件...
    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:
                # 保持目錄結(jié)構(gòu)
                rel_path = os.path.relpath(filepath, log_dir)
                dest_path = os.path.join(archive_dir, rel_path)
                
                # 創(chuàng)建目標(biāo)目錄
                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

# 創(chuàng)建目錄（包括中間目錄）
os.makedirs("path/to/my/directory")

# ? 目錄存在時不會報錯
os.makedirs("my_folder", exist_ok=True)

# 效果：
# - 如果目錄不存在：創(chuàng)建目錄
# - 如果目錄已存在：什么都不做，繼續(xù)執(zhí)行

# ? 目錄存在時會報錯
os.makedirs("my_folder")  # 等同于 exist_ok=False

# 效果：
# - 如果目錄不存在：創(chuàng)建目錄
# - 如果目錄已存在：拋出 FileExistsError 異常

import os
import shutil
from datetime import datetime

def backup_file(src_file, backup_root="backups"):
    """安全的備份函數(shù)"""
    # 創(chuàng)建帶日期的備份目錄
    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))
    
    # 執(zhí)行備份
    shutil.copy2(src_file, backup_path)
    return backup_path

# 多次調(diào)用也不會出錯
backup_file("data.txt")  # 第一次：創(chuàng)建目錄
backup_file("data.txt")  # 第二次：目錄已存在，正常繼續(xù)

def create_unique_workspace(base_dir="workspace"):
    """創(chuàng)建唯一的工作目錄"""
    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"創(chuàng)建了新工作目錄: {unique_dir}")
        return unique_dir
    except FileExistsError:
        print(f"目錄已存在（理論上不會發(fā)生）: {unique_dir}")
        raise  # 重新拋出異常

# 每次調(diào)用都會創(chuàng)建新目錄
create_unique_workspace()

# ?? 有風(fēng)險的代碼
if not os.path.exists("my_dir"):
    os.makedirs("my_dir")  # 這里可能有其他進(jìn)程創(chuàng)建了目錄

# ? 安全的代碼
try:
    os.makedirs("my_dir", exist_ok=False)
except FileExistsError:
    # 目錄已經(jīng)被其他進(jìn)程創(chuàng)建了
    print("目錄已被其他進(jìn)程創(chuàng)建，繼續(xù)執(zhí)行")

def safe_makedirs(path, mode=0o755):
    """安全創(chuàng)建目錄并設(shè)置權(quán)限"""
    try:
        os.makedirs(path, mode=mode, exist_ok=True)
        
        # 確保權(quán)限正確（即使目錄已存在）
        os.chmod(path, mode)
        
    except PermissionError:
        print(f"權(quán)限不足，無法創(chuàng)建或修改: {path}")
        raise
    except Exception as e:
        print(f"創(chuàng)建目錄失敗: {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():
    """應(yīng)用初始化 - 可以安全地多次調(diào)用"""
    directories = ["config", "data", "logs", "tmp"]
    for dir_name in directories:
        os.makedirs(dir_name, exist_ok=True)
    
# 3. 臨時文件目錄
import tempfile
temp_dir = tempfile.mkdtemp()  # 已經(jīng)創(chuàng)建了
os.makedirs(temp_dir, exist_ok=True)  # 不會重復(fù)創(chuàng)建

# 1. 檢測目錄是否是新創(chuàng)建的
def setup_new_project(project_path):
    """設(shè)置新項目 - 要求目錄不存在"""
    try:
        os.makedirs(project_path, exist_ok=False)
        print(f"新項目目錄已創(chuàng)建: {project_path}")
    except FileExistsError:
        print(f"錯誤：項目目錄已存在: {project_path}")
        raise

# 2. 避免意外覆蓋
def create_backup_dir(date_str):
    """創(chuàng)建日期備份目錄 - 如果已存在說明有問題"""
    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):
    """
    確保目錄存在（如果不存在則創(chuàng)建）
    類似于 mkdir -p 但更加安全
    """
    try:
        os.makedirs(path, mode=mode, exist_ok=True)
        return True
    except OSError as e:
        # 處理可能的錯誤
        if e.errno != errno.EEXIST:  # 不是"已存在"的錯誤
            print(f"無法創(chuàng)建目錄 {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):
        """獲取或創(chuàng)建目錄"""
        path = os.path.join(self.base_dir, name)
        
        # 創(chuàng)建目錄（如果已存在也沒關(guān)系）
        os.makedirs(path, exist_ok=True)
        self.created_dirs.add(path)
        
        return path
    
    def cleanup(self):
        """清理所有創(chuàng)建的目錄"""
        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")  # 自動創(chuàng)建

import os

class AppDirectories:
    """應(yīng)用目錄結(jié)構(gòu)管理"""
    
    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:
                    # 強(qiáng)制模式：刪除后重新創(chuàng)建
                    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"? 創(chuàng)建目錄失敗 {name}: {e}")
                raise

# 使用
app_dirs = AppDirectories("myapp")
app_dirs.setup()  # 第一次運行：創(chuàng)建目錄
app_dirs.setup()  # 第二次運行：目錄已存在，安全跳過

在Python的shutil模塊中，有多個用于拷貝文件的函數(shù)，其中copy2是常用的一個。它的好處在于，它不僅拷貝文件的內(nèi)容，還會嘗試保留文件的元數(shù)據(jù)（如修改時間、訪問時間等）。下面我將詳細(xì)解釋copy2與其他拷貝函數(shù)的區(qū)別，以及為什么選擇copy2。

shutil模塊中與拷貝相關(guān)的函數(shù)主要有：

shutil.copy

shutil.copy2

shutil.copyfile

shutil.copyfileobj

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

功能：將文件從src復(fù)制到dst。如果dst是一個目錄，則文件將被復(fù)制到該目錄中，并保留原文件名。如果dst是一個文件，則將被覆蓋。

特點：它只拷貝文件內(nèi)容，并且不會保留文件的元數(shù)據(jù)（如時間戳）。在Unix系統(tǒng)上，它還會丟失文件的權(quán)限（因為默認(rèn)使用copy2，但注意：實際上copy在Unix上使用copy2，而在Windows上使用copyfile和copymode，但文檔說它不保留所有元數(shù)據(jù)，特別是時間戳）。

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

功能：與copy類似，但會嘗試保留文件的元數(shù)據(jù)，包括修改時間和訪問時間等。

特點：在Unix系統(tǒng)上，它使用os.utime來設(shè)置時間，并嘗試保留其他元數(shù)據(jù)（如權(quán)限）。在Windows上，它也會嘗試設(shè)置時間，但注意Windows上文件創(chuàng)建時間等可能不會被保留（實際上，copy2在Windows上使用copyfile和copystat，而copystat在Windows上會設(shè)置最后修改時間和最后訪問時間）。

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

功能：只拷貝文件內(nèi)容，不拷貝任何元數(shù)據(jù)。而且，dst必須是文件名，不能是目錄。

特點：這是最基礎(chǔ)的拷貝，只拷貝數(shù)據(jù)。

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

功能：在兩個文件對象之間拷貝數(shù)據(jù)。例如，可以用于拷貝已經(jīng)打開的文件。

為什么選擇copy2？
如果你希望保留文件的元數(shù)據(jù)（特別是修改時間），那么應(yīng)該使用copy2。例如，當(dāng)你備份文件時，保留原始文件的修改時間可能會很有用。

如果你只是需要拷貝文件內(nèi)容，不關(guān)心元數(shù)據(jù)，那么使用copy或copyfile也可以。

為什么不是copy1或copy3？
在shutil模塊中，并沒有copy1和copy3這兩個函數(shù)。只有copy和copy2，以及copyfile和copyfileobj。所以，copy2的命名是因為它比copy多了一個保留元數(shù)據(jù)的步驟（可以理解為copy的增強(qiáng)版），而copyfile是更基礎(chǔ)的版本。

總結(jié)
使用shutil.copy2的好處是：在拷貝文件時，會盡可能保留文件的元數(shù)據(jù)（如修改時間、訪問時間等）。

如果你不需要保留元數(shù)據(jù)，可以使用shutil.copy。

如果只需要拷貝數(shù)據(jù)，甚至不需要拷貝權(quán)限，可以使用shutil.copyfile。

根據(jù)你的需求選擇適當(dāng)?shù)目截惡瘮?shù)。如果你在備份或需要保持文件時間屬性的場景下，copy2是更好的選擇。