Python开发从新手到专家：第十九章基础文件处理：File操作的奥妙-CSDN博客

本文链接：https://blog.csdn.net/caifox/article/details/149135895

在 Python 编程中，文件处理是一项不可或缺的技能。无论是处理文本数据、存储用户信息，还是读取配置文件，文件操作都扮演着重要的角色。本章将带你深入了解 Python 中的基础文件处理方法，从简单的读写操作到更高级的文件指针控制，逐步提升你的文件处理能力。

在日常编程中，我们经常会遇到需要与文件交互的场景。例如，读取日志文件以分析系统运行状态，将用户数据写入文件进行持久化存储，或者处理复杂的二进制文件。掌握文件处理的基本技巧，不仅可以帮助你更高效地完成这些任务，还能让你的代码更加健壮和可维护。

本章将从文件的基本操作入手，逐步介绍如何打开、读取、写入文件，以及如何处理文件操作中可能出现的异常。我们还会深入探讨文件指针的概念，以及如何通过文件指针实现更灵活的文件读写操作。此外，我们还会介绍一些实用的文件处理技巧，帮助你在实际开发中更高效地处理文件。

无论你是刚刚接触 Python 文件处理的新手，还是希望进一步提升文件操作能力的开发者，本章内容都将为你提供清晰的指导和实用的示例。让我们一起开启 Python 文件处理的探索之旅吧！

1. 文件处理基础概念

1.1 文件与文件系统

文件是计算机系统中存储数据的基本单位，它可以包含文本、图片、音频、视频等各种类型的数据。文件系统是操作系统用于管理和组织文件的机制，它定义了文件的存储、访问和管理方式。常见的文件系统有FAT32、NTFS（用于Windows系统）、ext4（用于Linux系统）等。文件系统的主要功能包括文件的创建、删除、读写、重命名、权限管理等。

文件的存储：文件以数据块的形式存储在磁盘上，文件系统负责将文件的数据分配到磁盘的不同位置，并记录文件的存储位置和大小等信息。例如，在NTFS文件系统中，文件的元数据（如文件名、大小、创建时间等）存储在主文件表（MFT）中，而文件的实际数据存储在磁盘的数据区域。
文件的访问：用户可以通过文件路径来访问文件，文件路径是文件在文件系统中的位置标识。文件路径可以是绝对路径，也可以是相对路径。绝对路径是从根目录开始的完整路径，而相对路径是从当前工作目录开始的路径。例如，在Windows系统中，一个文件的绝对路径可能是C:\Users\username\Documents\example.txt，而相对路径可能是Documents\example.txt。
文件的组织：文件系统通常采用树形结构来组织文件，文件夹（目录）是文件的容器，可以包含多个文件和其他文件夹。这种树形结构使得文件的组织更加清晰和方便。例如，在Linux系统中，根目录用/表示，其他文件夹和文件都位于根目录下，形成了一个层次化的目录结构。

1.2 文件路径与工作目录

文件路径是文件在文件系统中的位置标识，它对于文件的访问和操作至关重要。工作目录是当前程序或用户所在的目录，它是相对路径的基准点。在Python中，可以通过os模块来处理文件和路径工作目录。

获取当前工作目录：使用os.getcwd()函数可以获取当前工作目录。例如，os.getcwd()可能会返回'C:\Users\username\Documents'，表示当前工作目录是Documents文件夹。
改变工作目录：使用os.chdir(path)函数可以改变当前工作目录，其中path是目标目录的路径。例如，os.chdir('C:\Users\username\Documents\Projects')会将当前工作目录改变为Projects文件夹。
文件路径的拼接：使用os.path.join()函数可以将多个路径组件拼接成一个完整的路径。例如，os.path.join('C:\Users\username', 'Documents', 'example.txt')会返回'C:\Users\username\Documents\example.txt'。
文件路径的分割：使用os.path.split()函数可以将路径分割成目录部分和文件名部分。例如，os.path.split('C:\Users\username\Documents\example.txt')会返回('C:\Users\username\Documents', 'example.txt')。
获取文件的绝对路径：使用os.path.abspath(path)函数可以获取文件的绝对路径。例如，os.path.abspath('example.txt')会返回文件example.txt的绝对路径，如果当前工作目录是C:\Users\username\Documents，则返回'C:\Users\username\Documents\example.txt'。
判断路径是否存在：使用os.path.exists(path)函数可以判断指定路径是否存在。例如，os.path.exists('C:\Users\username\Documents\example.txt')会返回True或False，表示文件或目录是否存在。
判断路径是文件还是目录：使用os.path.isfile(path)和os.path.isdir(path)函数可以分别判断指定路径是否是文件或目录。例如，os.path.isfile('C:\Users\username\Documents\example.txt')会返回True，而os.path.isdir('C:\Users\username\Documents')会返回True。

