一文带你掌握Python文件操作的终极指南

# 错误示例：假设你想读取同目录下的data.txt
with open('data.txt', 'r') as f:
    content = f.read()

# 当你从不同目录运行脚本时，可能会出现：
# filenotfounderror: [errno 2] no such file or directory: 'data.txt'

# 方案1_complete.py
import os
import sys

def get_script_directory():
    """
    获取当前脚本所在的绝对路径
    这是解决路径问题的核心函数
    
    returns:
        str: 脚本所在目录的绝对路径
    """
    # 使用__file__获取当前脚本的相对路径
    script_path = os.path.abspath(__file__)
    # 获取脚本所在目录
    script_dir = os.path.dirname(script_path)
    return script_dir

def save_to_script_dir_os():
    """
    将工作目录设置为脚本所在目录，然后进行文件操作
    这种方法会改变全局状态，适合独立脚本
    """
    # 获取脚本目录
    script_dir = get_script_directory()
    
    # 保存原始工作目录，以便后续恢复（如果需要）
    original_cwd = os.getcwd()
    
    try:
        # 将工作目录切换到脚本目录
        os.chdir(script_dir)
        print(f"✅ 工作目录已切换到: {script_dir}")
        
        # 现在可以安全地使用相对路径
        data = "这是使用os模块保存的数据\n时间戳: 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")
        
        # 读取验证
        with open('output_os.txt', 'r', encoding='utf-8') as f:
            content = f.read()
        print(f"📖 文件内容:\n{content}")
        
    finally:
        # 恢复原始工作目录（可选，根据需求决定）
        os.chdir(original_cwd)
        print(f"🔄 工作目录已恢复: {original_cwd}")

