Python文件查找终极指南：os、glob与pathlib深度探索264

```html

在日常的软件开发和系统维护中，查找特定类型的文件是一项极为常见的任务。无论是处理日志文件、配置文件、用户上传的数据，还是进行代码分析，高效地定位目标文件都是提高工作效率的关键。Python作为一门功能强大且生态丰富的编程语言，为文件系统操作提供了多种简洁而高效的工具。本文将作为一份详尽的指南，深入探讨Python中用于查找某类文件的核心模块：os、glob和pathlib，并通过丰富的代码示例，帮助您掌握在各种场景下查找文件的最佳实践。

为了让您更好地跟随本文的示例，请在运行代码前，创建一个名为 test_files 的目录，并在其中创建以下文件和子目录：
# 创建目录结构
mkdir -p test_files/docs
mkdir -p test_files/reports/2023
mkdir -p test_files/data
# 创建文件
touch test_files/
touch test_files/
touch test_files/
touch test_files/docs/
touch test_files/docs/
touch test_files/reports/
touch test_files/reports/2023/
touch test_files/data/
touch test_files/data/

一、os 模块：文件系统操作的基础

os 模块是Python标准库中用于与操作系统交互的基础模块，提供了大量函数来处理文件和目录。它是进行文件查找的底层基石，尤其适用于需要精细控制路径、文件属性的场景。

1.1 非递归查找：()

(path) 函数用于获取指定路径下的所有文件和子目录的名称列表，但不包括 . 和 ..。它不会递归地进入子目录。
import os
def find_files_non_recursive(directory, extension):
"""
在指定目录中查找特定扩展名的文件（非递归）。
"""
found_files = []
try:
# 获取目录下的所有条目
entries = (directory)
for entry in entries:
# 构造完整路径
full_path = (directory, entry)
# 检查是否是文件且符合扩展名
if (full_path) and (extension):
(full_path)
except FileNotFoundError:
print(f"目录 '{directory}' 不存在。")
except PermissionError:
print(f"没有权限访问目录 '{directory}'。")
return found_files
# 示例：查找 'test_files' 目录下的所有 .py 文件
py_files = find_files_non_recursive('test_files', '.py')
print("非递归查找 .py 文件:", py_files)
# 示例：查找 'test_files' 目录下的所有 .md 文件
md_files = find_files_non_recursive('test_files', '.md')
print("非递归查找 .md 文件:", md_files)

输出示例：
非递归查找 .py 文件: ['test_files/']
非递归查找 .md 文件: ['test_files/']

注意：() 用于安全地拼接路径，它会自动根据操作系统添加正确的路径分隔符（Windows 是 \，Linux/macOS 是 /）。() 用于判断路径是否指向一个文件。

1.2 递归查找：()

(top) 是 os 模块中用于递归遍历目录树的强大工具。它会生成一个三元组 (dirpath, dirnames, filenames)，其中：
dirpath：当前正在遍历的目录的路径。
dirnames：dirpath 下的子目录名称列表。
filenames：dirpath 下的文件名称列表。

import os
def find_files_recursive_os_walk(directory, extension):
"""
递归查找指定目录及其子目录中特定扩展名的文件。
"""
found_files = []
try:
# 会遍历指定目录及其所有子目录
for dirpath, dirnames, filenames in (directory):
for filename in filenames:
if (extension):
# 构造完整的文件路径
full_path = (dirpath, filename)
(full_path)
except FileNotFoundError:
print(f"目录 '{directory}' 不存在。")
except PermissionError:
print(f"没有权限访问目录 '{directory}'。")
return found_files
# 示例：查找 'test_files' 及其子目录下的所有 .txt 文件
txt_files = find_files_recursive_os_walk('test_files', '.txt')
print(" 查找 .txt 文件:", txt_files)
# 示例：查找 'test_files' 及其子目录下的所有 .csv 文件
csv_files = find_files_recursive_os_walk('test_files', '.csv')
print(" 查找 .csv 文件:", csv_files)

输出示例：
查找 .txt 文件: ['test_files/docs/', 'test_files/docs/']
查找 .csv 文件: ['test_files/reports/']

总结：os 模块提供了最底层的、最灵活的文件系统操作接口。() 是实现递归查找的“瑞士军刀”，适用于需要处理目录结构本身，或者需要结合文件属性（如大小、修改时间等）进行复杂过滤的场景。

二、glob 模块：基于模式匹配的文件查找

glob 模块允许使用Unix shell风格的通配符模式来查找文件路径，这在许多情况下比 os 模块更加简洁直观。它特别适合那些只需要根据文件名模式进行简单查找的场景。

2.1 ()：匹配文件并返回列表

(pathname, *, recursive=False) 函数返回所有匹配 pathname 的路径名列表。支持以下通配符：
*：匹配0个或多个字符。
?：匹配单个字符。
[seq]：匹配 seq 中的任何单个字符。
[!seq]：匹配不在 seq 中的任何单个字符。

从 Python 3.5 开始，模式可以用于递归匹配目录和文件，但需要将 recursive 参数设置为 True。
import glob
# 示例：查找 'test_files' 目录下所有 .ini 文件 (非递归)
ini_files = ('test_files/*.ini')
print("glob 查找 .ini 文件 (非递归):", ini_files)
# 示例：查找 'test_files' 目录下所有以 's' 开头的文件 (非递归)
s_files = ('test_files/s*.py') # 严格来说，这里是查找以 's' 开头且以 '.py' 结尾的文件
print("glob 查找以 's' 开头的 .py 文件 (非递归):", s_files)
# 示例：递归查找 'test_files' 及其子目录下所有 .txt 文件
# 注意：使用匹配任意目录，并设置 recursive=True
all_txt_files = ('test_files//*.txt', recursive=True)
print("glob 查找 .txt 文件 (递归):", all_txt_files)
# 示例：递归查找 'test_files' 及其子目录下所有 .csv 或 .xlsx 文件
csv_xlsx_files = ('test_files//*.@(csv|xlsx)', recursive=True) # 扩展：{} 用于匹配多个模式，需要配合 shell 扩展
# 注意：Python 的 glob 模块本身不支持 {} 这种 shell 扩展语法。需要多次调用 glob 或结合其他方式。
# 正确的做法是：
csv_files = ('test_files//*.csv', recursive=True)
xlsx_files = ('test_files//*.xlsx', recursive=True)
all_reports = csv_files + xlsx_files
print("glob 查找 .csv 或 .xlsx 文件 (递归):", all_reports)
# 示例：查找 'test_files/reports/2023' 目录下的所有文件
report_2023_files = ('test_files/reports/2023/*')
print("glob 查找 test_files/reports/2023 目录下的所有文件:", report_2023_files)

输出示例：
glob 查找 .ini 文件 (非递归): ['test_files/']
glob 查找以 's' 开头的 .py 文件 (非递归): ['test_files/']
glob 查找 .txt 文件 (递归): ['test_files/docs/', 'test_files/docs/']
glob 查找 .csv 或 .xlsx 文件 (递归): ['test_files/reports/', 'test_files/reports/2023/']
glob 查找 test_files/reports/2023 目录下的所有文件: ['test_files/reports/2023/']

2.2 ()：迭代器版本

(pathname, *, recursive=False) 与 () 功能相似，但它返回一个迭代器而不是一个列表。这对于处理大量文件非常有用，因为它不会一次性将所有匹配的文件加载到内存中，从而节省内存资源。
import glob
# 示例：使用递归查找所有 .json 文件
print(" 查找 .json 文件 (迭代器):")
for json_file in ('test_files//*.json', recursive=True):
print(json_file)

输出示例：
查找 .json 文件 (迭代器):
test_files/data/

总结：glob 模块以其简洁的通配符语法，成为快速进行文件路径模式匹配的首选。当您只需要根据文件或目录名进行简单匹配时，它提供了比 () 更优雅的解决方案。对于内存敏感的应用，() 是一个很好的选择。

三、pathlib 模块：现代、面向对象的文件系统路径

pathlib 模块是 Python 3.4 引入的，提供了一种面向对象的方式来处理文件系统路径。它将文件系统路径抽象为 Path 对象，使得路径操作更加直观、链式化，并且具有更好的可读性和跨平台兼容性，是现代Python文件系统编程的推荐方式。

3.1 Path 对象的基本操作与非递归查找

创建一个 Path 对象很简单，然后可以使用它的各种方法进行操作。
from pathlib import Path
def find_files_pathlib_non_recursive(directory, extension):
"""
使用 pathlib 在指定目录中查找特定扩展名的文件（非递归）。
"""
found_files = []
base_path = Path(directory)
if not base_path.is_dir():
print(f"路径 '{directory}' 不是一个目录或不存在。")
return []
for item in ():
if item.is_file() and == extension:
(str(item)) # 转换为字符串路径
return found_files
# 示例：查找 'test_files' 目录下的所有 .md 文件
md_files_pathlib = find_files_pathlib_non_recursive('test_files', '.md')
print("pathlib 查找 .md 文件 (非递归):", md_files_pathlib)
# 示例：查找 'test_files/data' 目录下的所有 .png 文件
png_files_pathlib = find_files_pathlib_non_recursive('test_files/data', '.png')
print("pathlib 查找 .png 文件 (非递归):", png_files_pathlib)

输出示例：
pathlib 查找 .md 文件 (非递归): ['test_files/']
pathlib 查找 .png 文件 (非递归): ['test_files/data/']

注意：() 返回一个迭代器，包含目录中的所有 Path 对象。Path.is_file() 检查是否是文件，获取文件扩展名。

3.2 递归查找：() 与 ()

Path 对象提供了 .glob() 和 .rglob() 方法，它们是 glob 模块功能的面向对象封装，更易用。
(pattern)：在当前 Path 对象表示的目录下进行模式匹配（非递归，除非模式中包含）。
(pattern)：递归地在当前 Path 对象表示的目录下进行模式匹配，等同于 ('/' + pattern)。

from pathlib import Path
# 示例：使用查找 'test_files/docs' 目录下的所有 .txt 文件
# 注意：这里的 glob 不会递归到 docs 的子目录（如果有的话）
docs_txt_files = list(Path('test_files/docs').glob('*.txt'))
print(" 查找 test_files/docs 下的 .txt 文件:", [str(p) for p in docs_txt_files])
# 示例：使用递归查找 'test_files' 及其子目录下所有 .txt 文件
all_txt_files_pathlib = list(Path('test_files').rglob('*.txt'))
print(" 查找所有 .txt 文件:", [str(p) for p in all_txt_files_pathlib])
# 示例：查找文件名中包含 'report' 的所有 CSV 文件 (递归)
report_csv_files = list(Path('test_files').rglob('*report*.csv'))
print(" 查找包含 'report' 的 .csv 文件:", [str(p) for p in report_csv_files])

输出示例：
查找 test_files/docs 下的 .txt 文件: ['test_files/docs/', 'test_files/docs/']
查找所有 .txt 文件: ['test_files/docs/', 'test_files/docs/']
查找包含 'report' 的 .csv 文件: ['test_files/reports/']

总结：pathlib 模块提供了现代、面向对象的API，让文件系统操作更加Pythonic。它的 Path 对象封装了路径的各种属性和方法，.glob() 和 .rglob() 使得模式匹配既强大又简洁。对于新的项目和希望提高代码可读性的开发者来说，pathlib 是强烈推荐的选择。

四、高级过滤与优化

除了基于扩展名和通配符的查找，我们可能还需要更复杂的过滤逻辑，例如基于文件名中的特定模式、文件大小、修改时间等。

4.1 使用正则表达式进行高级文件名匹配

当通配符不足以表达复杂的匹配规则时，可以结合 re 模块的正则表达式进行更精确的过滤。这通常与 () 或 () 结合使用。
import os
import re
from pathlib import Path
def find_files_with_regex(directory, pattern):
"""
递归查找文件名匹配指定正则表达式模式的文件。
"""
found_files = []
regex = (pattern)
for root, _, files in (directory):
for file in files:
if (file): # 使用从文件名的开头匹配
((root, file))
return found_files
# 示例：查找文件名以 'sales' 开头，且扩展名为 .xlsx 的文件 (忽略大小写)
# 注意：默认从字符串开头匹配。如果想在文件名任意位置匹配，可以使用
sales_files = find_files_with_regex('test_files', r'sales_.*\.xlsx')
print("正则表达式查找 sales_*.xlsx 文件:", sales_files)
# 使用 pathlib 结合正则表达式
def find_files_pathlib_regex(directory, pattern):
found_files = []
regex = (pattern)
base_path = Path(directory)
for file_path in ('*'): # 遍历所有文件和目录
if file_path.is_file() and ():
(str(file_path))
return found_files
# 示例：查找文件名以 'report_' 开头，接着是日期模式（例如 YYYY-MM）的 CSV 文件
report_pattern = r'report_\d{4}-\d{2}\.csv'
report_date_files = find_files_pathlib_regex('test_files', report_pattern)
print("正则表达式查找文件:", report_date_files)

输出示例：
正则表达式查找 sales_*.xlsx 文件: ['test_files/reports/2023/']
正则表达式查找文件: ['test_files/reports/']

4.2 基于文件大小或修改时间过滤

在 () 或 pathlib 遍历文件的过程中，可以结合 () 获取文件大小，() 获取文件最后修改时间（时间戳），进一步细化过滤条件。
import os
import time
from datetime import datetime
def find_large_files(directory, min_size_kb):
"""
查找大于指定大小的文件 (递归)。
"""
found_files = []
for root, _, files in (directory):
for file in files:
full_path = (root, file)
try:
if (full_path) > min_size_kb * 1024: # 转换为字节
(full_path)
except OSError:
# 忽略无法访问的文件
continue
return found_files
# 示例：查找 test_files 目录下所有大于 1KB 的文件 (当前所有创建的文件都非常小，所以可能为空)
# 为演示效果，我们将文件写入一些内容使其变大
with open('test_files/', 'w') as f:
('A' * 2000) # 2KB
large_files = find_large_files('test_files', 1)
print("查找大于 1KB 的文件:", large_files)
def find_recent_files(directory, days_ago):
"""
查找在指定天数内修改过的文件 (递归)。
"""
found_files = []
cutoff_timestamp = () - (days_ago * 24 * 60 * 60)
for root, _, files in (directory):
for file in files:
full_path = (root, file)
try:
if (full_path) > cutoff_timestamp:
(full_path)
except OSError:
continue
return found_files
# 示例：查找 test_files 目录下过去 7 天内修改过的所有文件
# 注意：由于所有文件都是刚刚创建的，所以应该都能被找到
recent_files = find_recent_files('test_files', 7)
print("查找过去 7 天内修改过的文件:", recent_files)
```