2. 打开与关闭文件

2.1 使用 open 函数打开文件

在 Python 中，open() 函数是处理文件的基础。它用于打开一个文件，并返回一个文件对象，通过这个文件对象可以对文件进行读写等操作。

基本用法：open() 函数的基本语法是 open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)。其中，file 是要打开的文件的路径，mode 是文件的打开模式，默认为只读模式 'r'。
示例代码：

file_path = 'example.txt'
file = open(file_path, 'r')
content = file.read()
print(content)
file.close()

在这个例子中，open() 函数以只读模式 'r' 打开了 example.txt 文件，并将文件对象赋值给变量 file。然后通过 file.read() 方法读取文件的全部内容，并将其存储在变量 content 中。最后，使用 file.close() 方法关闭文件，释放系统资源。
注意事项：在打开文件时，如果文件不存在，且打开模式为写入模式（如 'w' 或 'a'），Python 会自动创建文件。但如果文件不存在且打开模式为只读模式 'r'，则会抛出 FileNotFoundError 异常。

2.2 文件模式介绍

open() 函数的 mode 参数用于指定文件的打开模式，不同的模式对应不同的文件操作权限。

常见模式：
- 'r'：只读模式，这是默认模式。如果文件不存在，会抛出 FileNotFoundError 异常。
- 'w'：写入模式。如果文件存在，会清空文件内容；如果文件不存在，会创建一个新文件。
- 'a'：追加模式。如果文件存在，会在文件末尾追加内容；如果文件不存在，会创建一个新文件。
- 'b'：二进制模式，用于处理二进制文件（如图片、音频等）。通常与 'r'、'w'、'a' 等模式结合使用，如 'rb'、'wb'、'ab'。
- '+'：更新模式，用于同时读写文件。通常与 'r'、'w'、'a' 等模式结合使用，如 'r+'、'w+'、'a+'。
示例代码：

# 写入模式
file = open('example.txt', 'w')
file.write('Hello, World!')
file.close()

# 追加模式
file = open('example.txt', 'a')
file.write('\nThis is a new line.')
file.close()

# 二进制写入模式
file = open('example.jpg', 'wb')
file.write(b'\x89PNG\r\n\x1a\n')
file.close()

在第一个例子中，以写入模式 'w' 打开文件，会清空文件内容并写入新内容。在第二个例子中，以追加模式 'a' 打开文件，会在文件末尾追加新内容。在第三个例子中，以二进制写入模式 'wb' 打开文件，用于写入二进制数据。

2.3 关闭文件的重要性

关闭文件是一个重要的步骤，它可以确保文件的更改被正确保存，并释放系统资源。

文件对象在使用完毕后，必须调用 close() 方法来关闭文件。如果文件没有正确关闭，可能会导致数据丢失或文件损坏。
示例代码：

file = open('example.txt', 'w')
file.write('Hello, World!')
# 如果忘记关闭文件，可能会导致文件内容没有正确保存
file.close()

在这个例子中，如果忘记调用 file.close() 方法，文件的内容可能不会被正确写入磁盘。
使用 with 语句：为了避免忘记关闭文件，可以使用 with 语句。with 语句会在代码块执行完毕后自动关闭文件，即使发生异常也会确保文件被正确关闭。

with open('example.txt', 'w') as file:
    file.write('Hello, World!')
# 文件在代码块结束后自动关闭

在这个例子中，使用 with 语句打开文件，文件会在代码块执行完毕后自动关闭，无需手动调用 file.close() 方法。

3. 读取文件内容

3.1 逐行读取文件

逐行读取文件是一种常见的文件读取方式，尤其适用于处理大型文件。这种方式可以避免一次性将整个文件内容加载到内存中，从而节省内存资源。

使用 readline() 方法：readline() 方法用于逐行读取文件内容。每次调用 readline() 会返回文件中的一行，直到文件末尾返回空字符串。
- 示例代码：

