【Python入门】Python文件操作终极指南：从基础到高阶实战

大家好，我是唐叔！今天为大家带来一篇全面系统的Python文件操作指南。无论是刚入门的新手还是有经验的开发者，都能从这篇文章中找到有价值的内容。我们将按照由浅入深的顺序，全面讲解Python文件操作的各个方面。

一、Python文件操作基础

1. 打开文件

文件操作的第一步就是打开文件，Python使用内置的open()函数：

file = open('example.txt', 'r', encoding='utf-8')

关键参数解析：

• file：文件路径（相对或绝对）
• mode：打开模式（详见下文）
• encoding：指定文件编码（推荐utf-8）

常用打开模式：

• 'r'：只读（默认）
• 'w'：写入（会覆盖）
• 'a'：追加
• 'b'：二进制模式
• '+'：读写模式

2. 关闭文件

文件使用完毕后必须关闭，否则可能导致资源泄漏：

file.close()

推荐做法：使用with语句自动管理

with open('example.txt', 'r') as file:
    # 操作文件
    # 离开with块自动关闭

3. 文件状态检查

3.1 使用os模块

import os

# 检查文件是否存在
os.path.exists('file.txt')

# 获取文件大小（字节）
os.path.getsize('file.txt')

# 获取修改时间
os.path.getmtime('file.txt')

3.2 使用pathlib模块

from pathlib import Path

path = Path('file.txt')
if path.exists():
    print(f"大小: {path.stat().st_size}字节")

注意：需要Python3.4+才能使用 pathlib 模块

二、Python文件读写操作

1. 基础文件读写方法

1.1 基础文件读取方法

方法	描述	适用场景
read()	读取全部内容	文件较小，需要一次性处理全部内容时使用。
readline()	读取一行	需要按行处理大文件，节省内存。
readlines()	读取所有行（返回列表）	需要将所有行存储在列表中进一步处理，适合中小文件。

示例：

with open('example.txt', 'r', encoding='utf-8') as file:
    content = file.read()  # 读取全部内容为一个字符串

with open('example.txt', 'r', encoding='utf-8') as file:
    line = file.readline()  # 每次读取一行
    while line:
        print(line, end='')
        line = file.readline()

with open('example.txt', 'r', encoding='utf-8') as file:
    lines = file.readlines()  # 返回包含所有行的列表

1.2 基本文件写入方法

方法	描述	特点
write()	写入字符串	* 不会自动添加换行符 * 可以多次调用，内容会连续写入 * 适合写入单个字符串或少量内容
writelines()	写入多行	* 接受一个字符串序列（列表、元组等） * 不会自动添加换行符，需要自己包含在字符串中 * 比循环调用write()更高效

示例：

with open('output.txt', 'w', encoding='utf-8') as file:
    file.write("Hello, Python!\n")  # 写入字符串，注意换行符需要自己添加

lines = ["第一行\n", "第二行\n", "第三行\n"]
with open('output.txt', 'w', encoding='utf-8') as file:
    file.writelines(lines)  # 写入字符串列表

文件写入模式对比：

模式	文件存在时	文件不存在时
‘w’	覆盖	创建
‘a’	追加	创建
‘x’	报错	创建

2. 高效文件读写方法

2.1 高效文件读取方法

1. 直接迭代文件对象

with open('large.txt') as f:
 for line in f:
     process(line)

优势：内存效率高，特别适合处理大文件。

2. 分块读取（处理大文件）

chunk_size = 1024  # 1KB
while True:
 chunk = f.read(chunk_size)
 if not chunk:
     break
 process(chunk)

适用场景：处理二进制大文件，如图片、视频等。

3. 使用seek()和tell()控制读取位置

f.seek(100)  # 移动到第100字节
pos = f.tell()  # 获取当前位置

4. 使用next()逐行读取

with open('example.txt', 'r', encoding='utf-8') as file:
    try:
        while True:
            line = next(file)
            print(line, end='')
    except StopIteration:
        pass

5. 部分读取

with open('example.txt', 'r', encoding='utf-8') as file:
    first_100_chars = file.read(100)  # 只读取前100个字符

2.2 高效文件写入方法

1. 缓冲区控制

with open('data.txt', 'w', buffering=1) as file:  # 行缓冲
    file.write("每行立即写入\n")

