从os.path到pathlib解析Python路径处理的高级应用

import os

# 基本路径操作示例
path = "/home/user/documents/file.txt"

# 获取路径的各个组件
print("目录名:", os.path.dirname(path))
print("文件名:", os.path.basename(path))
print("扩展名:", os.path.splitext(path)[1])

# 路径拼接
new_path = os.path.join("/home/user", "documents", "new_file.txt")
print("拼接后的路径:", new_path)

import os

path = "/home/user/docs/report.pdf"

# 提取不同组件
print("目录部分:", os.path.dirname(path))      # /home/user/docs
print("文件名部分:", os.path.basename(path))   # report.pdf
print("分割路径:", os.path.split(path))        # ('/home/user/docs', 'report.pdf')
print("分割扩展名:", os.path.splitext(path))   # ('/home/user/docs/report', '.pdf')

def analyze_path(path):
    """全面分析路径属性"""
    print(f"路径: {path}")
    print(f"是否存在: {os.path.exists(path)}")
    print(f"是文件: {os.path.isfile(path)}")
    print(f"是目录: {os.path.isdir(path)}")
    print(f"是绝对路径: {os.path.isabs(path)}")
    print(f"是链接: {os.path.islink(path)}")
    print(f"文件大小: {os.path.getsize(path) if os.path.exists(path) else 'N/A'} bytes")
    print(f"最后修改时间: {os.path.getmtime(path) if os.path.exists(path) else 'N/A'}")
    
# 使用示例
analyze_path("/etc/passwd")

# 路径规范化
print("规范化路径:", os.path.normpath("/home//user/../docs/./file.txt"))

# 获取绝对路径
relative_path = "../docs/file.txt"
abs_path = os.path.abspath(relative_path)
print("绝对路径:", abs_path)

# 获取相对路径
base_path = "/home/user"
target_path = "/home/user/docs/file.txt"
relative = os.path.relpath(target_path, base_path)
print("相对路径:", relative)

from pathlib import Path

# 创建Path对象
p = Path('/home/user/docs/file.txt')

# 面向对象的操作方式
print("父目录:", p.parent)
print("文件名:", p.name)
print(" stem:", p.stem)        # 不带扩展名的文件名
print("后缀:", p.suffix)
print("所有父目录:", list(p.parents))

from pathlib import Path

# 多种创建Path对象的方式
home = Path.home()  # 用户家目录
cwd = Path.cwd()    # 当前工作目录

# 路径拼接
config_file = home / '.config' / 'app' / 'config.ini'
print("配置文件路径:", config_file)

# 路径组件访问
print("文件名:", config_file.name)
print("父目录:", config_file.parent)
print("后缀:", config_file.suffix)
print("所有后缀:", config_file.suffixes)  # 对于.tar.gz这样的多后缀文件

from pathlib import Path

# 创建测试文件
test_dir = Path('test_directory')
test_file = test_dir / 'test.txt'

# 创建目录（包括父目录）
test_dir.mkdir(parents=True, exist_ok=True)

# 写入文件
test_file.write_text('Hello, Pathlib!')

# 读取文件
content = test_file.read_text()
print("文件内容:", content)

# 文件信息
print("文件大小:", test_file.stat().st_size)
print("是否是文件:", test_file.is_file())
print("是否是目录:", test_dir.is_dir())

# 清理
test_file.unlink()
test_dir.rmdir()

from pathlib import Path
import re

# 遍历目录
def find_files(pattern, directory='.'):
    """查找匹配模式的文件"""
    path = Path(directory)
    return list(path.rglob(pattern))

# 使用示例
python_files = find_files('*.py')
print("Python文件:", python_files)

# 更复杂的匹配
def find_large_python_files(min_size=1024):
    """查找大于指定大小的Python文件"""
    path = Path('.')
    for file_path in path.rglob('*.py'):
        if file_path.stat().st_size > min_size:
            yield file_path

# 使用生成器
for large_file in find_large_python_files(2048):
    print(f"大文件: {large_file} ({large_file.stat().st_size} bytes)")

import os
from pathlib import Path

class CrossPlatformPath:
    """跨平台路径处理工具类"""
    
    @staticmethod
    def ensure_unix_path(path):
        """确保路径使用Unix风格分隔符"""
        if isinstance(path, Path):
            path = str(path)
        return path.replace('\\', '/')
    
    @staticmethod
    def ensure_native_path(path):
        """转换为本地操作系统风格的路径"""
        if isinstance(path, Path):
            return path
        return Path(path)
    
    @staticmethod
    def is_hidden(path):
        """检查路径是否为隐藏文件/目录（跨平台）"""
        path = Path(path)
        name = path.name
        
        # Unix/Linux: 以点开头
        if name.startswith('.'):
            return True
            
        # Windows: 检查隐藏属性
        if os.name == 'nt' and hasattr(path, 'stat'):
            try:
                import stat
                return bool(path.stat().st_file_attributes & stat.FILE_ATTRIBUTE_HIDDEN)
            except (OSError, AttributeError):
                pass
                
        return False

