Python 文件操作：读取、写入和追加写入

模式	描述	典型场景
`'r'`	只读（默认）	读取文本文件内容
`'w'`	覆盖写入（若文件存在会清空内容，不存在则创建）	创建新文件或重置旧文件
`'x'`	独占创建（仅在文件不存在时创建）	防止意外覆盖重要文件
`'a'`	追加写入（在文件末尾添加内容）	日志文件续写、数据记录
`'b'`	二进制模式（需配合 `'r'`/`'w'` 使用）	处理图片、视频等非文本文件
`'t'`	文本模式（默认）	常规文本处理
`'+'`	读写模式（需配合 `'r'`/`'w'`/`'a'` 使用）	同时需要读写操作的场景

组合模式示例：

'r+'：以读写模式打开文件，文件指针在开头
'w+'：以读写模式打开文件，会清空原内容
'a+'：以读写模式打开文件，文件指针在末尾

二、基础文件操作

1. 读取文件内容

方法 1：一次性读取全部内容

with open('data.txt', 'r') as file:  # 使用 with 自动管理文件关闭
    content = file.read()            # 读取全部内容为字符串
print("文件内容：\n", content)

适用场景：小文件快速读取
缺点：大文件可能占用过多内存

方法 2：逐行读取

with open('data.txt', 'r') as file:
    for line in file:                # 逐行迭代，内存友好
        print(line.strip())          # strip() 移除行尾换行符

优势：适合处理大文件，避免内存溢出
注意：line 变量包含换行符，可用 strip() 清理

方法 3：读取为列表

with open('data.txt', 'r') as file:
    lines = file.readlines()        # 返回包含每行内容的列表
print("总行数：", len(lines))
for idx, line in enumerate(lines, 1):
    print(f"第{idx}行：{line.strip()}")

适用场景：需要随机访问行内容或统计行数

2. 写入文件（覆盖模式）

with open('output.txt', 'w') as file:  # 使用 'w' 模式
    file.write("Hello World!\n")       # 写入单行内容（需手动添加换行符）
    file.writelines([                  # 写入多行内容
        "Line 1\n", 
        "Line 2\n",
        "Line 3\n"
    ])
    file.flush()  # 立即将缓冲区数据写入磁盘（非必须，close()会自动调用）

关键点：
- write() 不会自动换行，需在字符串末尾加 \n
- writelines() 接收字符串列表，同样需自行处理换行
风险提示：'w' 模式会直接清空原文件内容，务必确认文件可覆盖！

3. 追加写入

with open('log.txt', 'a') as file:     # 使用 'a' 模式
    file.write("2023-10-01 09:00:00 - 系统启动\n")
    file.write("2023-10-01 10:30:00 - 用户登录\n")
    file.flush()  # 确保日志立即写入，防止程序崩溃丢失数据

特点：
- 文件不存在时会自动创建
- 写入内容始终添加到文件末尾
典型应用：日志记录、数据追加存储

三、常用文件操作技巧

1. 同时读写文件（`'r+'`/`'w+'`/`'a+'`）

with open('data.txt', 'r+') as file:
    content = file.read()             # 先读取内容
    file.seek(0)                      # 将指针移回文件开头
    file.write("New Header\n" + content)  # 在开头插入新内容

操作逻辑：
1. 读取原内容
2. 移动指针到目标位置（此处为开头）
3. 写入新内容（可能覆盖部分原有内容）
注意：'r+' 不会清空文件，而 'w+' 会先清空

2. 二进制文件操作

# 复制图片文件
with open('photo.jpg', 'rb') as src:  # 二进制读取
    with open('photo_copy.jpg', 'wb') as dst:  # 二进制写入
        while True:
            chunk = src.read(4096)    # 每次读取 4KB
            if not chunk:             # 读取结束
                break
            dst.write(chunk)
        dst.flush()  # 确保所有数据写入磁盘（close()会自动处理）

关键点：
- 'rb'/'wb' 必须用于非文本文件
- 分块读取（如 read(4096)）可高效处理大文件

3. 文件指针控制（`seek()`）

with open('data.txt', 'r+') as file:
    file.seek(5)           # 移动指针到第5个字节
    print(file.read(3))    # 读取3个字符 → 输出第5-7字节内容
    file.seek(0, 2)        # 第二个参数：0=开头，1=当前，2=末尾
    file.write("\nEOF")    # 在文件末尾追加内容

seek(offset, whence) 参数说明：
- whence=0（默认）：从文件开头计算偏移
- whence=1：从当前位置计算
- whence=2：从文件末尾计算

4. 文件关闭与缓冲区刷新（`close()` 与 `flush()`）

`close()` 方法