def read_relative_with_fullpath():
    """
    不改变工作目录，使用完整路径进行文件操作
    这是更安全的方法，不会产生副作用
    """
    # 获取脚本目录
    script_dir = get_script_directory()
    
    # 构建完整路径
    file_path = os.path.join(script_dir, 'data', 'sample.txt')
    
    # 如果目录不存在，创建它
    data_dir = os.path.join(script_dir, 'data')
    if not os.path.exists(data_dir):
        os.makedirs(data_dir)
        print(f"📁 创建目录: {data_dir}")
    
    # 写入文件
    with open(file_path, 'w', encoding='utf-8') as f:
        f.write("使用完整路径写入的数据")
    
    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🎯 关键要点:")
    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):
        """初始化常用的子目录结构"""
        # 定义项目目录结构
        self.dirs = {
            'data': self.script_dir / 'data',
            'logs': self.script_dir / 'logs',
            'output': self.script_dir / 'output',
            'config': self.script_dir / 'config'
        }
        
        # 创建目录（如果不存在）
        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数据到data目录
        
        args:
            data: 要保存的数据（可json序列化）
            filename: 文件名
            
        returns:
            path: 保存的文件路径
        """
        filepath = self.get_path(filename, 'data')
        
        # 确保文件扩展名正确
        if not filename.endswith('.json'):
            filepath = filepath.with_suffix('.json')
        
        # 写入json数据
        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数据
        
        args:
            filename: 文件名
            
        returns:
            dict/list: 加载的数据
        """
        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: 日志级别
        """
        # 按日期创建日志文件
        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)}个{pattern}文件")
        return files

def demonstrate_path_operations():
    """
    演示pathlib的各种强大功能
    """
    # 创建路径管理器
    pm = pathmanager()
    
    # 1. 保存和加载json数据
    sample_data = {
        "project": "python路径管理",
        "author": "开发者",
        "version": "1.0.0",
        "features": ["路径安全", "自动目录创建", "日志记录"],
        "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"加载的数据: {loaded_data['project']}")
    
    # 2. 记录日志
    pm.log("程序开始运行")
    pm.log("数据保存完成", "success")
    
    # 3. 查找文件
    # 先创建一些测试文件
    test_files = ['test1.txt', 'test2.txt', 'data.csv']
    for file in test_files:
        (pm.dirs['data'] / file).write_text(f"这是{file}的内容")
    
    # 查找所有txt文件
    txt_files = pm.find_files("*.txt", 'data')
    for file in txt_files:
        print(f"找到文件: {file.name} (大小: {file.stat().st_size}字节)")
    
    # 4. 路径操作演示
    print("\n🔧 pathlib路径操作演示:")
    current_file = path(__file__)
    print(f"当前文件: {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目标路径: {new_path}")
    
    # 自动创建多级目录
    new_path.parent.mkdir(parents=true, exist_ok=true)
    new_path.write_text("深度嵌套文件的内容")
    print(f"✅ 已创建深度嵌套文件")

if __name__ == "__main__":
    print("=" * 60)
    print("方案二：使用pathlib的现代化路径管理")
    print("=" * 60)
    
    demonstrate_path_operations()
    
    print("\n🎯 pathlib核心优势:")
    print("1. 面向对象，代码更直观")
    print("2. 自动处理路径分隔符（/ 运算符重载）")
    print("3. 链式调用，代码更简洁")
    print("4. 跨平台兼容性更好")

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

@contextmanager
def working_directory(path):
    """
    上下文管理器：临时切换工作目录
    
    args:
        path: 目标目录路径（字符串或path对象）
        
    使用示例:
        with working_directory("/tmp"):
            # 在这个块内，工作目录是/tmp
            open("tempfile.txt", "w").write("test")
        # 离开块后，工作目录自动恢复
    """
    # 转换为字符串路径
    if isinstance(path, path):
        path = str(path)
    
    # 保存原始工作目录
    original_cwd = os.getcwd()
    
    try:
        # 切换到目标目录
        os.chdir(path)
        print(f"📁 进入目录: {path}")
        yield path  # 这里交出控制权
    except filenotfounderror:
        print(f"❌ 目录不存在: {path}")
        # 创建目录后重试
        os.makedirs(path, exist_ok=true)
        os.chdir(path)
        print(f"📁 创建并进入目录: {path}")
        yield path
    finally:
        # 无论是否发生异常，都恢复原始目录
        os.chdir(original_cwd)
        print(f"↩️ 返回目录: {original_cwd}")

@contextmanager
def script_directory():
    """
    临时切换到脚本所在目录的上下文管理器
    这是最常用的场景
    """
    # 获取脚本目录
    script_dir = os.path.dirname(os.path.abspath(__file__))
    
    with working_directory(script_dir) as dir_path:
        yield dir_path

class projectenvironment:
    """
    项目环境管理器
    管理整个项目的路径环境
    """
    def __init__(self, base_dir=none):
        """
        初始化项目环境
        
        args:
            base_dir: 项目根目录，none表示使用脚本目录
        """
        if base_dir is none:
            self.base_dir = path(__file__).resolve().parent
        else:
            self.base_dir = path(base_dir).resolve()
        
        # 项目目录结构
        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):
        """进入项目环境"""
        # 确保所有目录存在
        for dir_path in self.dirs.values():
            dir_path.mkdir(parents=true, exist_ok=true)
        
        # 保存原始目录
        self.original_cwd = path.cwd()
        
        # 切换到项目根目录
        os.chdir(self.base_dir)
        print(f"🚀 进入项目环境: {self.base_dir}")
        
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        """退出项目环境"""
        # 切换回原始目录
        os.chdir(self.original_cwd)
        print(f"🏁 退出项目环境，返回: {self.original_cwd}")
        
        # 如果有异常，可以选择处理或重新抛出
        if exc_type is not none:
            print(f"⚠️ 在项目环境中发生异常: {exc_type.__name__}: {exc_val}")
        
        # 返回false会重新抛出异常，true会吞掉异常
        return false
    
    def get_path(self, *parts, relative_to='base'):
        """
        获取项目内的路径
        
        args:
            *parts: 路径部分
            relative_to: 相对于哪个目录（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):
        """创建项目基本结构"""
        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} - 项目{dir_name}目录\n\n')
                    elif file.endswith('.md'):
                        file_path.write_text(f'# {file}\n\n项目文档\n')
        
        print("📁 项目结构创建完成")

def demonstrate_context_managers():
    """演示上下文管理器的使用"""
    
    print("1. 基本上下文管理器演示:")
    print("-" * 40)
    
    # 演示临时目录切换 - 兼容windows和linux
    original_dir = os.getcwd()
    
    # 使用系统临时目录
    temp_dir = tempfile.gettempdir()
    
    with working_directory(temp_dir) as tmp_dir:
        # 在临时目录中工作
        temp_file = path("context_demo.txt")
        temp_file.write_text("在临时目录创建的文件")
        print(f"在{tmp_dir}创建文件: {temp_file.absolute()}")
        print(f"文件内容: {temp_file.read_text()}")
        
        # 清理
        temp_file.unlink()
        print("🧹 清理演示文件")
    
    # 验证已返回原始目录
    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"在脚本目录创建: {script_dir}")
        print(f"在脚本目录创建文件: {demo_file.name}")
        print(f"文件内容: {demo_file.read_text()}")
        
        # 清理
        demo_file.unlink()
        print("🧹 清理演示文件")
    
    print("\n3. 项目环境管理器演示:")
    print("-" * 40)
    
    # 在临时目录中创建演示项目
    with tempfile.temporarydirectory() as temp_project_dir:
        print(f"临时项目目录: {temp_project_dir}")
        
        with projectenvironment(temp_project_dir) as project:
            # 创建项目结构
            project.create_project_structure()
            
            # 在项目环境中工作
            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"✅ 创建源代码文件: {src_main}")
            print(f"文件内容:\n{src_main.read_text()}")
            
            # 在data目录创建文件
            data_file = project.get_path('sample.csv', relative_to='data')
            data_file.write_text("name,value\ntest,123\n")
            
            print(f"✅ 创建数据文件: {data_file}")
            
            # 列出项目结构
            print("\n📁 项目结构:")
            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}个文件")
    
    print("\n✅ 临时项目目录已自动清理")

