# 錯(cuò)誤示例：假設(shè)你想讀取同目錄下的data.txt
with open('data.txt', 'r') as f:
    content = f.read()

# 當(dāng)你從不同目錄運(yùn)行腳本時(shí)，可能會(huì)出現(xiàn)：
# FileNotFoundError: [Errno 2] No such file or directory: 'data.txt'

# 方案1_complete.py
import os
import sys

def get_script_directory():
    """
    獲取當(dāng)前腳本所在的絕對路徑
    這是解決路徑問題的核心函數(shù)
    
    Returns:
        str: 腳本所在目錄的絕對路徑
    """
    # 使用__file__獲取當(dāng)前腳本的相對路徑
    script_path = os.path.abspath(__file__)
    # 獲取腳本所在目錄
    script_dir = os.path.dirname(script_path)
    return script_dir

def save_to_script_dir_os():
    """
    將工作目錄設(shè)置為腳本所在目錄，然后進(jìn)行文件操作
    這種方法會(huì)改變?nèi)譅顟B(tài)，適合獨(dú)立腳本
    """
    # 獲取腳本目錄
    script_dir = get_script_directory()
    
    # 保存原始工作目錄，以便后續(xù)恢復(fù)（如果需要）
    original_cwd = os.getcwd()
    
    try:
        # 將工作目錄切換到腳本目錄
        os.chdir(script_dir)
        print(f"? 工作目錄已切換到: {script_dir}")
        
        # 現(xiàn)在可以安全地使用相對路徑
        data = "這是使用os模塊保存的數(shù)據(jù)\n時(shí)間戳: 2026-01-15 10:30:00"
        
        with open('output_os.txt', 'w', encoding='utf-8') as f:
            f.write(data)
        print(f"? 文件已保存: output_os.txt")
        
        # 讀取驗(yàn)證
        with open('output_os.txt', 'r', encoding='utf-8') as f:
            content = f.read()
        print(f"?? 文件內(nèi)容:\n{content}")
        
    finally:
        # 恢復(fù)原始工作目錄（可選，根據(jù)需求決定）
        os.chdir(original_cwd)
        print(f"?? 工作目錄已恢復(fù): {original_cwd}")

def read_relative_with_fullpath():
    """
    不改變工作目錄，使用完整路徑進(jìn)行文件操作
    這是更安全的方法，不會(huì)產(chǎn)生副作用
    """
    # 獲取腳本目錄
    script_dir = get_script_directory()
    
    # 構(gòu)建完整路徑
    file_path = os.path.join(script_dir, 'data', 'sample.txt')
    
    # 如果目錄不存在，創(chuàng)建它
    data_dir = os.path.join(script_dir, 'data')
    if not os.path.exists(data_dir):
        os.makedirs(data_dir)
        print(f"?? 創(chuàng)建目錄: {data_dir}")
    
    # 寫入文件
    with open(file_path, 'w', encoding='utf-8') as f:
        f.write("使用完整路徑寫入的數(shù)據(jù)")
    
    print(f"? 文件已保存: {file_path}")
    
    # 讀取文件
    with open(file_path, 'r', encoding='utf-8') as f:
        content = f.read()
    
    print(f"?? 讀取到: {content}")
    
    return content

if __name__ == "__main__":
    print("=" * 60)
    print("方案一：使用os模塊處理路徑")
    print("=" * 60)
    
    # 方法1：改變工作目錄
    save_to_script_dir_os()
    
    print("\n" + "-" * 60)
    
    # 方法2：使用完整路徑（推薦）
    read_relative_with_fullpath()
    
    print("\n?? 關(guān)鍵要點(diǎn):")
    print("1. os.path.abspath(__file__) 獲取腳本絕對路徑")
    print("2. os.path.dirname() 獲取目錄部分")
    print("3. os.chdir() 改變工作目錄（有副作用）")
    print("4. os.path.join() 安全地拼接路徑")

# 方案2_complete.py
from pathlib import Path
import json
from datetime import datetime