# 使用示例
path = "C:\\Users\\Admin\\.config"
unix_style = CrossPlatformPath.ensure_unix_path(path)
print("Unix风格路径:", unix_style)
print("是隐藏路径:", CrossPlatformPath.is_hidden(path))

from pathlib import Path
import os

class SafePathHandler:
    """安全路径处理工具"""
    
    def __init__(self, base_directory):
        self.base_dir = Path(base_directory).resolve()
        
    def get_safe_path(self, user_path):
        """获取安全的绝对路径，防止目录遍历攻击"""
        try:
            # 解析用户输入的路径
            requested_path = (self.base_dir / user_path).resolve()
            
            # 检查是否在基目录内
            if not requested_path.is_relative_to(self.base_dir):
                raise SecurityError("路径遍历攻击检测")
                
            return requested_path
        except (ValueError, RuntimeError):
            raise SecurityError("无效的路径")
            
    def read_file_safely(self, user_path):
        """安全地读取文件"""
        safe_path = self.get_safe_path(user_path)
        
        if not safe_path.is_file():
            raise FileNotFoundError("文件不存在")
            
        return safe_path.read_text()
    
    def ensure_directory(self, path):
        """确保目录存在且具有适当权限"""
        path = Path(path)
        path.mkdir(parents=True, exist_ok=True)
        
        # 设置安全权限（Unix系统）
        if hasattr(os, 'chmod'):
            os.chmod(path, 0o755)
            
        return path

class SecurityError(Exception):
    """安全相关异常"""
    pass

# 使用示例
handler = SafePathHandler('/var/www/uploads')
try:
    safe_path = handler.get_safe_path('user123/document.pdf')
    content = handler.read_file_safely('user123/document.pdf')
except SecurityError as e:
    print(f"安全错误: {e}")

from pathlib import Path
import fnmatch
import re

class PathMatcher:
    """高级路径匹配工具"""
    
    @staticmethod
    def match_patterns(path, patterns):
        """使用多种模式匹配路径"""
        path_str = str(path)
        
        for pattern in patterns:
            # 通配符匹配
            if fnmatch.fnmatch(path_str, pattern):
                return True
                
            # 正则表达式匹配
            if pattern.startswith('regex:'):
                regex_pattern = pattern[6:]
                if re.search(regex_pattern, path_str):
                    return True
                    
        return False
    
    @staticmethod
    def find_matching_files(directory, include_patterns=None, exclude_patterns=None):
        """查找匹配特定模式的文件"""
        directory = Path(directory)
        include_patterns = include_patterns or ['*']
        exclude_patterns = exclude_patterns or []
        
        for file_path in directory.rglob('*'):
            if file_path.is_file():
                # 检查排除模式
                if exclude_patterns and PathMatcher.match_patterns(file_path, exclude_patterns):
                    continue
                    
                # 检查包含模式
                if PathMatcher.match_patterns(file_path, include_patterns):
                    yield file_path

# 使用示例
matcher = PathMatcher()

# 查找所有Python文件，但排除测试文件和隐藏文件
python_files = matcher.find_matching_files(
    '.',
    include_patterns=['*.py'],
    exclude_patterns=['*test*', '*__pycache__*', 'regex:^\..*']
)

for file in python_files:
    print(f"找到Python文件: {file}")

from pathlib import Path
import platform
import appdirs