file_path = 'example.txt'
with open(file_path, 'r') as file:
    line = file.readline()
    while line:
        print(line.strip())  # 使用 strip() 去掉行尾的换行符
        line = file.readline()

在这个例子中，readline() 方法逐行读取文件内容，并通过 while 循环处理每一行。strip() 方法用于去掉每行末尾的换行符，使输出更加整洁。
使用 readlines() 方法：readlines() 方法会一次性读取文件的所有行，并将每行作为一个元素存储在列表中。这种方式适合处理较小的文件，因为它会将整个文件内容加载到内存中。
- 示例代码：

file_path = 'example.txt'
with open(file_path, 'r') as file:
    lines = file.readlines()
    for line in lines:
        print(line.strip())

在这个例子中，readlines() 方法将文件的所有行读取到一个列表中，然后通过 for 循环逐行处理。同样使用 strip() 方法去掉行尾的换行符。
逐行迭代：Python 提供了一种更简洁的方式来逐行读取文件内容，即直接对文件对象进行迭代。
- 示例代码：

file_path = 'example.txt'
with open(file_path, 'r') as file:
    for line in file:
        print(line.strip())

在这个例子中，直接对文件对象进行迭代，Python 会自动逐行读取文件内容，这种方式不仅简洁，而且效率较高。

3.2 读取整个文件内容

读取整个文件内容通常用于处理较小的文件，这种方式可以一次性将文件的全部内容加载到内存中，便于后续处理。

使用 read() 方法：read() 方法用于读取文件的全部内容，并将其作为一个字符串返回。
- 示例代码：

file_path = 'example.txt'
with open(file_path, 'r') as file:
    content = file.read()
    print(content)

在这个例子中，read() 方法将文件的全部内容读取到一个字符串变量 content 中，然后通过 print() 函数输出。这种方式适合处理文本文件，尤其是文件内容较小的情况。
读取二进制文件：对于二进制文件（如图片、音频等），可以使用 'rb' 模式打开文件，并使用 read() 方法读取其内容。
- 示例代码：

file_path = 'example.jpg'
with open(file_path, 'rb') as file:
    binary_content = file.read()
    print(binary_content)

在这个例子中，以二进制模式 'rb' 打开文件，read() 方法将文件的二进制内容读取到变量 binary_content 中。二进制内容通常以字节序列的形式表示，因此输出可能包含不可打印的字符。
分块读取：如果文件较大，一次性读取整个文件内容可能会占用大量内存。此时可以采用分块读取的方式，逐块读取文件内容。
- 示例代码：

file_path = 'large_file.txt'
chunk_size = 1024  # 每次读取1024字节
with open(file_path, 'r') as file:
    while True:
        chunk = file.read(chunk_size)
        if not chunk:
            break
        print(chunk)

在这个例子中，通过设置 chunk_size 参数，每次读取指定大小的数据块。当读取到文件末尾时，read() 方法会返回空字符串，此时退出循环。这种方式可以有效减少内存占用，适用于处理大型文件。

4. 写入文件内容

4.1 写入文本文件

在 Python 中，写入文本文件是一个常见的操作，用于将数据保存到文件中以便后续使用或分享。以下是一些常见的写入文本文件的方法和示例。

基本写入操作

使用 write() 方法：write() 方法用于将字符串写入文件。如果文件不存在，会自动创建文件；如果文件已存在，会根据打开模式决定是否覆盖或追加内容。
- 示例代码：

file_path = 'example.txt'
with open(file_path, 'w') as file:  # 以写入模式打开文件
    file.write('Hello, World!\n')  # 写入一行文本
    file.write('This is another line.\n')  # 写入另一行文本

在这个例子中，write() 方法将文本内容写入文件。每次调用 write() 方法时，内容会连续写入文件，不会自动添加换行符，因此需要手动添加换行符 \n。

追加内容

使用追加模式 'a'：如果希望在文件末尾追加内容，而不是覆盖原有内容，可以使用追加模式 'a'。
- 示例代码：

file_path = 'example.txt'
with open(file_path, 'a') as file:  # 以追加模式打开文件
    file.write('This is a new line appended to the file.\n')

在这个例子中，以追加模式 'a' 打开文件，写入的内容会被添加到文件末尾，不会覆盖原有内容。

写入多行内容