with open('data.txt', 'w', buffering=0) as file:  # 无缓冲
    file.write("立即写入磁盘")

2. 二进制写入

data = b'\x48\x65\x6c\x6c\x6f'  # "Hello"的二进制表示
with open('binary.bin', 'wb') as file:  # 注意'b'模式
    file.write(data)

3. 文件指针操作

with open('data.txt', 'w+') as file:  # 读写模式
    file.write("Hello World")
    file.seek(0)  # 回到文件开头
    content = file.read()  # 读取刚写入的内容

3. 不同文件类型读写方法

3.1 CSV文件读写

import csv

# 读取CSV
with open('data.csv') as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

# 写入CSV
with open('output.csv', 'w') as f:
    writer = csv.writer(f)
    writer.writerow(['name', 'age'])

3.2 JSON文件读写

import json

# 读取JSON
with open('data.json') as f:
    data = json.load(f)

# 写入JSON
with open('output.json', 'w') as f:
    json.dump(data, f, indent=2)

3.3 Excel文件读写

import pandas as pd

# 读取Excel
data = pd.read_excel('input.xlsx')

# 写入Excel
data.to_excel('output.xlsx', index=False)

三、Python文件其他操作

1. 文件目录基础操作

import os

# 创建目录
os.mkdir('new_dir')
os.makedirs('path/to/dir')  # 多级目录

# 删除目录
os.rmdir('empty_dir')  # 只能删除空目录
import shutil
shutil.rmtree('dir_with_content')  # 删除非空目录

# 列出目录内容
os.listdir('.')  # 简单列表
os.scandir('.')  # 更高效（返回迭代器）

2. 文件系统操作

import os
import shutil

# 重命名/移动文件
os.rename('old.txt', 'new.txt')

# 复制文件
shutil.copy2('source.txt', 'dest.txt')  # 保留元数据

# 删除文件
os.remove('file_to_delete.txt')

# 获取绝对路径
abs_path = os.path.abspath('relative.txt')

# 路径拼接
full_path = os.path.join('dir', 'subdir', 'file.txt')

3. 文件权限管理

import os
import stat

# 修改文件权限
os.chmod('script.py', stat.S_IRWXU)  # 用户读写执行

# 获取文件权限
mode = os.stat('file.txt').st_mode
is_readable = mode & stat.S_IRUSR  # 用户可读

4. 临时文件处理

import tempfile

# 创建临时文件
with tempfile.NamedTemporaryFile(delete=False) as tmp:
    tmp.write(b'临时数据')
    tmp_path = tmp.name  # 获取临时文件路径

# 创建临时目录
with tempfile.TemporaryDirectory() as tmpdir:
    print(f"临时目录: {tmpdir}")
    # 操作临时目录

5. 内存文件操作

from io import StringIO, BytesIO

# 文本内存文件
text_buffer = StringIO()
text_buffer.write("内存中的文本")
content = text_buffer.getvalue()

# 二进制内存文件
bytes_buffer = BytesIO()
bytes_buffer.write(b'\x01\x02\x03')
binary_data = bytes_buffer.getvalue()

6. 文件锁定（跨进程安全）

import fcntl  # Unix系统

with open('shared.txt', 'a') as f:
    fcntl.flock(f, fcntl.LOCK_EX)  # 获取排他锁
    f.write("安全写入\n")
    fcntl.flock(f, fcntl.LOCK_UN)  # 释放锁

四、实战案例

实战一：Nginx日志分析器

现在，让我们来做一个简单的实战案例：分析Nginx访问日志，统计访问量最高的IP地址。

假设我们有一个名为access.log的Nginx访问日志文件，格式如下：

192.168.1.1 - - [01/Jan/2023:00:00:01 +0800] "GET /index.html HTTP/1.1" 200 1234
192.168.1.2 - - [01/Jan/2023:00:00:02 +0800] "GET /about.html HTTP/1.1" 200 5678
192.168.1.1 - - [01/Jan/2023:00:00:03 +0800] "GET /contact.html HTTP/1.1" 200 9012

完整代码实现

from collections import defaultdict