class ConfigManager:
    """跨平台配置文件管理"""
    
    def __init__(self, app_name):
        self.app_name = app_name
        self.system = platform.system()
        
    def get_config_path(self):
        """获取配置文件路径"""
        if self.system == "Windows":
            base_dir = Path(os.environ.get('APPDATA', Path.home()))
            return base_dir / self.app_name / 'config.ini'
        else:
            # Unix-like系统
            config_dir = Path.home() / '.config' / self.app_name
            config_dir.mkdir(parents=True, exist_ok=True)
            return config_dir / 'config.ini'
    
    def get_cache_path(self):
        """获取缓存目录"""
        if hasattr(appdirs, 'user_cache_dir'):
            cache_dir = Path(appdirs.user_cache_dir(self.app_name))
        else:
            if self.system == "Windows":
                cache_dir = Path(os.environ.get('LOCALAPPDATA', Path.home())) / 'Cache' / self.app_name
            else:
                cache_dir = Path.home() / '.cache' / self.app_name
                
        cache_dir.mkdir(parents=True, exist_ok=True)
        return cache_dir
    
    def get_log_path(self):
        """获取日志文件路径"""
        if self.system == "Windows":
            log_dir = Path(os.environ.get('LOCALAPPDATA', Path.home())) / 'Logs' / self.app_name
        else:
            log_dir = Path('/var/log') / self.app_name
            # 如果没有权限访问/var/log，则使用用户目录
            if not log_dir.exists() and not os.access(log_dir.parent, os.W_OK):
                log_dir = Path.home() / '.local' / 'log' / self.app_name
                
        log_dir.mkdir(parents=True, exist_ok=True)
        return log_dir / f"{self.app_name}.log"

# 使用示例
config_mgr = ConfigManager('my_app')
print("配置文件:", config_mgr.get_config_path())
print("缓存目录:", config_mgr.get_cache_path())
print("日志文件:", config_mgr.get_log_path())

from pathlib import Path
import shutil
from datetime import datetime

class FileOrganizer:
    """自动文件整理工具"""
    
    def __init__(self, source_dir, target_base_dir):
        self.source_dir = Path(source_dir)
        self.target_base_dir = Path(target_base_dir)
        
    def organize_by_extension(self):
        """按文件扩展名整理文件"""
        for file_path in self.source_dir.iterdir():
            if file_path.is_file():
                # 获取文件扩展名（不带点）
                extension = file_path.suffix[1:].lower() if file_path.suffix else 'no_extension'
                
                # 创建目标目录
                target_dir = self.target_base_dir / extension
                target_dir.mkdir(parents=True, exist_ok=True)
                
                # 移动文件
                target_file = target_dir / file_path.name
                shutil.move(str(file_path), str(target_file))
                print(f"移动: {file_path} -> {target_file}")
    
    def organize_by_date(self, date_format="%Y-%m"):
        """按日期整理文件"""
        for file_path in self.source_dir.rglob('*'):
            if file_path.is_file():
                # 获取文件修改时间
                mtime = datetime.fromtimestamp(file_path.stat().st_mtime)
                
                # 创建日期目录
                date_str = mtime.strftime(date_format)
                target_dir = self.target_base_dir / date_str
                target_dir.mkdir(parents=True, exist_ok=True)
                
                # 移动文件
                target_file = target_dir / file_path.name
                shutil.move(str(file_path), str(target_file))
                print(f"移动: {file_path} -> {target_file}")
    
    def find_duplicates(self):
        """查找重复文件（基于文件名和大小）"""
        seen_files = {}
        duplicates = []
        
        for file_path in self.source_dir.rglob('*'):
            if file_path.is_file():
                file_key = (file_path.name, file_path.stat().st_size)
                
                if file_key in seen_files:
                    duplicates.append((seen_files[file_key], file_path))
                else:
                    seen_files[file_key] = file_path
                    
        return duplicates

# 使用示例
organizer = FileOrganizer('/path/to/source', '/path/to/organized')
organizer.organize_by_extension()

duplicates = organizer.find_duplicates()
for original, duplicate in duplicates:
    print(f"重复文件: {duplicate} (原始: {original})")

from pathlib import Path
import uuid
import hashlib
from datetime import datetime