使用 writelines() 方法：writelines() 方法可以一次性写入多行内容，但需要将内容存储在一个列表中，每行作为一个元素。
- 示例代码：

file_path = 'example.txt'
lines = ['Line 1\n', 'Line 2\n', 'Line 3\n']
with open(file_path, 'w') as file:  # 以写入模式打开文件
    file.writelines(lines)  # 写入多行内容

在这个例子中，writelines() 方法将列表中的每一行内容写入文件。需要注意的是，writelines() 方法不会自动添加换行符，因此需要在每行内容中手动添加换行符 \n。

写入格式化内容

使用格式化字符串：在写入文件时，可以使用格式化字符串来动态生成内容。
- 示例代码：

file_path = 'example.txt'
name = 'Alice'
age = 30
with open(file_path, 'w') as file:  # 以写入模式打开文件
    file.write(f'Name: {name}, Age: {age}\n')

在这个例子中，使用格式化字符串 f'Name: {name}, Age: {age}\n' 将变量 name 和 age 的值动态插入到字符串中，并写入文件。

4.2 写入二进制文件

写入二进制文件与写入文本文件类似，但需要使用二进制模式 'wb' 打开文件，并写入二进制数据。二进制数据通常以字节序列的形式表示。

写入二进制数据

使用 write() 方法：在二进制模式下，write() 方法用于写入字节序列。
- 示例代码：

file_path = 'example.bin'
data = b'\x01\x02\x03\x04'  # 二进制数据
with open(file_path, 'wb') as file:  # 以二进制写入模式打开文件
    file.write(data)  # 写入二进制数据

在这个例子中，以二进制写入模式 'wb' 打开文件，写入字节序列 b'\x01\x02\x03\x04'。二进制数据以字节序列的形式表示，每个字节用 \x 后跟两位十六进制数表示。

写入图片或其他二进制文件

写入图片文件：可以使用二进制模式写入图片文件或其他二进制文件。
- 示例代码：

file_path = 'example.jpg'
with open(file_path, 'rb') as source_file:  # 以二进制读取模式打开源文件
    data = source_file.read()  # 读取二进制内容
with open('copy_example.jpg', 'wb') as target_file:  # 以二进制写入模式打开目标文件
    target_file.write(data)  # 写入二进制内容

在这个例子中，首先以二进制读取模式 'rb' 打开源图片文件，读取其二进制内容。然后以二进制写入模式 'wb' 打开目标文件，将读取的内容写入目标文件，从而实现图片文件的复制。

写入结构化二进制数据

使用 struct 模块：如果需要写入结构化的二进制数据（如整数、浮点数等），可以使用 struct 模块进行数据打包。
- 示例代码：

import struct

file_path = 'example.bin'
# 打包数据：一个整数和一个浮点数
packed_data = struct.pack('if', 42, 3.14)  # 'i' 表示整数，'f' 表示浮点数
with open(file_path, 'wb') as file:  # 以二进制写入模式打开文件
    file.write(packed_data)  # 写入打包后的二进制数据

在这个例子中，使用 struct.pack() 方法将一个整数 42 和一个浮点数 3.14 打包成二进制数据，然后写入文件。struct.pack() 方法的第一个参数是格式字符串，用于指定数据的格式，例如 'if' 表示一个整数和一个浮点数。

5. 文件操作异常处理

5.1 常见文件操作异常

在 Python 文件操作中，可能会遇到多种异常情况，这些异常通常是由文件不存在、权限不足、磁盘空间不足等原因引起的。了解这些常见异常有助于更好地处理文件操作中的错误。

FileNotFoundError：当尝试打开一个不存在的文件时，会抛出此异常。例如：

```
with open('nonexistent_file.txt', 'r') as file:
    content = file.read()
```
如果文件 nonexistent_file.txt 不存在，程序会抛出 FileNotFoundError。
PermissionError：当尝试访问或修改一个没有权限的文件时，会抛出此异常。例如：

with open('protected_file.txt', 'w') as file:
    file.write('Hello, World!')

如果当前用户没有写入权限，程序会抛出 PermissionError。

IOError：这是一个通用的输入输出错误异常，通常在文件操作中遇到磁盘空间不足、文件损坏等情况时抛出。例如：

with open('large_file.txt', 'w') as file:
    file.write('a' * 10000000000)  # 尝试写入大量数据

如果磁盘空间不足，程序会抛出 IOError。