输出示例：
查找大于 1KB 的文件: ['test_files/']
查找过去 7 天内修改过的文件: ['test_files/', 'test_files/', 'test_files/', 'test_files/', 'test_files/docs/', 'test_files/docs/', 'test_files/reports/', 'test_files/reports/2023/', 'test_files/data/', 'test_files/data/']

4.3 性能考虑：迭代器与列表

当处理大型文件系统时，性能是一个重要考量。()、() 和 ()/() 都返回迭代器，它们按需生成结果，避免一次性将所有结果加载到内存中，这对于资源有限的环境或需要处理海量文件的情况非常有利。而 () 则会一次性构建并返回一个完整的列表。

如果查找结果量较小，两者性能差异不明显。但对于潜在的大量文件，优先选择迭代器版本的函数。

五、选择合适的工具

根据您的具体需求，选择最合适的Python工具至关重要：
os 模块 (特别是 ()):

优点：最底层、最灵活，可以完全控制目录遍历过程；可以轻松获取文件大小、修改时间等元数据。
缺点：语法相对繁琐，需要手动拼接路径、判断文件类型。
适用场景：需要深入控制文件系统交互，进行复杂的文件属性过滤，或在Python 3.4之前的版本。

glob 模块:

优点：简洁的通配符模式匹配，非常适合快速、简单的文件查找；iglob() 提供迭代器。
缺点：匹配能力有限，不适用于复杂的模式；递归功能 () 需要 Python 3.5+。
适用场景：只需要基于文件名模式进行简单匹配，例如查找所有 .log 文件或 * 文件。

pathlib 模块:

优点：面向对象，API 设计优雅，代码可读性高；自动处理跨平台路径问题；.glob() 和 .rglob() 集成了模式匹配功能。
缺点： Python 3.4+ 才可用；对于一些极端复杂的底层操作，可能仍需回到 os 模块。
适用场景：大多数现代Python文件系统操作的首选，兼顾简洁性、可读性和功能性。

re 模块 (结合其他模块):

优点：提供强大的正则表达式匹配能力，能够处理最复杂的字符串模式。
缺点：正则表达式本身学习成本较高，可能降低代码可读性。
适用场景：文件名匹配规则极其复杂，例如需要匹配特定日期格式、版本号模式等。