Python 中如何优雅的处理文件

pathlib是Python 3.4及以上版本中引入的一个面向对象的文件系统路径库，它提供了更简洁、更易读的API，同时避免了操作系统路径分隔符的差异问题。

文件基础操作

创建目录mkdir()

from pathlib import Path
 
# 创建多级目录
new_dir = Path('data/reports/2025')
new_dir.mkdir(parents=True, exist_ok=True)  # parents=True 创建多级目录，exist_ok=True 避免目录已存在时报错

读取文件 read_text()

# 读取文件内容
file_path = Path('data/reports/2025/report.txt')
if file_path.exists():
    content = file_path.read_text(encoding='utf-8')  # 指定编码避免编码问题
    print(content)

重命名文件 rename()

 
# 重命名文件
old_file = Path('data/reports/2025/summary.txt')
new_file = Path('data/reports/2025/report_summary.txt')
old_file.rename(new_file)

删除文件 unlink()

这个和PHP中删除文件一致。

 
# 删除文件
temp_file = Path('data/reports/2025/temp.txt')
if temp_file.exists():  # 检查文件是否存在
    temp_file.unlink()

遍历目录

 
# 遍历目录下的所有txt文件
report_dir = Path('data/reports/2025')
for txt_file in report_dir.glob('**/*.txt'):  # 使用glob模式匹配文件
    print(f'找到文件：{txt_file.name}')

glob 模块提供了一个函数 glob.glob()，用于返回所有匹配指定模式的路径列表。

它还提供了一个生成器版本 glob.iglob()，用于逐个生成匹配的路径。

使用with语句处理文件

with语句可以确保文件在使用后正确关闭，即使在文件操作过程中发生异常也是如此。这是处理文件时的最佳实践。

# 读取文件
file_path = Path('data/reports/2025/report.txt')
with file_path.open('r', encoding='utf-8') as file:  # 使用with语句
    content = file.read()
    print(content)

# 写入文件
file_path = Path('data/reports/2025/summary.txt')
with file_path.open('w', encoding='utf-8') as file:  # 使用with语句
    file.write('这是一个总结文件。')

处理文件时的错误和异常

在文件操作中，可能会遇到各种异常，如文件不存在、权限不足等。使用try-except块可以优雅地处理这些异常。

 
file_path = Path('data/reports/2025/report.txt')
try:
    with file_path.open('r', encoding='utf-8') as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print(f"文件 {file_path} 不存在。")
except PermissionError:
    print(f"没有权限读取文件 {file_path}。")
except Exception as e:
    print(f"读取文件时发生错误：{e}")

使用临时文件

如果需要处理临时数据，可以使用tempfile模块来创建临时文件和目录。这些临时文件在使用后可以自动删除。

 
import tempfile
from pathlib import Path
 
# 创建临时文件
with tempfile.NamedTemporaryFile(delete=False) as temp_file:
    temp_path = Path(temp_file.name)
    temp_path.write_text('临时数据', encoding='utf-8')
 
# 使用临时文件
print(temp_path.read_text(encoding='utf-8'))
 
# 删除临时文件
temp_path.unlink()

处理大文件

对于大文件，一次性读取整个文件内容可能会导致内存不足。可以使用逐行读取或分块读取的方式来处理大文件。

# 逐行读取大文件
file_path = Path('data/reports/2025/big_file.txt')
with file_path.open('r', encoding='utf-8') as file:
    for line in file:
        process_line(line)  # 假设有一个处理每一行的函数

def read_in_chunks(file_path, chunk_size=1024*1024):
    with file_path.open('r', encoding='utf-8') as file:
        while True:
            chunk = file.read(chunk_size)
            if not chunk:
                break
            yield chunk
 
file_path = Path('data/reports/2025/big_file.txt')
for chunk in read_in_chunks(file_path):
    process_chunk(chunk)  # 假设有一个处理每个块的函数

使用上下文管理器

它可以帮助你在特定的上下文中管理资源，确保资源在使用后正确释放。

对于更复杂的文件操作，定义自己的上下文管理器可以让你更好地控制文件的打开、处理和关闭过程。

Python的contextlib模块提供了一个装饰器contextmanager，可以用来定义自己的上下文管理器。

这种方式不需要显式定义 __enter__和__exit__方法，而是通过生成器函数来实现上下文管理。

要实现以下功能：

打开一个输入文件，逐行读取内容。
对每一行内容进行某种处理（例如，将内容转换为大写）。
将处理后的结果写入到一个输出文件中。
确保在操作完成后，输入文件和输出文件都被正确关闭。

 
from contextlib import contextmanager
 
@contextmanager
def process_files(input_path, output_path):
    try:
        # 打开输入文件和输出文件
        input_file = open(input_path, 'r', encoding='utf-8')
        output_file = open(output_path, 'w', encoding='utf-8')
        
        # 逐行读取输入文件内容并处理
        for line in input_file:
            processed_line = line.strip().upper()  # 示例处理：去掉首尾空白并转换为大写
            output_file.write(processed_line + '\n')
        
        # 返回输出文件路径，以便外部可以使用
        yield output_path
    except Exception as e:
        print(f"处理文件时发生错误：{e}")
    finally:
        # 确保文件被正确关闭
        input_file.close()
        output_file.close()
 
