import os

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

# 獲取路徑的各個(gè)組件
print("目錄名:", os.path.dirname(path))
print("文件名:", os.path.basename(path))
print("擴(kuò)展名:", 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("分割擴(kuò)展名:", 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"是絕對(duì)路徑: {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"最后修改時(shí)間: {os.path.getmtime(path) if os.path.exists(path) else 'N/A'}")
    
# 使用示例
analyze_path("/etc/passwd")

# 路徑規(guī)范化
print("規(guī)范化路徑:", os.path.normpath("/home//user/../docs/./file.txt"))

# 獲取絕對(duì)路徑
relative_path = "../docs/file.txt"
abs_path = os.path.abspath(relative_path)
print("絕對(duì)路徑:", abs_path)

# 獲取相對(duì)路徑
base_path = "/home/user"
target_path = "/home/user/docs/file.txt"
relative = os.path.relpath(target_path, base_path)
print("相對(duì)路徑:", relative)

from pathlib import Path

# 創(chuàng)建Path對(duì)象
p = Path('/home/user/docs/file.txt')

# 面向?qū)ο蟮牟僮鞣绞?
print("父目錄:", p.parent)
print("文件名:", p.name)
print(" stem:", p.stem)        # 不帶擴(kuò)展名的文件名
print("后綴:", p.suffix)
print("所有父目錄:", list(p.parents))

from pathlib import Path

# 多種創(chuàng)建Path對(duì)象的方式
home = Path.home()  # 用戶家目錄
cwd = Path.cwd()    # 當(dāng)前工作目錄

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

# 路徑組件訪問(wèn)
print("文件名:", config_file.name)
print("父目錄:", config_file.parent)
print("后綴:", config_file.suffix)
print("所有后綴:", config_file.suffixes)  # 對(duì)于.tar.gz這樣的多后綴文件

from pathlib import Path

# 創(chuàng)建測(cè)試文件
test_dir = Path('test_directory')
test_file = test_dir / 'test.txt'

# 創(chuàng)建目錄（包括父目錄）
test_dir.mkdir(parents=True, exist_ok=True)

# 寫(xiě)入文件
test_file.write_text('Hello, Pathlib!')

# 讀取文件
content = test_file.read_text()
print("文件內(nèi)容:", 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)

# 更復(fù)雜的匹配
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:
    """跨平臺(tái)路徑處理工具類"""
    
    @staticmethod
    def ensure_unix_path(path):
        """確保路徑使用Unix風(fēng)格分隔符"""
        if isinstance(path, Path):
            path = str(path)
        return path.replace('\\', '/')
    
    @staticmethod
    def ensure_native_path(path):
        """轉(zhuǎn)換為本地操作系統(tǒng)風(fēng)格的路徑"""
        if isinstance(path, Path):
            return path
        return Path(path)
    
    @staticmethod
    def is_hidden(path):
        """檢查路徑是否為隱藏文件/目錄（跨平臺(tái)）"""
        path = Path(path)
        name = path.name
        
        # Unix/Linux: 以點(diǎn)開(kāi)頭
        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風(fēng)格路徑:", 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):
        """獲取安全的絕對(duì)路徑，防止目錄遍歷攻擊"""
        try:
            # 解析用戶輸入的路徑
            requested_path = (self.base_dir / user_path).resolve()
            
            # 檢查是否在基目錄內(nèi)
            if not requested_path.is_relative_to(self.base_dir):
                raise SecurityError("路徑遍歷攻擊檢測(cè)")
                
            return requested_path
        except (ValueError, RuntimeError):
            raise SecurityError("無(wú)效的路徑")
            
    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):
        """確保目錄存在且具有適當(dāng)權(quán)限"""
        path = Path(path)
        path.mkdir(parents=True, exist_ok=True)
        
        # 設(shè)置安全權(quán)限（Unix系統(tǒng)）
        if hasattr(os, 'chmod'):
            os.chmod(path, 0o755)
            
        return path

class SecurityError(Exception):
    """安全相關(guān)異常"""
    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"安全錯(cuò)誤: {e}")

from pathlib import Path
import fnmatch
import re

