Skip to main content

文件读写

程序中的数据在程序运行结束就会消失。那些需要在多次运行程序之间保持记录的数据（比如配置状态，用户信息等），或者是在程序结束后，依然可以使用的数据（比如计算结果等），都需要保存成文件。文件读写，一般总是要先打开一个文件，进行读写操作，然后关闭文件。

打开关闭​

打开文件​

Python 使用 open() 函数来打开文件。该函数接收两个主要参数：文件路径和打开模式：

file = open("filename.txt", "r")

上面示例程序中的打开模式 "r" 表示文件是以只读（只可以读取，不能改变）模式打开的。常见的文件打开模式有：

  • "r": 只读模式。这是默认模式。
  • "w": 写入模式，如果文件已经存在，则清空内容后写入数据；否则创建一个新文件。
  • "a": 追加模式，如果文件存在，数据将被追加到文件末尾；否则创建新文件。
  • "b": 二进制模式，表示文件中的数据是二进制字节数据。它需要与其他模式结合使用，如 "rb" 或 "wb"。
  • "x": 排他模式，表示文件不能预先存在。只有当文件不存在时，才会创建新文件并打开。

关闭文件​

打开的文件可以使用 close() 方法关闭：

file.close()

打开的文件必须被关闭，这是非常重要的一个步骤。特别是在写入文件时，关闭文件可以确保所有缓冲的数据被正确写入磁盘。不关闭文件可能导致数据写入不完全或损坏。即便是在只读的情况下，访问文件后也必须关闭，否则一是可能会影响程序其它部分，或者其它的程序使用该文件，因为文件被打开时可能会被锁住，不允许其它线程或进程访问，以防止数据错误。二是，每个进程能打开的文件数量是有限的，如果打开的文件都不关闭，程序可能就无法再打开新的文件了。

with 语句​

with 语句是 Python 用来简化资源管理的，例如文件读写、网络连接、数据库连接等。

使用 with 语句的基本结构如下：

with expression as variable:
    # do something with the variable

with 语句最常见的用途是打开文件，确保在操作完成后文件被正确关闭，而不必显式调用 close() 方法。with 代码块中的代码无论是否发生了异常，使用 with 语句打开的资源都会被正确清理和关闭。

使用 with 语句进行文件操作如下：

with open('myfile.txt', 'w') as file:
    file.write('Hello, world!')
# 文件自动关闭，无需显式调用 file.close()

在上面的示例中，无论 file.write() 方法是否引发异常，文件都会在 with 块结束时自动关闭。

读取文件​

文本文件​

最基本的文件读取，只需要打开文件，然后使用文件对象的 read() 方法来读取文件内容：

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

这里，'sample.txt' 是要读取的文件的名称。如果只有文件名，要确保该文件与 Python 程序在同一文件夹下，否则可以使用全路径。'r' 表示只读模式的文本文件，在这种模式下，read() 方法读取并返回文件的全部内容，返回的数据是一个字符串。

逐行读取文件​

如果就只想从文本文件中读取一行，可以使用 readline 方法，比如：

# 打开文件
with open('example.txt', 'r') as file:
    # 读取第一行
    first_line = file.readline()

# 输出读取的内容
print(first_line)

对于多数的文本文件，我们一般会希望一行一行的读取文件中所有的内容。最常用的方式是使用 for 循环，当迭代一个文件对象时，Python 会默认地逐行读取文件：

with open('filename.txt', 'r') as file:
    for line in file:
        print(line)

文本文件的每行的末尾通常都会有一个换行符。Linux 格式的文本文件用 \n 作为换行符；Windows 用 \r\n 换行，如果不希望输出时有额外的空行，可以使用字符串的 strip() 方法移除它：

print(line.strip())

二进制文件​

读取二进制文件与读取文本文件非常类似，只是在打开文件时需要使用 'rb' （读取二进制）模式。读取二进制文件时， read() 函数返回的数据类型是字节序列，而不是字符串。