def analyze_log_file(log_file):
    ip_count = defaultdict(int)

    with open(log_file, 'r') as f:
        for line in f:
            # 提取IP地址（简单处理，实际情况可能需要更复杂的正则）
            ip = line.split()[0]
            ip_count[ip] += 1

    # 按访问量排序
    sorted_ips = sorted(ip_count.items(), key=lambda x: x[1], reverse=True)

    # 打印结果
    print("Top 10访问IP:")
    for ip, count in sorted_ips[:10]:
        print(f"{ip}: {count}次")

if __name__ == "__main__":
    analyze_log_file('access.log')

代码解析

1. 使用defaultdict来统计每个IP出现的次数
2. 使用with语句安全地打开文件
3. 逐行读取日志文件，提取IP地址
4. 对统计结果进行排序
5. 输出访问量最高的10个IP

实战二：实现文件版本管理系统

import os
import shutil
from datetime import datetime
from pathlib import Path

class FileVersioner:
    def __init__(self, max_versions=5):
        self.max_versions = max_versions
        self.backup_dir = Path('.file_versions')
        self.backup_dir.mkdir(exist_ok=True)

    def save_version(self, filepath):
        """保存文件版本"""
        filepath = Path(filepath)
        if not filepath.exists():
            raise FileNotFoundError(f"文件不存在: {filepath}")

        # 生成版本文件名
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        version_file = self.backup_dir / f"{filepath.name}.{timestamp}"

        # 复制文件
        shutil.copy2(filepath, version_file)

        # 清理旧版本
        self._cleanup_versions(filepath.name)

    def _cleanup_versions(self, filename_prefix):
        """保留最近max_versions个版本"""
        versions = sorted(
            self.backup_dir.glob(f"{filename_prefix}.*"),
            key=os.path.getmtime
        )

        # 删除多余的旧版本
        for old_version in versions[:-self.max_versions]:
            old_version.unlink()

    def list_versions(self, filename):
        """列出所有版本"""
        return sorted(
            self.backup_dir.glob(f"{filename}.*"),
            key=os.path.getmtime,
            reverse=True
        )

    def restore_version(self, filename, version=None):
        """恢复指定版本"""
        versions = self.list_versions(filename)
        if not versions:
            raise ValueError("没有可用的版本")

        target = versions[0] if version is None else \
            next((v for v in versions if str(v).endswith(version)), None)

        if target is None:
            raise ValueError("指定版本不存在")

        shutil.copy2(target, filename)

# 使用示例
versioner = FileVersioner(max_versions=3)

# 保存当前版本
versioner.save_version('important_doc.txt')

# 列出所有版本
print("可用版本:")
for v in versioner.list_versions('important_doc.txt'):
    print(f" - {v.name.split('.')[-1]}")

# 恢复特定版本
versioner.restore_version('important_doc.txt', version='20230815_143022')

五、性能优化和注意事项

性能优化建议

1. 文件安全：

   • 重要操作先写临时文件，再重命名
   • 考虑文件锁机制处理并发写入

2. 缓冲区设置：根据场景调整缓冲区大小

3. 频繁读取：考虑使用io.StringIO或io.BytesIO

4. 二进制文件：使用'rb'模式打开，提高读取效率

5. 批量写入：多次小写入合并为一次大写入更高效

6. 异常处理：

   try:
       with open('important.txt', 'w') as file:
           file.write("关键数据")
   except IOError as e:
       print(f"写入文件失败: {e}")
   

常见陷阱

1. 资源泄漏：

   • 忘记关闭文件
   • 解决方案：使用with语句

2. 竞态条件：

   • 检查存在性后文件可能被修改
   • 解决方案：使用异常处理替代存在性检查

3. 跨平台问题：

   • 路径分隔符不同（Windows用\，Linux用/）
   • 解决方案：使用os.path或pathlib

4. 编码问题：

   • 不指定编码时使用系统默认编码
   • 解决方案：明确指定编码（如utf-8）

5. 大文件处理：

   • 一次性读取大文件导致内存不足
   • 解决方案：分块读取或逐行处理

六、总结

通过本文，我们系统学习了：

1. 基础操作：文件打开、关闭和状态检查
2. 读写方法：从基础到高效的多种读写技巧
3. 扩展操作：目录管理、权限控制等
4. 实战案例：日志分析和版本管理

我是唐叔，感谢阅读！如果觉得有帮助，请点赞收藏。有任何问题欢迎在评论区讨论。