Python如何实现高效的文件/目录比较

import os
import filecmp
from pathlib import Path
 
def should_exclude(path: Path, exclude_patterns: list) -> bool:
    """判断路径是否匹配排除规则"""
    rel_path = str(path.relative_to(path.parent.parent))  # 获取相对于比较根目录的路径
    rel_path = rel_path.replace("\"android, "/")  # 统一路径分隔符
    
    # 目录规则末尾加/，文件规则用通配符
    for pattern in exclude_patterns:
        if pattern.endswith("/") and path.is_dir():
            normalized_pattern = pattern[:-1] + "/"  # 确保目录模式以/结尾
            if rel_path.startswith(normalized_pattern[:-1]) or pattern in rel_path:
                return True
        elif not pattern.endswith("/"):
            if fnmatch.fnmatch(rel_path, pattern):
                return True
    return False
 
def compare_directories(dir1, dir2, exclude_patterns=None):
    if exclude_patterns is None:
        exclude_patterns = []
    
    dcmp = filecmp.dircmp(dir1, dir2)
    
    # 过滤排除项
    left_only = [item for item in dcmp.left_only if not should_exclude(Path(dir1)/item, exclude_patterns)]
    right_only = [item for item in dcmp.right_only if not should_exclude(Path(dir2)/item, exclude_patterns)]
    diff_files = [item for item in dcmp.diff_files if not should_exclude(Path(dir1)/item, exclude_patterns)]
    
    # 递归处理子目录
    common_dirs = []
    for subdir in dcmp.common_dirs:
        sub_path1 = os.path.join(dir1, subdir)
        sub_path2 = os.path.join(dir2, subdir)
        if not should_exclude(Path(sub_path1), exclude_patterns):
            common_dirs.append(subdir)
    
    # 输出结果
    print("仅在左侧存在的文件:", left_only)
    print("仅在右侧存在的文件:", right_only)
    print("内容不同的文件:", diff_files)
    print("共同子目录:", common_dirs)
 
# 使用示例
exclude_rules = [
    "*.log",        # 排除所有log文件
    "__pycache__/", # 排除缓存目录
    "node_modules/" # 排除依赖目录
]
compare_directories("project_v1", "project_v2", exclude_rules)

import hashlib
import os
from pathlib import Path
 
def get_file_hash(file_path, chunk_size=8192):
    """分块计算文件哈希，避免内存溢出"""
    hash_func = hashlib.sha256()
    with open(file_path, 'rb') as f:
        while chunk := f.read(chunk_size):
            hash_func.update(chunk)
    return hash_func.hexdigest()
 
def compare_large_files(dir1, dir2, exclude_patterns):
    mismatches = []
    
    for root, _, files in os.walk(dir1):
        for file in files:
            path1 = Path(root)/file
            rel_path = path1.relative_to(dir1)
            path2 = Path(dir2)/rel_path
            
            # 检查排除规则
            if any(fnmatch.fnmatch(pythonstr(rel_path), pattern) for pattern in exclude_patterns):
                continue
                
            # 文件存在性检查
            if not path2.exists():
                mismatches.append(f"{rel_path} 仅存在于左侧")
                continue
                
            # 哈希比较
            if get_file_hash(path1) != get_file_hash(path2):
                mismatches.append(f"{rel_path} 内容不一致")
    
    # 检查右侧独有文件（简化示例，实际需双向检查）
    return mismatches
 
# 使用示例
exclude_rules = [
    "*.tmp",          # 临时文件
    "backup_2025*/"  # 特定备份目录
]
differences = compare_large_files("/backups/v1", "/backups/v2", exclude_rules)
for diff in differences:
    print(diff)

from pathlib import Path, PurePosixPath
import fnmatch
import platform
 
def is_windows():
    return platform.system() == "Windows"
 
def normalize_path(path: PChina编程ath) -> str:
    """统一转换为POSIX风格路径"""
    return str(path.relative_to(path.anchor)).replace("\", "/")
 
def case_insensitive_match(path_str: str, pattern: str) -> bool:
    """跨平台大小写不敏感匹配"""
    if is_windows():
        return fnmatch.fnmatch(path_str.lower(), pattern.lower())
    return fnmatch.fnmatch(path_str, pattern)
 
def compare_cross_platform(dir1, dir2, exclude_patterns):
    dcmp = filecmp.dircmp(dir1, dir2)
    
    # 过滤排除项（示例处理单个文件）
    filtered_diff = []
    for file in dcmp.diff_files:
        path1 = Path(dir1)/file
        path2 = Path(dir2)/file
        rel_path = normalize_path(path1)
        
        exclude = False
        for pattern in exclude_patterns:
            if pattern.endswith("/") and path1.is_dir():
                if rel_path.startswith(pattern[:-1]):
                    exclude = True
                    break
            elif case_insensitive_match(rel_path, pattern):
                exclude = True
                break
                
        if not exclude:
            filtered_diff.append(file)
    
    print("差异文件（已过滤）:", filtered_diff)
 
# 使用示例
exclude_rules = [
    ".DS_Store",      # MACOS隐藏文件
    "Thumbs.db",      # Windows隐藏文件
    "temp_*/"        # 临时目录
]
compare_cross_platform("C:/project", "/mnt/project", exclude_rules)

import difflib
from datetime import datetime
import os
from pathlib import Path
 
def generate_html_report(dir1, dir2, exclude_patterns):
    # 收集需要比较的文件
    file_pairs = []
    for root, _, files in os.walk(dir1):
        for file in files:
            path1 = Path(root)/file
            rel_path = path1.relative_to(dir1)
            path2 = Path(dir2)/rel_path
            
            # 检查排除规则
            exclude = False
            for pattern in exclude_patterns:
                if fnmatch.fnmatch(str(rel_path), pattern):
                    exclude = True
                    break
            
            if not exclude and path2.exists():
         编程China编程       # 读取文件内容（简化处理，实际需考虑大文件）
                with open(path1, 'r') as f1, open(path2, 'r') as f2:
                    lines1 = f1.readlines()
                    lines2 = f2.readlines()
                
                # 获取文件信息
                stat1 = os.stat(path1)
                stat2 = os.stat(path2)
                info = {
                    'path': str(rel_path),
                    'mtime1': datetime.fromtimestamp(stat1.st_mtime),
                    'mtime2': datetime.fromtimestamp(stat2.st_mtime),
                    'size1': stat1.st_size,
                    'size2': stat2.st_size
                }
                file_pairs.append((lines1, lines2, info))
    
    # 生成HTML报告
    html = """
    <html>
        <head><title>目录比较报告</title></head>
        <body>
            <h1>比较结果概览</h1>
            <table border="1">
                <tr><th>文件路径</th><th>左侧修改时间</th><th>右侧修改时间</th><th>大小差异</th></tr>
    """
    
    for lines1, lines2, info in file_pairs:
        diff = difflib.HtmlDiff().make_file(lines1, lines2, info['path'], info['path'])
        size_diff = info['size1'] - info['size2']
        html += f"""
            <tr>
                <td>{info['path']}</td>
                <td>{info['mtime1']}</td>
                <td>{info['mtime2']}</td>
                <td>{size_diff} bytes</td>
            </tr>
            <tr><td colspan="4">{diff}</td></tr>
        """
    
    html += """
        </body>
    </html>
"""
    
    with open("comparison_report.html", "w") as f:
        f.write(html)
 
# 使用示例
exclude_rules = ["*.tmp", "*.bak"]
generate_html_report("project_old", "project_new", exclude_rules)

# 错误方式（绝对路径匹配）
exclude_patterns = ["/home/user/project/*.log"]  
 
# 正确方式（相对路径匹配）
exclude_patterns = ["*.log"]  # 在比较函数中转换为相对路径

# 优化前：先扫描全部文件再过滤
all_files = os.listdir(dir1)
filtered = [f for f in all_files if not should_exclude(f)]
 
# 优化后：walk时即时过滤
for root, _, files in os.walk(dir1):
    for file in files:
        path = Path(root)/file
        if should_exclude(path):
            continue  # 跳过排除项，不进入处理流程

# 使用pathlib处理路径
path = Path("data") / "subdir" / "file.txt"  # 自动适配操作系统
 
# 替代错误的字符串拼接
# 错误方式：path = "data" + "\" + "subdir" + "\" + "file.txt"