IsADirectoryError：当尝试以文件模式打开一个目录时，会抛出此异常。例如：

```
with open('directory_name', 'r') as file:
    content = file.read()
```
如果 directory_name 是一个目录，程序会抛出 IsADirectoryError。

5.2 异常处理机制

在 Python 中，可以使用 try-except 语句来捕获和处理异常。通过合理地处理异常，可以增强程序的健壮性和用户体验。

基本用法：

try:
    # 尝试执行的代码
    with open('example.txt', 'r') as file:
        content = file.read()
except FileNotFoundError:
    # 处理 FileNotFoundError 异常
    print("文件未找到，请检查文件路径是否正确。")
except PermissionError:
    # 处理 PermissionError 异常
    print("没有权限访问该文件，请检查文件权限。")
except Exception as e:
    # 处理其他所有异常
    print(f"发生了一个错误：{e}")
else:
    # 如果没有异常发生，执行这里的代码
    print("文件读取成功。")
finally:
    # 无论是否发生异常，都会执行这里的代码
    print("文件操作完成。")

捕获多个异常：可以在 except 块中捕获多个异常，或者使用元组的形式捕获多个异常类型。

try:
    with open('example.txt', 'r') as file:
        content = file.read()
except (FileNotFoundError, PermissionError) as e:
    print(f"发生了一个错误：{e}")

自定义异常处理逻辑：可以根据不同的异常类型执行不同的处理逻辑。例如：

try:
    with open('example.txt', 'r') as file:
        content = file.read()
except FileNotFoundError:
    print("文件未找到，正在尝试创建文件...")
    with open('example.txt', 'w') as file:
        file.write("这是一个新创建的文件。")
except PermissionError:
    print("没有权限访问该文件，请检查文件权限。")

记录异常信息：在处理异常时，可以将异常信息记录到日志文件中，便于后续排查问题。

import logging

logging.basicConfig(filename='error.log', level=logging.ERROR)

try:
    with open('example.txt', 'r') as file:
        content = file.read()
except Exception as e:
    logging.error(f"发生了一个错误：{e}")

通过合理地使用异常处理机制，可以有效避免程序因文件操作异常而崩溃，同时提供更友好的用户体验。

6. 文件与目录操作

6.1 os模块文件操作

os 模块提供了丰富的文件操作功能，可以方便地对文件进行各种操作。

文件属性获取

获取文件大小：使用 os.path.getsize() 函数可以获取文件的大小，单位是字节。

import os

file_path = 'example.txt'
size = os.path.getsize(file_path)
print(f"文件大小为：{size} 字节")

获取文件的最后修改时间：使用 os.path.getmtime() 函数可以获取文件的最后修改时间，返回的是一个时间戳。

import os
import time

file_path = 'example.txt'
mtime = os.path.getmtime(file_path)
print(f"文件最后修改时间：{time.ctime(mtime)}")

文件删除

删除文件：使用 os.remove() 函数可以删除指定的文件。

import os

file_path = 'example.txt'
if os.path.exists(file_path):
    os.remove(file_path)
    print("文件已删除")
else:
    print("文件不存在")

文件重命名

重命名文件：使用 os.rename() 函数可以将文件重命名。

import os

old_name = 'example.txt'
new_name = 'new_example.txt'
if os.path.exists(old_name):
    os.rename(old_name, new_name)
    print("文件已重命名")
else:
    print("文件不存在")

文件复制

复制文件：可以使用 shutil 模块中的 copy() 函数来复制文件。

import shutil

source_file = 'example.txt'
destination_file = 'copy_example.txt'
shutil.copy(source_file, destination_file)
print("文件已复制")

6.2 os模块目录操作

os 模块也提供了丰富的目录操作功能，可以方便地对目录进行各种操作。

创建目录

创建单个目录：使用 os.mkdir() 函数可以创建一个目录。

import os

directory_name = 'new_directory'
if not os.path.exists(directory_name):
    os.mkdir(directory_name)
    print("目录已创建")
else:
    print("目录已存在")

创建多级目录：使用 os.makedirs() 函数可以创建多级目录。

import os

directory_name = 'parent_directory/child_directory'
if not os.path.exists(directory_name):
    os.makedirs(directory_name)
    print("多级目录已创建")
else:
    print("目录已存在")

删除目录

删除单个目录：使用 os.rmdir() 函数可以删除一个空目录。