def main():
    """主函数，展示所有功能"""
    print("=" * 60)
    print("方案三：上下文管理器的优雅路径管理")
    print("=" * 60)
    
    try:
        demonstrate_context_managers()
        
        print("\n🎯 上下文管理器优势:")
        print("• 资源自动管理，避免忘记恢复状态")
        print("• 异常安全，即使出错也能正确清理")
        print("• 代码可读性高，逻辑清晰")
        print("• 支持嵌套，可组合使用")
        print("• 跨平台兼容性")
        
    except exception as e:
        print(f"\n❌ 发生错误: {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:
    """
    智能路径查找器
    自动发现和管理项目中的各种路径
    """
    
    def __init__(self, anchor_file=none):
        """
        初始化路径查找器
        
        args:
            anchor_file: 锚点文件，none表示使用调用者的文件
        """
        if anchor_file is none:
            # 获取调用者的文件路径
            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):
        """
        查找项目根目录（通过标记文件）
        
        args:
            markers: 标记文件列表，如['.git', 'pyproject.toml', 'setup.py']
            
        returns:
            path: 项目根目录
        """
        if markers is none:
            markers = ['.git', 'pyproject.toml', 'setup.py', 'requirements.txt']
        
        current = self.anchor_dir
        
        # 向上搜索直到找到标记文件
        while current != current.parent:  # 到达根目录时停止
            for marker in markers:
                if (current / marker).exists():
                    self._project_root = current
                    return current
            current = current.parent
        
        # 如果没找到，使用锚点目录
        self._project_root = self.anchor_dir
        return self._project_root
    
    def get_module_path(self, module_name):
        """
        获取模块的路径
        
        args:
            module_name: 模块名（如'os'、'numpy'或项目内模块）
            
        returns:
            path: 模块所在目录
        """
        if module_name in self._module_paths:
            return self._module_paths[module_name]
        
        try:
            # 尝试导入标准库或已安装模块
            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
        
        # 对于项目内模块，尝试相对导入
        try:
            # 从项目根目录开始查找
            project_root = self.find_project_root()
            
            # 将模块名转换为路径
            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):
        """
        智能查找数据文件
        
        args:
            filename: 要查找的文件名
            search_dirs: 搜索目录列表，none表示自动搜索
            
        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
            
            # 尝试常见扩展名
            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: 目标路径
            reference_path: 参考路径，none表示锚点目录
            
        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):
        """
        创建目录树结构
        
        args:
            start_dir: 起始目录
            max_depth: 最大深度
            current_depth: 当前深度
            
        returns:
            dict: 目录树结构
        """
        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. 创建智能路径查找器:")
    print("-" * 40)
    
    finder = smartpathfinder(__file__)
    print(f"锚点文件: {finder.anchor_file}")
    print(f"锚点目录: {finder.anchor_dir}")
    
    print("\n2. 查找项目根目录:")
    print("-" * 40)
    
    project_root = finder.find_project_root()
    print(f"项目根目录: {project_root}")
    
    print("\n3. 查找模块路径:")
    print("-" * 40)
    
    # 查找标准库模块
    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)
    
    # 创建一些测试文件
    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"内容: {config_file.read_text()}")
    
    data_file = finder.find_data_file("data", search_dirs=[test_dir])
    if data_file:
        print(f"找到数据文件: {data_file}")
        print(f"内容:\n{data_file.read_text()}")
    
    print("\n5. 路径关系:")
    print("-" * 40)
    
    relative_to_project = finder.get_relative_path(
        config_file, finder.find_project_root()
    )
    print(f"配置文件相对于项目根目录: {relative_to_project}")
    
    print("\n6. 目录树结构:")
    print("-" * 40)
    
    # 创建演示目录树
    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("方案四：智能路径发现系统")
    print("=" * 60)
    
    demonstrate_smart_finder()
    
    print("\n🎯 智能路径查找器特点:")
    print("• 自动发现项目结构")
    print("• 智能搜索文件")
    print("• 模块路径解析")
    print("• 目录树可视化")
    print("• 缓存优化性能")