二进制文件不存在行的概念，对于大文件，我们通常会一块一块的读取。比如，可每次读取文件的 1024 个字节，处理完之后，在读入接下来的 1024 个字节，直到文件结束。这只要给 read() 函数传递一个表示字节数量的参数即可，程序如下：

chunk_size = 1024  # 每次读取 1024 字节

with open('filename.bin', 'rb') as file:
    chunk = file.read(chunk_size)
    while chunk:
        # 处理每一次读取的 chunk ......
        print(chunk)
        
        chunk = file.read(chunk_size)   # 读取下一块

当需要处理大型文件或者希望控制内存使用量时，这种方法特别有用，因为这种方法只需要每次加载文件的一小部分到内存中。

移动文件指针​

读者可能已经发现了，在上面的示例中，每次调用 file.read(chunk_size)，它都会自动返回文件后续的数据。这是因为在，在打开一个文件并开始读取或写入时，文件对象维护了一个“指针”或叫做“文件位置”的数据表示当前在读写文件的哪个位置。通常，刚打开文件时这个指针在文件的开头，但我们可以通过移动它来访问文件的不同部分。这对于大文件操作、随机访问文件或者访问特定格式的文件时，是非常有用的。

我们可以使用 tell() 方法返回文件的当前位置，然后使用 seek() 方法用于移动文件指针。seek() 方法接受两个参数：

  • offset： 表示要移动的字节数。可以是正数（向文件尾方向移动）或负数（向文件头方向移动）
  • whence（可选）： 设定基准点，表示从哪里开始移动。它可以是以下三种值之一： os.SEEK_SET 或 0 表示从文件开头开始（默认值）； os.SEEK_CUR 或 1 表示从当前位置开始；os.SEEK_END 或 2 表示从文件末尾开始。

示例：

with open('sample.txt', 'r') as file:
    position = file.tell()
    print(f"当前文件位置： {position}")
    
with open('sample.txt', 'rb') as file:
    # 从当前位置向后移动5个字节
    file.seek(5, 1)
    
    # 从文件末尾向前移动5个字节
    file.seek(-5, 2)
    
    # 移动到文件的第10个字节位置
    file.seek(10)
    
    # 因为文件指针被指向了文件的第10个字节位置，
    # 下面的 read 方法会读取文件第10个字节的数据
    file.read(1)

写入文件​

写入文件与读取文件的方式非常类似，通常使用文件对象的 write() 方法写入数据：

with open('sample.txt', 'w') as file:
    chars_written = file.write("Hello, World!")
    print(f"Wrote {chars_written} characters to the file.")

同样可以使用循环写入多行文件，但是需要确保每一行一定是以 \n 结尾：

lines = ["Line 1", "Line 2", "Line 3"]

with open('sample.txt', 'w') as file:
    for line in lines:
        file.write(line)
        file.write('\n')

写入二进制数据的方法也类似，使用 'wb' 模式：

# 二进制数据  
data = b'\x00\x01\x02\x03\x04\x05'  
  
# 打开一个文件用于写入二进制数据  
with open('binary_file.bin', 'wb') as f:  
    f.write(data)

文本文字有不同的编码方式，参考字符串和字节之间的转换。有时候，读写文本文件需要考虑编码格式：

# 要写入的内容
text = "你好，世界"

# 以 GBK 编码写入文件
with open('example_gbk.txt', 'w', encoding='gbk') as file:
    file.write(text)
    
# 打开一个以 GBK 编码的文本文件
with open('example_gbk.txt', 'r', encoding='gbk') as file:
    content = file.read()
    print(content)

数据转换成字节序列​

之前，我们介绍了字符串和字节之间的转换。但是在使用二进制文件时，最主要的目的不是保存字符串，而是其它类型的数据，比如整数，列表等等。二进制文件读入时，一般都是以字节序列类型返回的，这就需要我们清除，如何在字节序列与其它类型的数据之间进行转换。

整数与字节序列​

整数可以通过使用 int.to_bytes(length, byteorder) 方法转换为字节序列，而字节序列可以通过使用 int.from_bytes(bytes, byteorder) 方法转换回整数。