import os

directory_name = 'new_directory'
if os.path.exists(directory_name):
    os.rmdir(directory_name)
    print("目录已删除")
else:
    print("目录不存在")

删除多级目录：使用 shutil.rmtree() 函数可以删除多级目录，包括目录中的所有文件。

import shutil

directory_name = 'parent_directory'
if os.path.exists(directory_name):
    shutil.rmtree(directory_name)
    print("多级目录已删除")
else:
    print("目录不存在")

列出目录内容

列出目录中的文件和子目录：使用 os.listdir() 函数可以列出指定目录中的所有文件和子目录。

import os

directory_name = '.'
contents = os.listdir(directory_name)
print("目录内容：")
for item in contents:
    print(item)

遍历目录树

递归遍历目录树：可以使用 os.walk() 函数递归遍历目录树，获取每个目录中的文件和子目录。

import os

directory_name = '.'
for root, dirs, files in os.walk(directory_name):
    print(f"当前目录：{root}")
    print("子目录：", dirs)
    print("文件：", files)

7. 文件处理的高级技巧

7.1 使用 with 语句简化文件操作

在 Python 中，with 语句是一种上下文管理器，用于简化文件操作。它可以在代码块执行完毕后自动关闭文件，即使发生异常也会确保文件被正确关闭，从而避免了忘记调用 close() 方法导致的资源泄漏问题。使用 with 语句可以显著提高代码的可读性和安全性。

基本用法：

```
with open('example.txt', 'r') as file:
    content = file.read()
# 文件在代码块结束后自动关闭
```
在这个例子中，with 语句打开文件 example.txt，并将其赋值给变量 file。在代码块内部，可以对文件进行读写操作。当代码块执行完毕后，文件会自动关闭，无需手动调用 file.close() 方法。
处理多个文件：如果需要同时处理多个文件，可以在 with 语句中使用多个上下文管理器。
```
with open('source.txt', 'r') as source, open('destination.txt', 'w') as destination:
    content = source.read()
    destination.write(content)
```
在这个例子中，同时打开了两个文件：source.txt 用于读取内容，destination.txt 用于写入内容。两个文件在代码块结束后都会自动关闭。
结合异常处理： with 语句还可以与异常处理机制结合使用，以进一步增强代码的健壮性。

try:
    with open('example.txt', 'r') as file:
        content = file.read()
except FileNotFoundError:
    print("文件未找到，请检查文件路径是否正确。")
except Exception as e:
    print(f"发生了一个错误：{e}")

在这个例子中，即使在 with 语句中发生异常，文件仍然会被自动关闭，确保资源被正确释放。

7.2 文件指针操作

文件指针（也称为文件游标）表示当前文件操作的位置。在文件操作过程中，可以通过移动文件指针来控制读写的位置。Python 提供了多种方法来操作文件指针，从而实现更灵活的文件读写操作。

获取文件指针位置：使用 tell() 方法可以获取当前文件指针的位置，返回的是从文件开头到当前指针的字节数。

with open('example.txt', 'r') as file:
    content = file.read(5)  # 读取前5个字符
    print(content)  # 输出读取的内容
    position = file.tell()  # 获取当前文件指针位置
    print(f"当前文件指针位置：{position}")

移动文件指针位置：使用 seek() 方法可以移动文件指针的位置。seek() 方法的语法为 seek(offset, whence)，其中 offset 是偏移量，whence 是偏移的基准位置。
- whence=0（默认值）：从文件开头开始偏移。
- whence=1：从当前文件指针位置开始偏移。
- whence=2：从文件末尾开始偏移。

with open('example.txt', 'r') as file:
    file.seek(10)  # 将文件指针移动到第10个字节的位置
    content = file.read(5)  # 从当前位置读取5个字符
    print(content)

结合读写操作：文件指针操作在读写文件时非常有用，尤其是在处理二进制文件或需要随机访问文件内容的场景中。

with open('example.bin', 'rb+') as file:  # 以二进制读写模式打开文件
    file.seek(10)  # 移动文件指针到第10个字节的位置
    file.write(b'\x01\x02\x03')  # 在当前位置写入3个字节
    file.seek(0)  # 将文件指针移回文件开头
    content = file.read()  # 读取整个文件内容
    print(content)

通过灵活使用文件指针操作，可以实现对文件的精确读写，满足复杂的文件处理需求。