class PathManager:
    """
    使用pathlib管理路徑的高級類
    提供安全的文件操作接口
    """
    def __init__(self):
        # 獲取腳本所在目錄的Path對象
        self.script_dir = Path(__file__).resolve().parent
        self._init_directories()
    
    def _init_directories(self):
        """初始化常用的子目錄結(jié)構(gòu)"""
        # 定義項(xiàng)目目錄結(jié)構(gòu)
        self.dirs = {
            'data': self.script_dir / 'data',
            'logs': self.script_dir / 'logs',
            'output': self.script_dir / 'output',
            'config': self.script_dir / 'config'
        }
        
        # 創(chuàng)建目錄（如果不存在）
        for name, path in self.dirs.items():
            path.mkdir(exist_ok=True)
            print(f"?? 確保目錄存在: {path}")
    
    def get_path(self, filename, category='data'):
        """
        獲取指定類別下的文件完整路徑
        
        Args:
            filename: 文件名
            category: 文件類別（data/logs/output/config）
            
        Returns:
            Path: 完整路徑對象
        """
        if category not in self.dirs:
            raise ValueError(f"無效的類別: {category}")
        
        return self.dirs[category] / filename
    
    def save_json(self, data, filename):
        """
        保存JSON數(shù)據(jù)到data目錄
        
        Args:
            data: 要保存的數(shù)據(jù)（可JSON序列化）
            filename: 文件名
            
        Returns:
            Path: 保存的文件路徑
        """
        filepath = self.get_path(filename, 'data')
        
        # 確保文件擴(kuò)展名正確
        if not filename.endswith('.json'):
            filepath = filepath.with_suffix('.json')
        
        # 寫入JSON數(shù)據(jù)
        with open(filepath, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
        
        print(f"? JSON已保存: {filepath}")
        return filepath
    
    def load_json(self, filename):
        """
        從data目錄加載JSON數(shù)據(jù)
        
        Args:
            filename: 文件名
            
        Returns:
            dict/list: 加載的數(shù)據(jù)
        """
        filepath = self.get_path(filename, 'data')
        
        # 如果沒有.json后綴，添加它
        if not filename.endswith('.json'):
            filepath = filepath.with_suffix('.json')
        
        with open(filepath, 'r', encoding='utf-8') as f:
            data = json.load(f)
        
        print(f"?? JSON已加載: {filepath}")
        return data
    
    def log(self, message, level="INFO"):
        """
        記錄日志到logs目錄
        
        Args:
            message: 日志消息
            level: 日志級別
        """
        # 按日期創(chuàng)建日志文件
        today = datetime.now().strftime('%Y%m%d')
        log_file = self.dirs['logs'] / f"app_{today}.log"
        
        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        log_entry = f"[{timestamp}] [{level}] {message}\n"
        
        # 追加寫入日志
        with open(log_file, 'a', encoding='utf-8') as f:
            f.write(log_entry)
        
        print(f"?? 日志記錄: {log_entry.strip()}")
    
    def find_files(self, pattern="*", category='data'):
        """
        查找指定模式的文件
        
        Args:
            pattern: 文件匹配模式（如*.txt, *.json）
            category: 目錄類別
            
        Returns:
            list: 找到的文件路徑列表
        """
        directory = self.dirs[category]
        files = list(directory.glob(pattern))
        
        print(f"?? 在{category}目錄找到{len(files)}個(gè){pattern}文件")
        return files

def demonstrate_path_operations():
    """
    演示pathlib的各種強(qiáng)大功能
    """
    # 創(chuàng)建路徑管理器
    pm = PathManager()
    
    # 1. 保存和加載JSON數(shù)據(jù)
    sample_data = {
        "project": "Python路徑管理",
        "author": "開發(fā)者",
        "version": "1.0.0",
        "features": ["路徑安全", "自動(dòng)目錄創(chuàng)建", "日志記錄"],
        "config": {
            "auto_create_dirs": True,
            "default_encoding": "utf-8"
        }
    }
    
    # 保存JSON
    json_path = pm.save_json(sample_data, "config")
    print(f"保存路徑: {json_path}")
    
    # 加載JSON
    loaded_data = pm.load_json("config.json")
    print(f"加載的數(shù)據(jù): {loaded_data['project']}")
    
    # 2. 記錄日志
    pm.log("程序開始運(yùn)行")
    pm.log("數(shù)據(jù)保存完成", "SUCCESS")
    
    # 3. 查找文件
    # 先創(chuàng)建一些測試文件
    test_files = ['test1.txt', 'test2.txt', 'data.csv']
    for file in test_files:
        (pm.dirs['data'] / file).write_text(f"這是{file}的內(nèi)容")
    
    # 查找所有txt文件
    txt_files = pm.find_files("*.txt", 'data')
    for file in txt_files:
        print(f"找到文件: {file.name} (大小: {file.stat().st_size}字節(jié))")
    
    # 4. 路徑操作演示
    print("\n?? Pathlib路徑操作演示:")
    current_file = Path(__file__)
    print(f"當(dāng)前文件: {current_file}")
    print(f"父目錄: {current_file.parent}")
    print(f"文件名: {current_file.name}")
    print(f"后綴: {current_file.suffix}")
    print(f"無后綴名: {current_file.stem}")
    
    # 5. 安全路徑拼接
    new_path = pm.script_dir / 'data' / 'deep' / 'nested' / 'file.txt'
    print(f"\n目標(biāo)路徑: {new_path}")
    
    # 自動(dòng)創(chuàng)建多級目錄
    new_path.parent.mkdir(parents=True, exist_ok=True)
    new_path.write_text("深度嵌套文件的內(nèi)容")
    print(f"? 已創(chuàng)建深度嵌套文件")

if __name__ == "__main__":
    print("=" * 60)
    print("方案二：使用pathlib的現(xiàn)代化路徑管理")
    print("=" * 60)
    
    demonstrate_path_operations()
    
    print("\n?? pathlib核心優(yōu)勢:")
    print("1. 面向?qū)ο?，代碼更直觀")
    print("2. 自動(dòng)處理路徑分隔符（/ 運(yùn)算符重載）")
    print("3. 鏈?zhǔn)秸{(diào)用，代碼更簡潔")
    print("4. 跨平臺(tái)兼容性更好")

# 方案3_complete.py
import os
import sys
from contextlib import contextmanager
from pathlib import Path
import tempfile

@contextmanager
def working_directory(path):
    """
    上下文管理器：臨時(shí)切換工作目錄
    
    Args:
        path: 目標(biāo)目錄路徑（字符串或Path對象）
        
    使用示例:
        with working_directory("/tmp"):
            # 在這個(gè)塊內(nèi)，工作目錄是/tmp
            open("tempfile.txt", "w").write("test")
        # 離開塊后，工作目錄自動(dòng)恢復(fù)
    """
    # 轉(zhuǎn)換為字符串路徑
    if isinstance(path, Path):
        path = str(path)
    
    # 保存原始工作目錄
    original_cwd = os.getcwd()
    
    try:
        # 切換到目標(biāo)目錄
        os.chdir(path)
        print(f"?? 進(jìn)入目錄: {path}")
        yield path  # 這里交出控制權(quán)
    except FileNotFoundError:
        print(f"? 目錄不存在: {path}")
        # 創(chuàng)建目錄后重試
        os.makedirs(path, exist_ok=True)
        os.chdir(path)
        print(f"?? 創(chuàng)建并進(jìn)入目錄: {path}")
        yield path
    finally:
        # 無論是否發(fā)生異常，都恢復(fù)原始目錄
        os.chdir(original_cwd)
        print(f"?? 返回目錄: {original_cwd}")

@contextmanager
def script_directory():
    """
    臨時(shí)切換到腳本所在目錄的上下文管理器
    這是最常用的場景
    """
    # 獲取腳本目錄
    script_dir = os.path.dirname(os.path.abspath(__file__))
    
    with working_directory(script_dir) as dir_path:
        yield dir_path

class ProjectEnvironment:
    """
    項(xiàng)目環(huán)境管理器
    管理整個(gè)項(xiàng)目的路徑環(huán)境
    """
    def __init__(self, base_dir=None):
        """
        初始化項(xiàng)目環(huán)境
        
        Args:
            base_dir: 項(xiàng)目根目錄，None表示使用腳本目錄
        """
        if base_dir is None:
            self.base_dir = Path(__file__).resolve().parent
        else:
            self.base_dir = Path(base_dir).resolve()
        
        # 項(xiàng)目目錄結(jié)構(gòu)
        self.dirs = {
            'src': self.base_dir / 'src',
            'tests': self.base_dir / 'tests',
            'docs': self.base_dir / 'docs',
            'data': self.base_dir / 'data',
            'logs': self.base_dir / 'logs',
            'output': self.base_dir / 'output'
        }
        
    def __enter__(self):
        """進(jìn)入項(xiàng)目環(huán)境"""
        # 確保所有目錄存在
        for dir_path in self.dirs.values():
            dir_path.mkdir(parents=True, exist_ok=True)
        
        # 保存原始目錄
        self.original_cwd = Path.cwd()
        
        # 切換到項(xiàng)目根目錄
        os.chdir(self.base_dir)
        print(f"?? 進(jìn)入項(xiàng)目環(huán)境: {self.base_dir}")
        
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        """退出項(xiàng)目環(huán)境"""
        # 切換回原始目錄
        os.chdir(self.original_cwd)
        print(f"?? 退出項(xiàng)目環(huán)境，返回: {self.original_cwd}")
        
        # 如果有異常，可以選擇處理或重新拋出
        if exc_type is not None:
            print(f"?? 在項(xiàng)目環(huán)境中發(fā)生異常: {exc_type.__name__}: {exc_val}")
        
        # 返回False會(huì)重新拋出異常，True會(huì)吞掉異常
        return False
    
    def get_path(self, *parts, relative_to='base'):
        """
        獲取項(xiàng)目內(nèi)的路徑
        
        Args:
            *parts: 路徑部分
            relative_to: 相對于哪個(gè)目錄（base/src/tests等）
            
        Returns:
            Path: 完整路徑
        """
        if relative_to == 'base':
            base = self.base_dir
        else:
            base = self.dirs.get(relative_to, self.base_dir)
        
        return base.joinpath(*parts)
    
    def create_project_structure(self):
        """創(chuàng)建項(xiàng)目基本結(jié)構(gòu)"""
        structure = {
            'src': ['__init__.py', 'main.py', 'utils.py'],
            'tests': ['__init__.py', 'test_main.py', 'test_utils.py'],
            'docs': ['README.md', 'API.md'],
            'data': ['.gitkeep'],  # 占位文件，確保目錄被git跟蹤
            'logs': ['.gitkeep'],
            'output': ['.gitkeep']
        }
        
        for dir_name, files in structure.items():
            dir_path = self.dirs[dir_name]
            for file in files:
                file_path = dir_path / file
                if not file_path.exists():
                    if file == '.gitkeep':
                        file_path.write_text('')
                    elif file.endswith('.py'):
                        file_path.write_text(f'# {file} - 項(xiàng)目{dir_name}目錄\n\n')
                    elif file.endswith('.md'):
                        file_path.write_text(f'# {file}\n\n項(xiàng)目文檔\n')
        
        print("?? 項(xiàng)目結(jié)構(gòu)創(chuàng)建完成")

def demonstrate_context_managers():
    """演示上下文管理器的使用"""
    
    print("1. 基本上下文管理器演示:")
    print("-" * 40)
    
    # 演示臨時(shí)目錄切換 - 兼容Windows和Linux
    original_dir = os.getcwd()
    
    # 使用系統(tǒng)臨時(shí)目錄
    temp_dir = tempfile.gettempdir()
    
    with working_directory(temp_dir) as tmp_dir:
        # 在臨時(shí)目錄中工作
        temp_file = Path("context_demo.txt")
        temp_file.write_text("在臨時(shí)目錄創(chuàng)建的文件")
        print(f"在{tmp_dir}創(chuàng)建文件: {temp_file.absolute()}")
        print(f"文件內(nèi)容: {temp_file.read_text()}")
        
        # 清理
        temp_file.unlink()
        print("?? 清理演示文件")
    
    # 驗(yàn)證已返回原始目錄
    assert os.getcwd() == original_dir
    print(f"? 已返回原始目錄: {original_dir}")
    
    print("\n2. 腳本目錄上下文管理器:")
    print("-" * 40)
    
    with script_directory() as script_dir:
        # 在腳本目錄中工作
        demo_file = Path("script_dir_demo.txt")
        demo_file.write_text(f"在腳本目錄創(chuàng)建: {script_dir}")
        print(f"在腳本目錄創(chuàng)建文件: {demo_file.name}")
        print(f"文件內(nèi)容: {demo_file.read_text()}")
        
        # 清理
        demo_file.unlink()
        print("?? 清理演示文件")
    
    print("\n3. 項(xiàng)目環(huán)境管理器演示:")
    print("-" * 40)
    
    # 在臨時(shí)目錄中創(chuàng)建演示項(xiàng)目
    with tempfile.TemporaryDirectory() as temp_project_dir:
        print(f"臨時(shí)項(xiàng)目目錄: {temp_project_dir}")
        
        with ProjectEnvironment(temp_project_dir) as project:
            # 創(chuàng)建項(xiàng)目結(jié)構(gòu)
            project.create_project_structure()
            
            # 在項(xiàng)目環(huán)境中工作
            src_main = project.get_path('main.py', relative_to='src')
            src_main.write_text("""
def main():
    print("Hello from project environment!")
    
if __name__ == "__main__":
    main()
""")
            
            print(f"? 創(chuàng)建源代碼文件: {src_main}")
            print(f"文件內(nèi)容:\n{src_main.read_text()}")
            
            # 在data目錄創(chuàng)建文件
            data_file = project.get_path('sample.csv', relative_to='data')
            data_file.write_text("name,value\ntest,123\n")
            
            print(f"? 創(chuàng)建數(shù)據(jù)文件: {data_file}")
            
            # 列出項(xiàng)目結(jié)構(gòu)
            print("\n?? 項(xiàng)目結(jié)構(gòu):")
            for dir_name, dir_path in project.dirs.items():
                files = list(dir_path.glob("*"))
                file_count = len([f for f in files if f.is_file()])
                print(f"  {dir_name}/: {file_count}個(gè)文件")
    
    print("\n? 臨時(shí)項(xiàng)目目錄已自動(dòng)清理")

def main():
    """主函數(shù)，展示所有功能"""
    print("=" * 60)
    print("方案三：上下文管理器的優(yōu)雅路徑管理")
    print("=" * 60)
    
    try:
        demonstrate_context_managers()
        
        print("\n?? 上下文管理器優(yōu)勢:")
        print("? 資源自動(dòng)管理，避免忘記恢復(fù)狀態(tài)")
        print("? 異常安全，即使出錯(cuò)也能正確清理")
        print("? 代碼可讀性高，邏輯清晰")
        print("? 支持嵌套，可組合使用")
        print("? 跨平臺(tái)兼容性")
        
    except Exception as e:
        print(f"\n? 發(fā)生錯(cuò)誤: {e}")
        import traceback
        traceback.print_exc()
        return 1
    
    return 0

if __name__ == "__main__":
    sys.exit(main())

# 方案4_complete.py
import os
import sys
import inspect
from pathlib import Path
from functools import lru_cache
import importlib.util

class SmartPathFinder:
    """
    智能路徑查找器
    自動(dòng)發(fā)現(xiàn)和管理項(xiàng)目中的各種路徑
    """
    
    def __init__(self, anchor_file=None):
        """
        初始化路徑查找器
        
        Args:
            anchor_file: 錨點(diǎn)文件，None表示使用調(diào)用者的文件
        """
        if anchor_file is None:
            # 獲取調(diào)用者的文件路徑
            frame = inspect.currentframe().f_back
            anchor_file = frame.f_globals.get('__file__', __file__)
        
        self.anchor_file = Path(anchor_file).resolve()
        self.anchor_dir = self.anchor_file.parent
        
        # 緩存常用路徑
        self._project_root = None
        self._module_paths = {}
    
    @lru_cache(maxsize=None)
    def find_project_root(self, markers=None):
        """
        查找項(xiàng)目根目錄（通過標(biāo)記文件）
        
        Args:
            markers: 標(biāo)記文件列表，如['.git', 'pyproject.toml', 'setup.py']
            
        Returns:
            Path: 項(xiàng)目根目錄
        """
        if markers is None:
            markers = ['.git', 'pyproject.toml', 'setup.py', 'requirements.txt']
        
        current = self.anchor_dir
        
        # 向上搜索直到找到標(biāo)記文件
        while current != current.parent:  # 到達(dá)根目錄時(shí)停止
            for marker in markers:
                if (current / marker).exists():
                    self._project_root = current
                    return current
            current = current.parent
        
        # 如果沒找到，使用錨點(diǎn)目錄
        self._project_root = self.anchor_dir
        return self._project_root
    
    def get_module_path(self, module_name):
        """
        獲取模塊的路徑
        
        Args:
            module_name: 模塊名（如'os'、'numpy'或項(xiàng)目內(nèi)模塊）
            
        Returns:
            Path: 模塊所在目錄
        """
        if module_name in self._module_paths:
            return self._module_paths[module_name]
        
        try:
            # 嘗試導(dǎo)入標(biāo)準(zhǔn)庫或已安裝模塊
            spec = importlib.util.find_spec(module_name)
            if spec and spec.origin and spec.origin != 'built-in':
                module_path = Path(spec.origin).parent
                self._module_paths[module_name] = module_path
                return module_path
        except (ImportError, AttributeError):
            pass
        
        # 對于項(xiàng)目內(nèi)模塊，嘗試相對導(dǎo)入
        try:
            # 從項(xiàng)目根目錄開始查找
            project_root = self.find_project_root()
            
            # 將模塊名轉(zhuǎn)換為路徑
            module_parts = module_name.split('.')
            module_path = project_root
            
            for part in module_parts:
                module_path = module_path / part
                
                # 檢查是否是目錄模塊
                if (module_path / '__init__.py').exists():
                    continue
                # 檢查是否是文件模塊
                elif (module_path.with_suffix('.py')).exists():
                    module_path = module_path.with_suffix('.py')
                    break
            
            if module_path.exists():
                if module_path.is_file():
                    module_path = module_path.parent
                
                self._module_paths[module_name] = module_path
                return module_path
        except Exception:
            pass
        
        # 如果都失敗，返回None
        return None
    
    def find_data_file(self, filename, search_dirs=None):
        """
        智能查找數(shù)據(jù)文件
        
        Args:
            filename: 要查找的文件名
            search_dirs: 搜索目錄列表，None表示自動(dòng)搜索
            
        Returns:
            Path: 找到的文件路徑，None表示未找到
        """
        if search_dirs is None:
            search_dirs = [
                self.anchor_dir,
                self.anchor_dir / 'data',
                self.find_project_root() / 'data',
                Path.cwd(),
                Path.cwd() / 'data'
            ]
        
        for directory in search_dirs:
            if not isinstance(directory, Path):
                directory = Path(directory)
            
            file_path = directory / filename
            
            # 檢查文件是否存在
            if file_path.exists():
                print(f"?? 在 {directory} 找到文件: {filename}")
                return file_path
            
            # 嘗試常見擴(kuò)展名
            for ext in ['', '.json', '.txt', '.csv', '.yaml', '.yml']:
                file_path = directory / f"{filename}{ext}"
                if file_path.exists():
                    print(f"?? 在 {directory} 找到文件: {filename}{ext}")
                    return file_path
        
        print(f"?? 未找到文件: {filename}")
        return None
    
    def get_relative_path(self, target_path, reference_path=None):
        """
        獲取相對路徑
        
        Args:
            target_path: 目標(biāo)路徑
            reference_path: 參考路徑，None表示錨點(diǎn)目錄
            
        Returns:
            Path: 相對路徑
        """
        if reference_path is None:
            reference_path = self.anchor_dir
        
        target_path = Path(target_path).resolve()
        reference_path = Path(reference_path).resolve()
        
        try:
            relative_path = target_path.relative_to(reference_path)
            return relative_path
        except ValueError:
            # 如果不在同一根目錄下，返回絕對路徑
            return target_path
    
    def create_path_tree(self, start_dir=None, max_depth=3, current_depth=0):
        """
        創(chuàng)建目錄樹結(jié)構(gòu)
        
        Args:
            start_dir: 起始目錄
            max_depth: 最大深度
            current_depth: 當(dāng)前深度
            
        Returns:
            dict: 目錄樹結(jié)構(gòu)
        """
        if start_dir is None:
            start_dir = self.find_project_root()
        
        start_dir = Path(start_dir)
        
        if current_depth >= max_depth:
            return {"_path": str(start_dir), "_type": "dir", "_truncated": True}
        
        tree = {
            "_path": str(start_dir),
            "_type": "dir",
            "_items": {}
        }
        
        try:
            for item in start_dir.iterdir():
                if item.is_dir():
                    # 遞歸處理子目錄
                    subtree = self.create_path_tree(
                        item, max_depth, current_depth + 1
                    )
                    tree["_items"][item.name] = subtree
                else:
                    tree["_items"][item.name] = {
                        "_path": str(item),
                        "_type": "file",
                        "_size": item.stat().st_size
                    }
        except PermissionError:
            tree["_permission_denied"] = True
        
        return tree
    
    def print_path_tree(self, tree, indent=""):
        """打印目錄樹"""
        if "_truncated" in tree:
            print(f"{indent}... (深度限制)")
            return
        
        print(f"{indent}?? {Path(tree['_path']).name}/")
        
        if "_items" in tree:
            items = list(tree["_items"].items())
            for i, (name, item) in enumerate(items):
                is_last = i == len(items) - 1
                branch = "└── " if is_last else "├── "
                
                if item["_type"] == "dir":
                    print(f"{indent}{branch}?? {name}/")
                    # 遞歸打印子目錄
                    next_indent = indent + ("    " if is_last else "│   ")
                    self.print_path_tree(item, next_indent)
                else:
                    size_kb = item.get("_size", 0) / 1024
                    print(f"{indent}{branch}?? {name} ({size_kb:.1f} KB)")

def demonstrate_smart_finder():
    """演示智能路徑查找器"""
    
    print("1. 創(chuàng)建智能路徑查找器:")
    print("-" * 40)
    
    finder = SmartPathFinder(__file__)
    print(f"錨點(diǎn)文件: {finder.anchor_file}")
    print(f"錨點(diǎn)目錄: {finder.anchor_dir}")
    
    print("\n2. 查找項(xiàng)目根目錄:")
    print("-" * 40)
    
    project_root = finder.find_project_root()
    print(f"項(xiàng)目根目錄: {project_root}")
    
    print("\n3. 查找模塊路徑:")
    print("-" * 40)
    
    # 查找標(biāo)準(zhǔn)庫模塊
    os_path = finder.get_module_path('os')
    print(f"os模塊路徑: {os_path}")
    
    # 查找第三方模塊（如果已安裝）
    try:
        numpy_path = finder.get_module_path('numpy')
        print(f"numpy模塊路徑: {numpy_path}")
    except ImportError:
        print("numpy未安裝，跳過")
    
    print("\n4. 智能查找文件:")
    print("-" * 40)
    
    # 創(chuàng)建一些測試文件
    test_dir = finder.anchor_dir / "test_data"
    test_dir.mkdir(exist_ok=True)
    
    (test_dir / "config.json").write_text('{"test": true}')
    (test_dir / "data.csv").write_text("col1,col2\n1,2\n3,4")
    
    # 智能查找
    config_file = finder.find_data_file("config", search_dirs=[test_dir])
    if config_file:
        print(f"找到配置文件: {config_file}")
        print(f"內(nèi)容: {config_file.read_text()}")
    
    data_file = finder.find_data_file("data", search_dirs=[test_dir])
    if data_file:
        print(f"找到數(shù)據(jù)文件: {data_file}")
        print(f"內(nèi)容:\n{data_file.read_text()}")
    
    print("\n5. 路徑關(guān)系:")
    print("-" * 40)
    
    relative_to_project = finder.get_relative_path(
        config_file, finder.find_project_root()
    )
    print(f"配置文件相對于項(xiàng)目根目錄: {relative_to_project}")
    
    print("\n6. 目錄樹結(jié)構(gòu):")
    print("-" * 40)
    
    # 創(chuàng)建演示目錄樹
    demo_root = finder.anchor_dir / "demo_project"
    demo_root.mkdir(exist_ok=True)
    
    (demo_root / "README.md").write_text("# Demo Project")
    (demo_root / "src").mkdir(exist_ok=True)
    (demo_root / "src" / "__init__.py").write_text("")
    (demo_root / "src" / "main.py").write_text("print('Hello')")
    (demo_root / "data").mkdir(exist_ok=True)
    (demo_root / "data" / "sample.txt").write_text("Sample data")
    (demo_root / "docs").mkdir(exist_ok=True)
    (demo_root / "docs" / "index.md").write_text("# Documentation")
    
    tree = finder.create_path_tree(demo_root, max_depth=2)
    finder.print_path_tree(tree)
    
    print("\n7. 清理測試文件:")
    print("-" * 40)
    
    # 清理
    import shutil
    for dir_to_remove in [test_dir, demo_root]:
        if dir_to_remove.exists():
            shutil.rmtree(dir_to_remove)
            print(f"?? 清理: {dir_to_remove}")

if __name__ == "__main__":
    print("=" * 60)
    print("方案四：智能路徑發(fā)現(xiàn)系統(tǒng)")
    print("=" * 60)
    
    demonstrate_smart_finder()
    
    print("\n?? 智能路徑查找器特點(diǎn):")
    print("? 自動(dòng)發(fā)現(xiàn)項(xiàng)目結(jié)構(gòu)")
    print("? 智能搜索文件")
    print("? 模塊路徑解析")
    print("? 目錄樹可視化")
    print("? 緩存優(yōu)化性能")