# 整数转换为字节序列
num = 0x01020304
byte_seq = num.to_bytes(2, 'big')  # 使用大端字节序
print(byte_seq)                    # 输出: b'\x01\x02\x03\x04'

# 字节序列转换回整数
num_from_bytes = int.from_bytes(byte_seq, 'big')
print(num_from_bytes)              # 输出: 16909060

转换过程中的字节序，大端（Big Endian）和小端（Little Endian），对于数字类型非常重要，转换和逆转换时要使用相同的字节序。大端和小端这两个名字来自小说《格列佛游记》。小说中的一个国家分成两派，一派认为扒鸡蛋壳，应该先敲碎鸡蛋的大头，被称为“大端派”；另一派认为，应该敲小头，被称为“小端派”。在计算机科学中，大端和小端用于描述字节序，也就是数据在内存中如何存储：

  • 在大端模式中，字节的存储是从最高有效字节（MSB）到最低有效字节（LSB）的顺序。也就是低地址位存高位数据。例如，数字 0x12345678 在内存中的存储顺序为 12 34 56 78。
  • 在小端模式中，字节的存储是从最低有效字节（LSB）到最高有效字节（MSB）的顺序，也就是高地址位存高位数据。同样的数字 0x12345678 在内存中的存储顺序为 78 56 34 12。

目前，主流 CPU 在处理数据的时候，都是按照“小端”顺序处理数据的，也就是高位数据保存在内存的高地址中；但是网络传输协议却大多是采用的“大端”，也就是高位数据保存在内存的低地址中。这两种设置没有明显的优劣之分，只要保证读写时采用一致的设置即可。

浮点数与字节序列​

更复杂的数字，比如浮点数和字节序列之间，可以通过使用 struct 模块中的 pack() 和 unpack() 函数进行转换。

import struct

# 浮点数转换为字节序列
num = 3.14159
byte_seq = struct.pack('f', num)
print(byte_seq)        # 输出类似于 b'\xdb\x0fI@'

# 字节序列转换回浮点数
num_from_bytes = struct.unpack('f', byte_seq)[0]
print(num_from_bytes)  # 输出: 3.14159

pack() 和 unpack() 函数在使用时需要一个格式字符串，这个格式字符串指定了如何解读和构造字节序列。常用格式包括：

  • i: 32 位整数
  • I: 32 位无符号整数
  • h: 16 位整数
  • H: 16 位无符号整数
  • f: 单精度浮点数
  • d: 双精度浮点数
  • c: 字符
  • s: 字符串（后跟长度）

pack() 和 unpack() 函数可以一次转换多个数据，比如：

import struct

packed_data = struct.pack('I d', 12345, 3.141592654)

unpacked_data = struct.unpack('I d', packed_data)

print(unpacked_data)  # 输出： (12345, 3.141592654)

复杂数据类型与字节序列​

更复杂了的类型，比如列表、元组、字典等通常包含多个数据项。要将它们转换为字节序列，需要序列化这些数据。数据序列化也被称为数据平化，是指把原本结构化的，有多个层次的数据，转换为单一层次的一段连续的数据。这主要是为了便于在内存或硬盘设备中 存储数据，以及通过网路传输数据。序列化可以以多种方式实现，常见的被把数据转换成 JSON、XML等格式。 在 Web 开发中，JSON 是一种非常流行的轻量级数据交换格式，用于序列化和传输数据。

数据也可以被序列化成二进制格式，在 Python 中，可以使用内置的 pickle 模块来序列化和反序列化数据：

import pickle

# 列表转换为字节序列
my_list = [1, 2, 3, 'Hello', True]
byte_seq = pickle.dumps(my_list)
print(byte_seq)         # 输出: 一串代表序列化列表的字节

# 字节序列转换回列表
list_from_bytes = pickle.loads(byte_seq)
print(list_from_bytes)  # 输出: [1, 2, 3, 'Hello', True]

处理文件异常​