class PathMatcher:
    """高級(jí)路徑匹配工具"""
    
    @staticmethod
    def match_patterns(path, patterns):
        """使用多種模式匹配路徑"""
        path_str = str(path)
        
        for pattern in patterns:
            # 通配符匹配
            if fnmatch.fnmatch(path_str, pattern):
                return True
                
            # 正則表達(dá)式匹配
            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文件，但排除測(cè)試文件和隱藏文件
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:
    """跨平臺(tái)配置文件管理"""
    
    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系統(tǒng)
            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
            # 如果沒(méi)有權(quán)限訪問(wèn)/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:
    """自動(dòng)文件整理工具"""
    
    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):
        """按文件擴(kuò)展名整理文件"""
        for file_path in self.source_dir.iterdir():
            if file_path.is_file():
                # 獲取文件擴(kuò)展名（不帶點(diǎn)）
                extension = file_path.suffix[1:].lower() if file_path.suffix else 'no_extension'
                
                # 創(chuàng)建目標(biāo)目錄
                target_dir = self.target_base_dir / extension
                target_dir.mkdir(parents=True, exist_ok=True)
                
                # 移動(dòng)文件
                target_file = target_dir / file_path.name
                shutil.move(str(file_path), str(target_file))
                print(f"移動(dòng): {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():
                # 獲取文件修改時(shí)間
                mtime = datetime.fromtimestamp(file_path.stat().st_mtime)
                
                # 創(chuàng)建日期目錄
                date_str = mtime.strftime(date_format)
                target_dir = self.target_base_dir / date_str
                target_dir.mkdir(parents=True, exist_ok=True)
                
                # 移動(dòng)文件
                target_file = target_dir / file_path.name
                shutil.move(str(file_path), str(target_file))
                print(f"移動(dòng): {file_path} -> {target_file}")
    
    def find_duplicates(self):
        """查找重復(fù)文件（基于文件名和大小）"""
        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"重復(fù)文件: {duplicate} (原始: {original})")

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

class UploadFileHandler:
    """Web應(yīng)用文件上傳處理"""
    
    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:]  # 去掉點(diǎn)號(hào)
        return extension in self.allowed_extensions
    
    def save_uploaded_file(self, file_stream, original_filename):
        """安全保存上傳的文件"""
        # 驗(yàn)證文件類型
        if not self.is_file_allowed(original_filename):
            raise ValueError("不允許的文件類型")
        
        # 生成安全文件名
        safe_filename = self.generate_unique_filename(original_filename)
        
        # 創(chuàng)建日期目錄結(jié)構(gòu)
        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:
            # 在實(shí)際應(yīng)用中，這里應(yīng)該有限流和大小檢查
            f.write(file_stream.read())
        
        # 計(jì)算文件哈希（用于后續(xù)驗(yàn)證）
        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'):
        """計(jì)算文件哈希值"""
        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):
        """生成文件訪問(wèn)URL"""
        # 將物理路徑轉(zhuǎn)換為Web可訪問(wèn)的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("文件訪問(wèn)URL:", upload_handler.get_file_url(file_info))

from pathlib import Path
import os

def efficient_path_operations():
    """高效的路徑操作示例"""
    
    # 1. 批量操作時(shí)緩存Path對(duì)象
    base_dir = Path('/path/to/base')
    files = list(base_dir.rglob('*.txt'))  # 預(yù)先獲取文件列表
    
    # 2. 使用生成器處理大量文件
    def process_files_generator(directory):
        for file_path in Path(directory).rglob('*'):
            if file_path.is_file():
                yield file_path
    
    # 3. 減少stat調(diào)用（昂貴的系統(tǒng)調(diào)用）
    file_paths = [p for p in Path('.').rglob('*') if p.is_file()]
    
    # 4. 使用os.scandir()進(jìn)行高性能目錄遍歷（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)} 個(gè)文件")

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):
        """執(zhí)行安全的文件操作"""
        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"權(quán)限錯(cuò)誤: {e}")
            raise
        except OSError as e:
            self.logger.error(f"系統(tǒng)錯(cuò)誤: {e}")
            raise
        except Exception as e:
            self.logger.error(f"未知錯(cuò)誤: {e}")
            raise
    
    def create_directory_structure(self, base_path, structure_dict):
        """創(chuàng)建復(fù)雜的目錄結(jié)構(gòu)"""
        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()

# 定義目錄結(jié)構(gòu)
project_structure = {
    'src': {
        'main.py': 'print("Hello World")',
        'utils': {
            'helpers.py': '# Utility functions'
        }
    },
    'tests': {
        'test_main.py': '# Test cases'
    },
    'docs': {}
}

# 創(chuàng)建項(xiàng)目結(jié)構(gòu)
handler.create_directory_structure('/tmp/my_project', project_structure)