class UploadFileHandler:
    """Web应用文件上传处理"""
    
    def __init__(self, upload_base_dir, allowed_extensions=None, max_file_size=10 * 1024 * 1024):
        self.upload_base_dir = Path(upload_base_dir)
        self.allowed_extensions = allowed_extensions or {'jpg', 'jpeg', 'png', 'gif', 'pdf'}
        self.max_file_size = max_file_size
        
    def generate_unique_filename(self, original_filename):
        """生成唯一文件名"""
        extension = Path(original_filename).suffix.lower()
        unique_id = uuid.uuid4().hex
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        return f"{timestamp}_{unique_id}{extension}"
    
    def is_file_allowed(self, filename):
        """检查文件类型是否允许"""
        extension = Path(filename).suffix.lower()[1:]  # 去掉点号
        return extension in self.allowed_extensions
    
    def save_uploaded_file(self, file_stream, original_filename):
        """安全保存上传的文件"""
        # 验证文件类型
        if not self.is_file_allowed(original_filename):
            raise ValueError("不允许的文件类型")
        
        # 生成安全文件名
        safe_filename = self.generate_unique_filename(original_filename)
        
        # 创建日期目录结构
        today = datetime.now()
        year_month_dir = self.upload_base_dir / today.strftime("%Y/%m")
        year_month_dir.mkdir(parents=True, exist_ok=True)
        
        # 完整文件路径
        file_path = year_month_dir / safe_filename
        
        # 保存文件
        with open(file_path, 'wb') as f:
            # 在实际应用中，这里应该有限流和大小检查
            f.write(file_stream.read())
        
        # 计算文件哈希（用于后续验证）
        file_hash = self.calculate_file_hash(file_path)
        
        return {
            'original_name': original_filename,
            'saved_path': file_path,
            'file_size': file_path.stat().st_size,
            'file_hash': file_hash,
            'upload_time': datetime.now()
        }
    
    def calculate_file_hash(self, file_path, algorithm='sha256'):
        """计算文件哈希值"""
        hash_func = hashlib.new(algorithm)
        with open(file_path, 'rb') as f:
            for chunk in iter(lambda: f.read(4096), b''):
                hash_func.update(chunk)
        return hash_func.hexdigest()
    
    def get_file_url(self, saved_file_info):
        """生成文件访问URL"""
        # 将物理路径转换为Web可访问的URL路径
        relative_path = saved_file_info['saved_path'].relative_to(self.upload_base_dir)
        return f"/uploads/{relative_path}"

# 使用示例
upload_handler = UploadFileHandler('/var/www/uploads')

# 模拟文件上传
class MockFile:
    def __init__(self, content, filename):
        self.content = content
        self.filename = filename
    
    def read(self):
        return self.content

mock_file = MockFile(b'test content', 'test.txt')
file_info = upload_handler.save_uploaded_file(mock_file, 'test.txt')
print("文件保存信息:", file_info)
print("文件访问URL:", upload_handler.get_file_url(file_info))

from pathlib import Path
import os

def efficient_path_operations():
    """高效的路径操作示例"""
    
    # 1. 批量操作时缓存Path对象
    base_dir = Path('/path/to/base')
    files = list(base_dir.rglob('*.txt'))  # 预先获取文件列表
    
    # 2. 使用生成器处理大量文件
    def process_files_generator(directory):
        for file_path in Path(directory).rglob('*'):
            if file_path.is_file():
                yield file_path
    
    # 3. 减少stat调用（昂贵的系统调用）
    file_paths = [p for p in Path('.').rglob('*') if p.is_file()]
    
    # 4. 使用os.scandir()进行高性能目录遍历（Python 3.5+）
    def fast_directory_walk(directory):
        with os.scandir(directory) as entries:
            for entry in entries:
                if entry.is_file():
                    yield entry.path
                elif entry.is_dir():
                    yield from fast_directory_walk(entry.path)
    
    return files

# 使用示例
files = efficient_path_operations()
print(f"找到 {len(files)} 个文件")

from pathlib import Path
import logging
import sys

# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

class RobustPathHandler:
    """健壮的路径处理工具"""
    
    def __init__(self):
        self.logger = logging.getLogger(__name__)
    
    def safe_file_operation(self, operation_func, *args, **kwargs):
        """执行安全的文件操作"""
        try:
            result = operation_func(*args, **kwargs)
            self.logger.info(f"操作成功: {operation_func.__name__}")
            return result
        except FileNotFoundError as e:
            self.logger.error(f"文件未找到: {e}")
            raise
        except PermissionError as e:
            self.logger.error(f"权限错误: {e}")
            raise
        except OSError as e:
            self.logger.error(f"系统错误: {e}")
            raise
        except Exception as e:
            self.logger.error(f"未知错误: {e}")
            raise
    
    def create_directory_structure(self, base_path, structure_dict):
        """创建复杂的目录结构"""
        base_path = Path(base_path)
        
        for name, content in structure_dict.items():
            current_path = base_path / name
            
            if isinstance(content, dict):
                # 如果是目录
                current_path.mkdir(parents=True, exist_ok=True)
                self.create_directory_structure(current_path, content)
            else:
                # 如果是文件
                self.safe_file_operation(
                    current_path.write_text, 
                    content if isinstance(content, str) else str(content)
                )

# 使用示例
handler = RobustPathHandler()

# 定义目录结构
project_structure = {
    'src': {
        'main.py': 'print("Hello World")',
        'utils': {
            'helpers.py': '# Utility functions'
        }
    },
    'tests': {
        'test_main.py': '# Test cases'
    },
    'docs': {}
}

# 创建项目结构
handler.create_directory_structure('/tmp/my_project', project_structure)