文件读写过程中是非常容易出现各种错误的，比如文件可能不存在、文件没有访问权限、磁盘空间不足、文件格式错误等等。这些错误可能会直接影响到程序的运行效果，甚至会导致程序的崩溃。因此，在文件读写的过程中，异常处理机制是非常重要的。

try:
    with open('sample.txt', 'r') as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print("文件不存在！")
except PermissionError:
    print("没有文件访问权限！")
except IOError:
    print("输入输出错误！")
finally:
    print("无论是否发生错误都会运行这里。")

在上面的示例中，我们尝试打开一个名为 "sample.txt" 的文件，并读取其中的内容。如果在这个过程中出现了任何错误，我们就会执行相应的异常处理代码。

内存文件​

相对内存来说，硬盘读写速度慢很多。我们会需要在内存中创建一个文件对象，这个文件对象的访问方式与硬盘上的文件完全一样，唯一不同是它处于内存而不是硬盘，这样读写速度就会非常快。Python 通过 io 模块中的 BytesIO 和 StringIO 类来创建和操作内存中的文件对象。StringIO 用于在内存中存储字符串数据的文件对象；BytesIO 用于在内存中存储字节数据的文件对象。

比如，下面使用 StringIO 创建了一个内存文本文件：

import io

# 创建一个内存中的字符串文件对象
output = io.StringIO()

# 写入数据
output.write("你好，")
output.write("这是一个内存中的文件！\n")
output.write("又写了一行。")

# 将文件指针移动到文件开始位置
output.seek(0)

# 读取数据
content = output.read()
print(content)

# 关闭内存文件
output.close()

# 输出：
# 你好，这是一个内存中的文件！
# 又写了一行。

下面使用 BytesIO 创建一个内存二进制文件：

import io

# 创建一个内存中的字节文件对象
output = io.BytesIO()

# 写入数据 (需要提供字节数据)
output.write(b"Hello, ")
output.write(b"Here is data in memory.\n")
output.write(b"Another line.")

# 将文件指针移动到文件开始位置
output.seek(0)

# 读取数据
byte_content = output.read()
print(byte_content.decode('utf-8'))

# 关闭内存文件
output.close()

这些内存文件对象与常规文件对象在使用上几乎是相同的，但它们只存在于内存中，不会写入到磁盘。这使得它们在需要快速、短暂的文件操作时非常有用，例如解析数据、暂存数据等场景。

路径处理​

读写文件，必然需要先找到文件，那就离不开处理文件的路径。在 Python 中，处理文件和目录路径的最常用的库是 os.path 和 pathlib。其中，pathlib 是一个比较新的库，提供了面向对象的方式来处理路径。

以下是常用的路径处理函数和相应的示例：

使用 os.path:​

import os

# 获取两个或多个路径名组件的连接
joined_path = os.path.join('folder', 'subfolder', 'file.txt')

# 获取路径的绝对路径
abs_path = os.path.abspath('./folder/file.txt')

# 获取路径的基名（文件名或最后的目录名）
base_name = os.path.basename('/folder/subfolder/file.txt')  # 返回 'file.txt'

# 获取路径的目录名
dir_name = os.path.dirname('/folder/subfolder/file.txt')  # 返回 '/folder/subfolder'

# 检查路径是否存在
exists = os.path.exists('/folder/subfolder/file.txt')

# 检查路径是否是目录
is_dir = os.path.isdir('/folder/subfolder')

# 检查路径是否是文件
is_file = os.path.isfile('/folder/subfolder/file.txt')

# 分割路径的目录名和文件名
dir_part, file_part = os.path.split('/folder/subfolder/file.txt')  # 返回 ('/folder/subfolder', 'file.txt')

使用 pathlib:​

from pathlib import Path

# 创建一个 Path 对象
p = Path('folder/subfolder/file.txt')

# 连接路径
new_path = p.parent / 'another_file.txt'

# 获取路径的绝对路径
abs_path = p.resolve()

# 获取路径的基名（文件名或最后的目录名）
base_name = p.name  # 返回 'file.txt'

# 获取路径的目录名
dir_name = p.parent  # 返回 a Path object: 'folder/subfolder'

