基于Python pathlib库的路径/文件/目录常用操作

from pathlib import Path

# 创建Path对象的几种方式
current_path = Path()  # 当前目录
relative_path = Path('folder/subfolder')  # 相对路径
absolute_path = Path('/home/user/documents')  # 绝对路径（Linux/Mac）
windows_path = Path('C:/Users/Name/Documents')  # 绝对路径（Windows）

# 使用类方法
current_dir = Path.cwd()  # 当前工作目录
home_dir = Path.home()  # 用户主目录

# 路径拼接
base_dir = Path('/base/demo')
sub_path = base_dir / 'subfolder' / 'file.txt'
print(sub_path)  # 输出: /base/demo/subfolder/file.txt

# 解析路径组成部分
path = Path('D:/Users/base_demo/demo.py')
print(path.name)      # 文件名（含后缀）: demo.py
print(path.stem)      # 文件名（不含后缀）: demo
print(path.suffix)    # 文件后缀: .py
print(path.parent)    # 父目录: D:/Users/base_demo
print(path.anchor)    # 锚点（驱动器）: D:

path = Path('/path/to/file.txt')

# 路径判断
print(path.exists())     # 路径是否存在
print(path.is_file())    # 是否是文件
print(path.is_dir())     # 是否是目录
print(path.is_absolute()) # 是否是绝对路径

# 路径解析
print(path.resolve())    # 获取绝对路径，解析任何符号链接
print(path.as_uri())     # 将路径表示为file URL

# 创建目录
new_dir = Path('new_directory')
new_dir.mkdir(exist_ok=True)  # exist_ok=True表示目录已存在时不报错

# 创建多级目录
deep_dir = Path('path/to/deep/directory')
deep_dir.mkdir(parents=True, exist_ok=True)  # parents=True创建所有必要的父目录

# 删除目录（目录必须为空）
empty_dir = Path('empty_directory')
empty_dir.rmdir()

path = Path('.')

# 遍历直接子项
for item in path.iterdir():
    if item.is_file():
        print(f"文件: {item.name}")
    elif item.is_dir():
        print(f"目录: {item.name}")

# 使用glob模式匹配
for py_file in path.glob('*.py'):
    print(f"Python文件: {py_file}")

# 递归匹配（搜索子目录）
for py_file in path.rglob('*.py'):
    print(f"Python文件: {py_file}")

file_path = Path('example.txt')

# 写入文件
file_path.write_text('Hello, World!')  # 写入文本

# 读取文件
content = file_path.read_text()
print(content)

# 二进制读写
data = b'Binary data'
file_path.write_bytes(data)  # 写入二进制数据
binary_content = file_path.read_bytes()  # 读取二进制数据

# 使用open方法（更细粒度的控制）
with file_path.open('a') as f:  # 追加模式
    f.write('\nAppended text')

file_path = Path('example.txt')

# 获取文件属性
stat_info = file_path.stat()
print(f"文件大小: {stat_info.st_size} 字节")
print(f"创建时间: {stat_info.st_ctime}")
print(f"修改时间: {stat_info.st_mtime}")

# 文件操作
new_path = file_path.rename('new_name.txt')  # 重命名
copied_path = new_path.replace('backup.txt')  # 移动/复制（会覆盖已存在文件）

# 删除文件
file_path.unlink(missing_ok=True)  # missing_ok=True表示文件不存在时不报错

from pathlib import Path
import shutil
import time