作用：关闭文件并释放系统资源，同时自动调用 flush() 确保缓冲区数据写入磁盘。
必要性：
- 未关闭的文件会占用系统资源，可能导致程序崩溃或数据丢失。
- 使用 with 语句可自动关闭文件（推荐），手动操作时需显式调用：
```
file = open('data.txt', 'r')
content = file.read()
file.close()  # 必须手动关闭！
```

`flush()` 方法

作用：强制将缓冲区数据写入磁盘，无需关闭文件。
适用场景：
- 长时间运行的程序中，需确保关键数据实时保存（如日志记录）。
- 调试时验证写入内容是否已持久化。

示例：

with open('log.txt', 'a') as file:
    file.write("重要操作记录...\n")
    file.flush()  # 立即写入，防止程序崩溃丢失记录

注意：频繁调用 flush() 可能影响性能，需权衡实时性和效率。

四、最佳实践与注意事项

1. 强制使用 `with` 语句

# 传统写法（不推荐）
file = open('data.txt', 'r')
try:
    content = file.read()
finally:
    file.close()  # 必须手动关闭

# with语句写法（推荐）
with open('data.txt', 'r') as file:  # 自动处理关闭和异常
    content = file.read()

优势：自动处理文件关闭，即使发生异常也能保证资源释放

2. 明确指定文件编码

with open('data.txt', 'r', encoding='utf-8') as file:
    content = file.read()

# 处理特殊编码文件（如GBK）
with open('data_gbk.txt', 'r', encoding='gbk') as file:
    content = file.read()

常见编码：
- utf-8：国际通用，支持多语言（推荐默认使用）
- gbk：中文编码
错误处理：可添加 errors='ignore' 参数忽略解码错误

3. 大文件处理策略

def process_large_file(filename):
    with open(filename, 'r') as file:
        while True:
            line = file.readline()     # 逐行读取
            if not line:               # 读取结束
                break
            process(line)              # 处理单行内容

# 或分块读取（适合无换行符的二进制文件）
def process_in_chunks(filename, chunk_size=1024):
    with open(filename, 'rb') as file:
        while True:
            chunk = file.read(chunk_size)
            if not chunk:
                break
            process(chunk)

4. 谨慎处理文件关闭与刷新

避免资源泄漏：始终通过 with 或显式 close() 关闭文件。
数据完整性：在关键操作后调用 flush()，确保数据持久化。
关系说明：close() 会自动调用 flush()，但两者适用场景不同：
- flush()：需保留文件打开状态继续操作时使用。
- close()：操作完成后释放资源。

五、常见错误与解决方案

1. 文件未关闭导致资源泄漏

file = open('data.txt', 'w')
file.write("测试内容")
# 忘记调用 file.close() → 文件句柄未释放，可能引发程序性能问题

修复：使用 with 语句或确保手动调用 close()。

2. 缓冲区数据未写入

file = open('log.txt', 'a')
file.write("关键操作记录")
# 程序崩溃 → 缓冲区内容可能丢失

修复：在写入后调用 flush() 或使用 with 语句自动处理。

3. 文件不存在错误

try:
    with open('missing.txt', 'r') as file:
        content = file.read()
except FileNotFoundError:
    print("错误：文件不存在！")
    # 可选：创建新文件
    open('missing.txt', 'w').close()

4. 权限不足

try:
    with open('/system/file', 'w') as file:
        file.write("test")
except PermissionError:
    print("错误：没有写入权限！")

5. 编码不一致

try:
    with open('data.txt', 'r', encoding='utf-8') as file:
        content = file.read()
except UnicodeDecodeError:
    print("错误：文件编码不符合utf-8！")
    # 尝试其他编码
    with open('data.txt', 'r', encoding='gbk') as file:
        content = file.read()

六、核心知识点总结

1. 核心操作要点

分类	关键内容
打开模式	`r`（只读）、`w`（覆盖）、`a`（追加）、`b`（二进制）、`+`（读写）
读取方法	`read()`、`readline()`、`readlines()`、逐行迭代
写入方法	`write()`、`writelines()`（需手动处理换行符）
指针控制	`seek(offset, whence)` 移动指针位置
资源管理	`with` 语句自动关闭文件，`close()` 显式关闭，`flush()` 强制刷新缓冲区

2. 核心原则

安全第一：始终优先使用 with 语句，避免资源泄漏。
编码明确：指定 encoding 参数（如 utf-8），处理多语言文本。
大文件策略：逐行或分块读写（read(1024)、readline()）。
缓冲区控制：
- flush()：实时保存关键数据（如日志），无需关闭文件。
- close()：自动调用 flush() 并释放资源，必须显式或通过 with 执行。