# 检查路径是否存在
exists = p.exists()

# 检查路径是否是目录
is_dir = p.is_dir()

# 检查路径是否是文件
is_file = p.is_file()

# 分割路径的目录名和文件名
dir_part, file_part = p.parent, p.name  # 返回 (Path('folder/subfolder'), 'file.txt')

在新的 Python 代码中，建议使用 pathlib，因为它提供了更直观和面向对象的接口，同时具有丰富的功能。但在处理旧的代码或与其他人合作时，可能仍然会遇到 os.path。

临时文件​

在学习或者做实验的时候，常常会需要把数据保存到文件中，但是因为不需要长期保存文件，我们可能会懒得给文件起名，这时候可以让系统把数据保存到系统临时文件夹的临时文件中。这样过后，系统自动清理这些不再需要的文件。Python 使用 tempfile 模块来创建临时文件。以下是一个示例，我们入一些数据到一个临时文件，并返回其路径：

import tempfile

def write_to_temp_file(data: str) -> str:
    # 创建一个临时文件，该文件在关闭后不会自动删除
    with tempfile.NamedTemporaryFile(delete=False) as temp_file:
        temp_file.write(data.encode('utf-8'))
        return temp_file.name

data = "Hello, Temp World!"
temp_file_path = write_to_temp_file(data)
print(f"Data has been written to: {temp_file_path}")

在这个例子中：

使用 tempfile.NamedTemporaryFile 创建了一个临时文件。默认情况下，当临时文件关闭时，它就会被自动删除。如果想保留这个文件，可以设置参数 delete=False。函数返回了临时文件的路径，以后可以使用这个路径来访问或处理该文件。

查找特定类型的文件​

我们有时候会希望得到一个文件夹下，所有符合某个特征的所有文件，比如找出所有的 *.txt 文件。我们可以使用 os 模块提供的函数遍历一个文件夹，比如：

import os

# 遍历文件夹
for root, dirs, files in os.walk('/path/to/folder'):
    for file in files:
        # 检查文件扩展名
        if file.endswith('.txt'):
            print(os.path.join(root, file))

上面的程序使用 os.walk() 函数遍历指定的文件夹。对于每个遍历到的文件，然后，使用字符串方法 endswith() 检查文件名是否以 .txt 结尾，如果是，就打印出该文件的完整路径。

此外，我们也可以使用 glob 模块中的 glob() 函数来查找文件。glob 最早是 UNIX 系统的一个程序，用来匹配文件路径，Python 在其 glob 模块中实现了类似功能。glob() 函数可以使用正则表达式来查找文件，这样我们就不必再手动检查每个文件了。比如，使用 glob 实现上面示例完全相同的功能：

import glob

# 假设我们要查找扩展名为 .txt 的文件
for filepath in glob.glob('/path/to/folder/*.txt'):
    print(filepath)

glob() 函数返回的是一个列表，使用同一模块中的 iglob() 函数，可以为搜索结果生成一个迭代器，其它功能完全相同：

import glob

# 假设我们要查找扩展名为 .txt 的文件
for filepath in glob.iglob('/path/to/folder/*.txt'):
    print(filepath)

glob() 函数一个极其强大的功能是它不仅可以搜索单层文件夹，还可以递归搜索所有的子文件夹。在搜索子文件夹的时候，必须使用 ** 作为路径通配符，并且把参数 recursive 设为 True。比如下面的程序可以找到 "folder" 文件夹极其所有子文件夹中任何以 "f" 字母开头的文件。

import glob

# 使用 '**' 进行递归搜索
# 参数 'recursive=True' 是必须的，以启用 '**' 的递归功能
for filepath in glob.glob('/path/to/folder/**/f*', recursive=True):
    print(filepath)

删除文件​

除了创建，读写文件，我们也会需要在适当时候删除一个文件，可以使用 os.remove() 函数删除文件：

import os

# Specify the file path
file_path = '/path/to/your/file.txt'

# Check if file exists
if os.path.exists(file_path):
    # Delete the file
    os.remove(file_path)