class FileIO:
    """
    使用 pathlib 封装常见文件路径操作的实用类

    该类提供了一系列用于文件和目录操作的方法，包括遍历、筛选、清空文件夹等功能。
    所有路径操作均基于 pathlib 库，确保跨平台兼容性。
    """

    def __init__(self, source_folder: None |str | Path, target_folder:None |str | Path) -> None:
        """
        初始化 FileIO 实例

        Args:
            source_folder: 源目录路径，可以是字符串或 Path 对象
        """
        self.source_folder = Path(source_folder)  # 保证路径是 Path 格式
        self.target_folder = Path(target_folder) #目标文件
        if not self.target_folder.exists(): #目标文件夹不存在时，新建
            self.target_folder.mkdir(parents=True, exist_ok=True)

    def list_folder_names(self, recursive: bool = True) -> list[str]:
        """
        获取文件夹名称列表

        Args:
            recursive: 是否递归获取所有子文件夹，默认为 True
                      True - 递归获取所有子文件夹
                      False - 只获取直接子文件夹

        Returns:
            文件夹名称列表
        """
        folder_path = self.source_folder
        folder_names = [item.name
                        for item in (folder_path.rglob('*') if recursive else folder_path.iterdir()) #iterdir()比glob('*')更高效，
                        if item.is_dir()]
        return folder_names

    def list_folder_paths(self, recursive: bool = True) -> list[Path]:
        """
        获取文件夹路径列表

        Args:
            recursive: 是否递归获取所有子文件夹路径

        Returns:
            Path 对象列表，包含所有匹配的文件夹路径
        """
        folder_path = self.source_folder
        folder_paths = [item
                        for item in (folder_path.rglob('*') if recursive else folder_path.iterdir())
                        if item.is_dir()]
        return folder_paths

    def list_file_names(self, recursive: bool = True, include_extension: bool = True) -> list[str]:
        """
        获取文件名列表

        Args:
            recursive: 是否递归获取所有子文件
            include_extension: 是否包含文件扩展名
                             True - 包含扩展名 (e.g., "document.txt")
                             False - 不包含扩展名 (e.g., "document")

        Returns:
            文件名列表
        """
        folder_path = self.source_folder
        file_names = [
            item.name if include_extension else item.stem
            for item in (folder_path.rglob('*') if recursive else folder_path.iterdir())
            if item.is_file()
        ]
        return file_names

    def list_file_paths(self, recursive: bool = True) -> list[Path]:
        """
        获取文件路径列表

        Args:
            recursive: 是否递归获取所有子文件路径

        Returns:
            Path 对象列表，包含所有匹配的文件路径
        """
        folder_path = self.source_folder
        file_paths = [item
                      for item in (folder_path.rglob('*') if recursive else folder_path.iterdir())
                      if item.is_file()]

        return file_paths

    @staticmethod
    def filter_by_strings(items: list[str] | list[Path], target_strings: list[str], logical_or: bool = True) -> list[str]:
        """
        根据字符串列表筛选项目

        Args:
            items: 要筛选的项目列表
            target_strings: 目标字符串列表，用于筛选条件
            logical_or: 逻辑操作类型
                       True - 逻辑或（包含任意一个目标字符串即匹配）
                       False - 逻辑与（包含所有目标字符串才匹配）

        Returns:
            筛选后的项目列表
        """
        if logical_or:  # 逻辑OR：包含任意一个字符串即可
            filtered_items = [item
                              for item in items
                              if any(target_str in str(item) for target_str in target_strings)
            ]
        else:  # 逻辑AND：包含所有字符串
            filtered_items = [item
                              for item in items
                              if all(target_str in str(item) for target_str in target_strings)
            ]
        return filtered_items

    @staticmethod
    def clear_folder(target_dir: str|Path, max_attempts: int = 3, delay_seconds: float = 3) -> bool|None:
        """
        通过删除并重建文件夹的方式来清空目标文件夹，支持重试机制

        Args:
            max_attempts: 最大尝试次数，默认为3次
            delay_seconds: 每次重试前的等待时间（秒），默认为3秒

        Returns:
            bool: 成功清空返回 True，失败返回 False

        Raises:
            PermissionError: 当文件被占用且无法删除时
            OSError: 当发生其他操作系统错误时
        """
        attempts = 0
        while attempts < max_attempts:
            try:
                # 尝试清空文件夹的核心逻辑
                source_folder = Path(target_dir)
                if source_folder.exists():
                    shutil.rmtree(source_folder)  # 递归删除整个文件夹
                    # 短暂延迟确保删除完全生效
                    time.sleep(0.05)

                source_folder.mkdir(exist_ok=True)  # 重新创建空文件夹
                print(f"成功清空文件夹: {source_folder}")
                return True

            except PermissionError as error:
                # 捕获权限错误（通常是因为文件被占用）
                attempts += 1
                print(f"尝试 {attempts}/{max_attempts} 失败: 文件可能正被其他程序占用。错误信息: {error}")

                if attempts < max_attempts:
                    print(f"等待 {delay_seconds} 秒后重试...")
                    time.sleep(delay_seconds)
                else:
                    print(f"已达到最大重试次数 {max_attempts}，无法清空文件夹。")
                    return False

            except OSError as error:
                # 捕获其他操作系统错误，例如路径无效等
                print(f"发生操作系统错误: {error}")
                return False

    def copy_directory_structure(self, recursive: bool = True) -> None:
        """
        复制源目录结构到目标位置（不复制文件内容）

        递归复制源目录下的所有子目录结构到目标位置，但不会复制任何文件内容，
        只创建空的目录结构。

        Args:
            target_dir: 目标目录路径，可以是字符串或 Path 对象
        """
        source_path = self.source_folder
        target_path = self.target_folder

        # 确保目标根目录存在
        target_path.mkdir(parents=True, exist_ok=True)

        # 使用 rglob 递归遍历源目录下的所有子目录
        for dir_path in (source_path.rglob('*') if recursive else source_path.glob('*')):
            if dir_path.is_dir():
                # 计算当前目录相对于源目录的相对路径
                try:
                    relative_path = dir_path.relative_to(source_path)
                except ValueError:
                    # 如果 dir_path 不是 source_path 的子路径，跳过
                    continue

                # 构建目标目录路径并创建
                target_subdir = target_path / relative_path
                target_subdir.mkdir(parents=True, exist_ok=True)
                print(f"创建目录: {target_subdir}")


    def find_leaf_directories(self) -> list[Path]:
        """
        查找并返回所有叶子目录（不包含子目录的目录）

        Returns:
            叶子目录的 Path 对象列表
        """
        source_path = self.source_folder
        leaf_directories = []

        # 识别叶子目录：没有子目录的目录就是叶子目录
        for dir_path in source_path.rglob('*'):
            if dir_path.is_dir():
                # 检查当前目录是否包含子目录
                has_subdirectories = any(item.is_dir() for item in dir_path.iterdir())

                if not has_subdirectories:
                    leaf_directories.append(dir_path)

        # 输出所有叶子目录信息
        result_paths = []
        print("\n所有叶子目录（最深层次的子目录）:")
        for leaf_path in leaf_directories:
            # 计算相对于源目录的路径用于显示
            try:
                relative_leaf_path = leaf_path.relative_to(source_path)
                result_paths.append(source_path / relative_leaf_path)

                # 计算目录深度
                depth = len(relative_leaf_path.parts)
                print(f"- {relative_leaf_path} (深度: {depth})")
            except ValueError:
                # 如果路径计算出错，跳过
                continue

        return result_paths

    #将一个文件夹里的所有指定格式文件复制到另一个目标文件夹
    def copy_files(self,  file_extension='.tif') -> None:
        source_files = self.list_file_paths(True) #获取原始文件夹里所有的文件路径
        for source_file in source_files:
            if file_extension in str(source_file):
                shutil.copy2(source_file, self.target_folder)#将原始文件夹里所有的文件复制到对应文件夹
                print(f"已复制: {source_file} -> {target_folder}")
    #将一个文件夹里的所有目录和指定格式文件复制到另一个文件夹
    def copy_folders_and_files(self, file_extension='.tif') -> None:
        self.copy_directory_structure(True)
        source_files = self.list_file_paths(True)  # 获取原始文件夹里所有的文件路径
        for source_file in source_files:
            if file_extension in str(source_file):
                # 计算 source_file 相对于 self.source_folder 的相对路径
                relative_path = source_file.relative_to(self.source_folder)
                # 将相对路径拼接到目标文件夹下
                target_file = self.target_folder / relative_path
                shutil.copy2(source_file, target_file)  # 将原始文件夹里所有的文件复制到对应文件夹
                print(f"已复制: {source_file} -> {target_file}")
    #将一个文件复制到目标文件夹里，并重命名
    @staticmethod
    def copy_rename_file(source_file_path:str|Path, target_folder:str|Path,new_filename:str) -> None:
        extension_name = Path(source_file_path).suffix
        target_file_path = Path(target_folder) / Path(new_filename +extension_name)
        shutil.copy2(source_file_path, target_file_path)
        print(f"已复制: {source_file_path} -> {target_file_path}")