# 使用自定义上下文管理器
input_file_path = 'data/input.txt'
output_file_path = 'data/output.txt'
 
with process_files(input_file_path, output_file_path) as processed_file:
    print(f"处理后的文件已保存到：{processed_file}")

在上下文管理器中使用 yield 是 contextlib.contextmanager 装饰器的核心机制，

它允许你在上下文管理器中暂停执行，并将控制权交回给 with 块中的代码。

避免硬编码路径

硬编码路径可能会导致代码在不同环境中无法运行。可以使用相对路径或通过配置文件、环境变量等方式动态获取路径。

from pathlib import Path
 
# 获取当前脚本的目录
current_dir = Path(__file__).parent
data_dir = current_dir / 'data' / 'reports' / '2025'

日志记录

在处理文件时，记录日志可以帮助调试和追踪问题。可以使用logging模块来记录文件操作的日志。

import logging
 
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
file_path = Path('data/reports/2025/report.txt')
try:
    with file_path.open('r', encoding='utf-8') as file:
        content = file.read()
        logging.info(f"成功读取文件 {file_path}")
        print(content)
except Exception as e:
    logging.error(f"读取文件 {file_path} 时发生错误：{e}")

shutil模块

shutil模块提供了许多高级的文件操作功能，如复制、移动、删除整个目录树等。这些功能在处理复杂的文件操作时非常有用。

复制文件和目录

import shutil
from pathlib import Path
 
# 复制单个文件
src_file = Path('data/input.txt')
dst_file = Path('data/output.txt')
shutil.copy(src_file, dst_file)
 
# 复制整个目录
src_dir = Path('data/reports/2025')
dst_dir = Path('data/reports/2025_backup')
shutil.copytree(src_dir, dst_dir)

移动文件和目录

# 移动文件
src_file = Path('data/input.txt')
dst_file = Path('data/backup/input.txt')
shutil.move(src_file, dst_file)
 
# 移动整个目录
src_dir = Path('data/reports/2025')
dst_dir = Path('data/backup/reports/2025')
shutil.move(src_dir, dst_dir)

删除整个目录

dir_to_delete = Path('data/backup')
shutil.rmtree(dir_to_delete)

使用io模块

并行文件处理

使用concurrent.futures模块进行并行文件处理

对于需要处理大量文件的场景，可以使用concurrent.futures模块来并行处理文件，提高效率。

import concurrent.futures
from pathlib import Path
 
def process_file(file_path):
    with file_path.open('r', encoding='utf-8') as file:
        content = file.read()
        return content.upper()  # 示例处理：将内容转换为大写
 
# 获取所有文件路径
files_dir = Path('data/reports/2025')
file_paths = list(files_dir.glob('*.txt'))
 
# 使用线程池并行处理文件
with concurrent.futures.ThreadPoolExecutor() as executor:
    results = list(executor.map(process_file, file_paths))
 
# 打印处理结果
for result in results:
    print(result)

io模块

io模块确实提供了更底层的文件操作功能，特别适合处理二进制数据或需要更细粒度控制的场景。

io模块包含了一系列用于处理输入/输出流的类，这些类提供了更灵活和高效的方式来操作文件和数据。

文本流和二进制流

io.TextIOWrapper：用于处理文本数据，支持编码和解码。
io.BytesIO：用于处理二进制数据，适合在内存中读写二进制数据。
io.StringIO：用于处理文本数据，适合在内存中读写字符串。

低级文件描述符

io.open()：底层的文件打开函数，返回一个文件对象，可以用于更细粒度的控制。
io.FileIO：用于直接操作文件描述符，适合需要直接控制文件读写操作的场景。

读取和写入二进制文件

 
import io
from pathlib import Path
 
# 读取二进制文件
binary_file = Path('data/image.png')
with binary_file.open('rb') as file:
    binary_data = file.read()
 
# 在内存中处理二进制数据
binary_stream = io.BytesIO(binary_data)
# 例如，你可以在这里对binary_stream中的数据进行处理
 
# 将处理后的数据写入到新的二进制文件
output_binary_file = Path('data/output_image.png')
with output_binary_file.open('wb') as file:
    file.write(binary_stream.getvalue())

在内存中处理文本数据

 
import io
 
# 创建一个StringIO对象
text_stream = io.StringIO()
 
# 写入文本数据
text_stream.write('Hello, ')
text_stream.write('world!')
 
# 获取内存中的文本数据
text_data = text_stream.getvalue()
print(text_data)  # 输出: Hello, world!
 
# 关闭流
text_stream.close()

使用`io.open()`进行低级文件操作

 
import io
from pathlib import Path
 
# 打开文件进行读写操作
file_path = Path('data/output.txt')
with io.open(file_path, 'w', encoding='utf-8') as file:
    file.write('Hello, world!')
 
# 读取文件内容
with io.open(file_path, 'r', encoding='utf-8') as file:
    content = file.read()
    print(content)  # 输出: Hello, world!