if __name__ == '__main__':
    # # 测试路径，请替换为实际路径
    source_folder = Path(r"F:\source")
    target_folder = Path(r"F:\target")
    file_io = FileIO(source_folder, target_folder)  # 实例化类

    target_strings = [".tif", ".docx"]
    #
    # 测试直接子文件夹相关方法
    print("=== 直接子文件夹 ===")
    current_folder_names = file_io.list_folder_names(False) #获取直接文件夹名
    current_folder_paths = file_io.list_folder_paths(False) #获取直接文件夹路径
    filtered_current_folder_paths_and = file_io.filter_by_strings(current_folder_paths, target_strings, False) #按照逻辑与筛选含所有关键字的直接子文件夹路径
    filtered_current_folder_paths_or = file_io.filter_by_strings(current_folder_paths, target_strings, True) #按照逻辑或筛选含任一关键字的直接子文件夹路径

    print("直接子文件夹名称列表:", current_folder_names)
    print("直接子文件夹路径列表:", current_folder_paths)
    print("AND条件过滤的文件夹:",  filtered_current_folder_paths_and)
    print("OR条件过滤的文件夹:", filtered_current_folder_paths_or)

    # 测试所有子文件夹相关方法
    print("\n=== 所有子文件夹 ===")
    all_folder_names = file_io.list_folder_names(True) #获取所有子文件夹名
    all_folder_paths = file_io.list_folder_paths(True) #获取所有子文件夹路径
    filtered_all_folder_paths_and = file_io.filter_by_strings(all_folder_paths, target_strings, False) #按照逻辑与筛选含所有关键字的子文件夹路径
    filtered_all_folder_paths_or =  file_io.filter_by_strings(all_folder_paths, target_strings, True) #按照逻辑或筛选含任一关键字的子文件夹路径

    print("所有子文件夹名称:", all_folder_names)
    print("所有子文件夹路径:", all_folder_paths)
    print("AND条件过滤的所有子文件夹:", filtered_all_folder_paths_and)
    print("OR条件过滤的所有子文件夹:", filtered_all_folder_paths_or )

    # 测试直接子文件相关方法
    print("\n=== 直接子文件 ===")
    current_file_lists_with_extension = file_io.list_file_names(False,True) #获取所有直接文件的名称，有扩展名
    current_file_lists_no_extension = file_io.list_file_names(False,False) #获取所有直接文件的名称，无扩展名
    current_file_path_lists = file_io.list_file_paths(False) #获取直接文件路径
    filtered_file_path_lists_and = file_io.filter_by_strings(current_file_path_lists, target_strings, False) #按照逻辑与筛选含所有关键字的直接子文件路径
    filtered_file_path_lists_or = file_io.filter_by_strings(current_file_path_lists, target_strings, True) #按照逻辑或筛选含任一关键字的直接子文件路径

    print("带扩展名的文件:", current_file_lists_with_extension)
    print("不带扩展名的文件:", current_file_lists_no_extension)
    print("文件路径列表:", current_file_path_lists )
    print("AND条件过滤的文件:", filtered_file_path_lists_and)
    print("OR条件过滤的文件:", filtered_file_path_lists_or)

    # 测试所有子文件相关方法
    print("\n=== 所有子文件 ===")
    all_file_lists_with_extension = file_io.list_file_names(True,True) #获取所有文件的名称，有扩展名
    all_file_lists_no_extension = file_io.list_file_names(True,False) #获取所有文件的名称，无扩展名
    all_file_path_lists = file_io.list_file_paths(True) #获取所有文件路径
    filtered_all_file_path_lists_and = file_io.filter_by_strings(all_file_path_lists, target_strings, False) #按照逻辑与筛选含所有关键字的所有文件路径
    filtered_all_file_path_lists_or = file_io.filter_by_strings(all_file_path_lists, target_strings, True) #按照逻辑或筛选含任一关键字的所有文件路径

    print("所有文件(带扩展名):", all_file_lists_with_extension)
    print("所有文件(不带扩展名):", all_file_lists_no_extension)
    print("所有文件路径:", all_file_path_lists)
    print("AND条件过滤的所有文件:", filtered_all_file_path_lists_and)
    print("OR条件过滤的所有文件:", filtered_all_file_path_lists_or)

    #清空目标文件夹里的所有内容
    file_io.clear_folder(file_io.target_folder)
    #复制所有目录
    file_io.copy_directory_structure(True) #True，复制所有目录，False，复制当前目录
    #找到所有叶子目录
    all_leaves = file_io.find_leaf_directories()
    print(all_leaves)
    # 清空目标文件夹里的所有内容
    file_io.clear_folder(file_io.target_folder)
    #复制特定格式的文件到指定目录
    file_io.copy_files(".docx")
    # 清空目标文件夹里的所有内容
    file_io.clear_folder(file_io.target_folder)
    #复制并重命名
    i=0
    for filtered_all_file_path_lists_or  in filtered_all_file_path_lists_or:
        file_io.copy_rename_file(filtered_all_file_path_lists_or,file_io.target_folder,str(i))
        i = i + 1