用Python读写文件(指南)

[TOC]

使用Python最常见的任务之一是读取和写入文件。无论是写入简单的文本文件，读取复杂的服务器日志，甚至是分析原始字节数据，所有这些情况都需要读取或写入文件。

在本教程中，您将学习：

什么组成了一个文件，为什么它在python中很重要

用Python读写文件的基础知识

读写文件的一些基本场景

本教程主要针对初学者到中级的 Pythonistas，但这里有一些提示，更高级的程序员可能也会从中受益。

什么是文件?

在讨论如何使用Python中的文件之前，了解文件的具体内容以及现代操作系统如何处理它们是很重要的。

从本质上讲，文件是用于存储数据的连续字节集。这些数据以特定格式组织，可以是任何像文本文件一样简单的数据，也可以像程序可执行文件一样复杂。最后，这些字节文件被翻译成二进制文件1，0以便计算机更容易处理。

大多数现代文件系统上的文件由三个主要部分组成：

标题(Header)：有关文件内容的元数据(文件名，大小，类型等)

数据(Data)：由创建者或编辑者编写的文件内容

文件结束符(EOF)：表示文件结尾的特殊字符

FileFormat.02335d06829d.png

数据表示的内容取决于所使用的格式规范，通常由扩展名表示。例如，具有.gif扩展名的文件最可能符合GIF规范。有数百个(甚至上千个)文件扩展名。对于本教程，您将只处理.txt或.csv文件扩展名。

文件路径

在操作系统上访问文件时，需要文件路径。文件路径是表示文件位置的字符串。它分为三个主要部分：

文件夹路径：文件系统上的文件夹位置，后续文件夹由正斜杠/(Unix)或反斜杠\(Windows)分隔

文件名：文件的实际名称

扩展名：文件路径的末尾(句号(.)后的内容)，用于表示文件类型

这是一个简单的例子。假设您有一个位于文件结构中的文件，如下所示：

/

│

├── path/

| │

│ ├── to/

│ │ └── cats.gif

│ │

│ └── dog_breeds.txt

|

└── animals.csv

假设您要访问cats.gif文件，并且您当前的位置位于文件夹path中。要访问该文件，您需要浏览该path文件夹，然后查看to文件夹，最后到达cats.gif文件。文件夹路径是path/to/。文件名是cats。文件扩展名是.gif。所以完整的道路是path/to/cats.gif。

现在假设您当前的位置或当前工作目录(cwd)位于我们的示例文件夹结构的to文件夹中。可以通过文件名和扩展名cats.gif简单地引用文件，而不用引用完整路径path/to/cats.gif。

/

│

├── path/

| │

| ├── to/ ← 你的当前工作目录 (cwd)在这儿

| │ └── cats.gif ← 访问这个文件

| │

| └── dog_breeds.txt

|

└── animals.csv

但如果要访问dog_breeds.txt呢？如果不使用完整路径，您将如何访问？您可以使用特殊字符double-dot(..)来移动到上一个目录。这意味着../dog_breeds.txt会从文件夹to引用到dog_breeds.txt：

/

│

├── path/ ← 引用该父目录

| │

| ├── to/ ← 当前工作目录 (cwd)

| │ └── cats.gif

| │

| └── dog_breeds.txt ← 访问该文件

|

└── animals.csv

double-dot(..)可以链接在一起以遍历当前目录上的多个目录。例如，要从to文件夹访问animals.csv，您将使用../../animals.csv。

Line Endings

处理文件数据时经常遇到的一个问题是新行或行结尾的表示。行结尾起源于莫尔斯电码时代，那时一个特定的符号被用来传达传输的结束或一条线的末端。

后来，国际标准化组织(ISO)和美国标准协会(ASA)对电传打字机进行了标准化。ASA标准规定行尾应使用回车(序列CR或\r)和换行(LF或\n)字符(CR+LF或\r\n)。然而，ISO标准允许CR+LF字符或仅LF字符.

Windows使用CR+LF字符表示新行，而Unix和较新的Mac版本仅使用LF字符。当您在不同于文件源的操作系统上处理文件时，这可能会导致一些复杂情况。以下是一个简单的例子。假设我们检查在Windows系统上创建的文件dog_breeds.txt:

哈巴狗\r\n

杰克罗素梗犬\r\n

英国史宾格犬\r\n

德国牧羊犬\r\n

斯塔福郡斗牛梗\r\n

骑士国王查尔斯猎犬\r\n

金毛猎犬\r\n

西部高地白梗\r\n

拳击手\r\n

边境猎犬\r\n

同样的输出将在Unix设备上以不同方式解释：

哈巴狗\r

\n

杰克罗素梗犬\r

\n

英国史宾格犬\r

\n

德国牧羊犬\r

\n

斯塔福郡斗牛梗\r

\n

骑士国王查尔斯猎犬\r

\n

金毛猎犬\r

\n

西部高地白梗\r

\n

拳击手\r

\n

边境猎犬\r

\n

这会使每一行的迭代都有问题，您可能需要考虑这样的情况。

字符编码

您可能面临的另一个常见问题是字节数据的编码。编码是从字节数据到人类可读字符的转换。这通常通过指定表示字符的数值来完成。两种最常见的编码是ASCII和UNICODE格式。ASCII只能存储128个字符，而Unicode最多可包含1,114,112个字符。

ASCII实际上是Unicode(UTF-8)的子集，这意味着ASCII和Unicode共享相同的数字到字符值。重要是要注意，使用不正确的字符编码解析文件可能会导致字符失败或误传。例如，如果文件是使用UTF-8编码创建的，并且您尝试使用ASCII编码对其进行解析，则如果存在超出128个值的字符，则会引发错误。

在Python中打开和关闭文件

当您想使用文件时，首先要做的就是打开它。这是通过调用open()内置函数完成的。open()有一个必需的参数，就是文件的路径。open()有一个返回，就是文件对象：

file = open('dog_breeds.txt')

打开文件后，接下来要学习的是如何关闭它。

:exclamation: 警告:

您应始终确保正确关闭打开的文件。

重要的是要记住，关闭文件是您的责任。在大多数情况下，在应用程序或脚本终止时，文件最终将被关闭。然而，并不能保证任何时候都会发生这种情况。这可能导致不必要的行为，包括资源泄漏。确保您的代码以明确定义的方式运行并减少任何不需要的行为, 这也是Python(Pythonic)中的最佳实践。

当您操作文件时，有两种方法可以确保文件正确关闭，即使遇到错误也是如此。关闭文件的第一种方法是使用try-finally块：

reader = open('dog_breeds.txt')

try:

# 在这儿做进一步的文件处理

finally:

reader.close()

关闭文件的第二种方法是使用如下的with语句：

with open('dog_breeds.txt') as reader:

# 在这儿做进一步的文件处理

WITH语句在离开WITH块后自动负责关闭文件，即使在出现错误的情况下也是如此。我强烈建议您尽可能多地使用WITH语句，因为它允许使用更干净的代码，并使您更容易处理任何意外错误。

最有可能的是，你也想要使用第二个位置参数mode。此参数是一个字符串，其中包含多个字符以表示您要如何打开文件。默认值和最常见的是'r'，表示以只读模式将文件作为文本文件打开：

with open('dog_breeds.txt', 'r') as reader:

# 在这儿做进一步的文件处理

其他模式选项参见: 在线完整记录，但最常用的选项如下：

字符

含义

'r'

只读模式打开(默认)

'w'

写模式打开，首先会截断(覆盖)文件

'rb' 或 'wb'

以二进制模式打开(使用字节数据读/写)

让我们回过头来谈谈文件对象。文件对象是：

“将面向文件的API(使用read()或write()等方法)暴露给底层资源的对象。”(定义来源)

有三种不同类别的文件对象：

文本文件

缓冲的二进制文件

原始二进制文件

这些文件类型中的每一种都在io模块中定义。这里简要介绍下如何排列。

文本文件类型

文本文件是最常见的文件。以下是一些如何打开这些文件的示例：

open('abc.txt')

open('abc.txt', 'r')

open('abc.txt', 'w')

使用这些类型的文件，open()将返回一个TextIOWrapper文件对象：

>>> file = open('dog_breeds.txt')

>>> type(file)

这是open()返回的默认文件对象。

缓冲二进制文件类型

缓冲二进制文件类型用于读取和写入二进制文件。以下是一些如何打开这些文件的示例：

open('abc.txt', 'rb')

open('abc.txt', 'wb')

使用这些类型的文件，open()将返回一个BufferedReader或BufferedWriter文件对象：

>>> file = open('dog_breeds.txt', 'rb')

>>> type(file)

>>> file = open('dog_breeds.txt', 'wb')

>>> type(file)

原始二进制文件类型

原始文件类型是：

“通常用作二进制和文本流的低级构建块。”(定义来源)

因此通常不使用它。

以下是如何打开这些文件的示例：

open('abc.txt', 'rb', buffering=0)

使用这些类型的文件，open()将返回一个FileIO文件对象：

>>> file = open('dog_breeds.txt', 'rb', buffering=0)

>>> type(file)

读写打开的文件

打开文件后，您将需要读取或写入文件。首先，让我们来读取一个文件。可以在文件对象上调用多种方法来帮助您：

方法

它能做什么

这将根据size字节数从文件中读取。如果没有传递参数或None或传参-1，那么整个文件被读取。

这最多读取行中的size字符大小。这将一直延伸到行尾，然后再绕回来。如果未传递任何参数，或者None或传递-1，则读取整行(或行的其余部分)。

这将从文件对象中读取剩余行并将其作为列表返回。

使用上面使用的相同文件dog_breeds.txt，我们来看一些如何使用这些方法的示例。以下是如何使用.read()命令打开和读取整个文件的示例：

>>> with open('dog_breeds.txt', 'r') as reader:

>>> # 读取并打印整个文件

>>> print(reader.read())

Pug

Jack Russel Terrier

English Springer Spaniel

German Shepherd

Staffordshire Bull Terrier

Cavalier King Charles Spaniel

Golden Retriever

West Highland White Terrier

Boxer

Border Terrier

这是一个如何使用.readline()每行读取5个字节的示例：

>>> with open('dog_breeds.txt', 'r') as reader:

>>> # 读取并打印一行的前5个字符, 重复5次

>>> print(reader.readline(5))

>>> # 请注意，一行大于5个字符，就沿该行继续，

>>> # 每次读取5个字符，直到行尾，然后“换行”

>>> print(reader.readline(5))

>>> print(reader.readline(5))

>>> print(reader.readline(5))

>>> print(reader.readline(5))

Pug

Jack

Russe

ll Te

rrier

以下是使用.readlines()方法将整个文件作为列表读取的示例：

>>> f = open('dog_breeds.txt')

>>> f.readlines() # 返回一个列表

['Pug\n', 'Jack Russel Terrier\n', 'English Springer Spaniel\n', 'German Shepherd\n', 'Staffordshire Bull Terrier\n', 'Cavalier King Charles Spaniel\n', 'Golden Retriever\n', 'West Highland White Terrier\n', 'Boxer\n', 'Border Terrier\n']

上面的例子也可以通过使用list()从文件对象创建列表来完成：

>>> f = open('dog_breeds.txt')

>>> list(f)

['Pug\n', 'Jack Russel Terrier\n', 'English Springer Spaniel\n', 'German Shepherd\n', 'Staffordshire Bull Terrier\n', 'Cavalier King Charles Spaniel\n', 'Golden Retriever\n', 'West Highland White Terrier\n', 'Boxer\n', 'Border Terrier\n']

迭代文件中的每一行

读取文件时常见的事情是迭代每一行。以下是如何使用.readline()执行迭代的示例：

>>> with open('dog_breeds.txt', 'r') as reader:

>>> # 一行接一行地读取和打印整个文件

>>> line = reader.readline()

>>> while line != '': # EOF为空

>>> print(line, end='')

>>> line = reader.readline()

Pug

Jack Russel Terrier

English Springer Spaniel

German Shepherd

Staffordshire Bull Terrier

Cavalier King Charles Spaniel

Golden Retriever

West Highland White Terrier

Boxer

Border Terrier

您可以迭代文件中每一行的另一种方法是使用.readlines()文件对象。请记住，.readlines()返回一个列表，其中列表中的每个元素代表文件中的一行：

>>> with open('dog_breeds.txt', 'r') as reader:

>>> for line in reader.readlines():

>>> print(line, end='')

Pug

Jack Russell Terrier

English Springer Spaniel

German Shepherd

Staffordshire Bull Terrier

Cavalier King Charles Spaniel

Golden Retriever

West Highland White Terrier

Boxer

Border Terrier

但是，通过迭代文件对象本身可以进一步简化上述示例：

>>> with open('dog_breeds.txt', 'r') as reader:

>>> # Read and print the entire file line by line

>>> for line in reader:

>>> print(line, end='')

Pug

Jack Russel Terrier

English Springer Spaniel

German Shepherd

Staffordshire Bull Terrier

Cavalier King Charles Spaniel

Golden Retriever

West Highland White Terrier

Boxer

Border Terrier

最后的方法更Pythonic，可以更快，更高效。因此，建议您改用它。

:exclamation: 注意：

上面的一些示例包含print('some text', end='')。这end=''是为了防止Python为正在打印的文本添加额外的换行符，并仅打印从文件中读取的内容。

现在让我们深入研究文件。与读取文件一样，文件对象有多种方法可用于写入文件：

方法

它能做什么

.write(string)

这会将字符串写入文件。

.writelines(seq)

这会将序列写入文件。没有行结尾附加到每个序列项。由您来添加适当的行结尾。

以下是使用.write()和.writelines()的简单示例：

with open('dog_breeds.txt', 'r') as reader:

# 注意：readlines 不裁剪行尾

dog_breeds = reader.readlines()

with open('dog_breeds_reversed.txt', 'w') as writer:

# 你也可以用

# writer.writelines(reversed(dog_breeds))

# 把狗的品种按相反的顺序写入文件

for breed in reversed(dog_breeds):

writer.write(breed)

使用字节

有时，您可能需要使用字节字符串处理文件。这是通过在mode参数中添加'b'字符来完成的。文件对象的所有相同方法都适用。但是，每个方法都期望并返回一个bytes对象:

>>> with open(`dog_breeds.txt`, 'rb') as reader:

>>> print(reader.readline())

b'Pug\n'

使用b标志打开文本文件并不那么有趣。假设我们有一张 杰克拉塞尔梗(jack_russell.png)的可爱图片：

jack_russell.92348cb14537.png

您实际上可以在Python中打开该文件并检查内容！由于.png文件格式定义良好，文件的标题是8个字节，如下所示：

值

解释

0x89

一个“魔术”数字，表示这是一个 PNG开头

0x50 0x4E 0x47

PNG in ASCII

0x0D 0x0A

DOS样式行结束 \r\n

0x1A

DOS风格的EOF字符

0x0A

一个Unix风格的行结尾 \n

果然，当您打开文件并单独读取这些字节时，您可以看到这确实是一个.png头文件：

>>> with open('jack_russell.png', 'rb') as byte_reader:

>>> print(byte_reader.read(1))

>>> print(byte_reader.read(3))

>>> print(byte_reader.read(2))

>>> print(byte_reader.read(1))

>>> print(byte_reader.read(1))

b'\x89'

b'PNG'

b'\r\n'

b'\x1a'

b'\n'

一个完整的例子： dos2unix.py

让我们把这整件事情捋一遍，看看如何读取和写入文件的完整示例。下面是一个类似dos2unix的工具，它将把包含\r\n行尾的文件转换为\n。

该工具分为三个主要部分。第一个是str2unix()将字符串从\\r\\n行结尾转换为\\n。第二个是dos2unix()将包含\r\n字符的字符串转换为\n。dos2unix()调用str2unix()。最后，有__main__块，只有当文件作为脚本执行时才会调用。可以将其视为其他编程语言中的main功能。

"""

一个简单的脚本和库,

用来把文件或字符从dos样式行结尾转换为Unix样式行结尾

"""

import argparse

import os

def str2unix(input_str: str) -> str:

r"""\

把 \r\n 行结尾字符串转换为 \n 行结尾

Parameters

----------

input_str

行结尾将被转换的整个字符串

Returns

-------

转换后的字符串

"""

r_str = input_str.replace('\r\n', '\n')

return r_str

def dos2unix(source_file: str, dest_file: str):

"""\

转换包含Dos样式的行结尾文件为Unix样式

Parameters

----------

source_file

要被转换的源文件路径

dest_file

转换后的文件输出路径

"""

# NOTE: 可以添加文件是否存在检查和文件覆盖保护

with open(source_file, 'r') as reader:

dos_content = reader.read()

unix_content = str2unix(dos_content)

with open(dest_file, 'w') as writer:

writer.write(unix_content)

if __name__ == "__main__":

# 创建Argument parser并设置描述

parser = argparse.ArgumentParser(

description="把Dos样式文件转换为Unix样式文件的脚本",

)

# Add the arguments:

# - source_file: 想要转换的源文件

# - dest_file: 输出文件目的地

# Note: the use of the argument type of argparse.FileType could

# streamline some things

parser.add_argument(

'source_file',

help='源文件路径 '

)

parser.add_argument(

'--dest_file',

help='目的文件路径(default: source_file appended with `_unix`',

default=None

)

# Parse the args (argparse automatically grabs the values from

# sys.argv)

args = parser.parse_args()

s_file = args.source_file

d_file = args.dest_file

# 如果没有传递目的文件,

# 那么我们会自动基与源文件创建一个新文件

if d_file is None:

file_path, file_extension = os.path.splitext(s_file)

d_file = f'{file_path}_unix{file_extension}'

dos2unix(s_file, d_file)

提示和技巧

现在您已经掌握了读写文件的基础知识，这里有一些提示和技巧可以帮助您提高技能。

__file__

__file__属性是模块的特殊属性，类似于__name__。它是：

“从中加载模块的文件的路径名(如果从文件加载模块的话)”(来源)

:exclamation: 注意：

要重新迭代，__file__返回相对于调用初始Python脚本的路径。如果需要完整的系统路径，可以使用os.getcwd()获取执行代码的当前工作目录。

这是一个真实世界的例子。在我过去的一份工作中，我对硬件设备进行了多次测试。每个测试都是使用Python脚本编写的，测试脚本文件名用作标题。然后执行这些脚本并使用__file__特殊属性打印其状态。这是一个示例文件夹结构：

project/

|

├── tests/

| ├── test_commanding.py

| ├── test_power.py

| ├── test_wireHousing.py

| └── test_leds.py

|

└── main.py

运行main.py产生以下内容：

>>> python main.py

tests/test_commanding.py Started:

tests/test_commanding.py Passed!

tests/test_power.py Started:

tests/test_power.py Passed!

tests/test_wireHousing.py Started:

tests/test_wireHousing.py Failed!

tests/test_leds.py Started:

tests/test_leds.py Passed!

通过使用__file__特殊属性，我能够运行并动态获取所有测试的状态。

附加到文件

有时，您可能希望附加到文件或在已填充文件的末尾开始写入。这可以通过使用mode参数的'a'轻松完成：

with open('dog_breeds.txt', 'a') as a_writer:

a_writer.write('\nBeagle')

当您再次检查dog_breeds.txt时，您将看到文件的开头未更改，Beagle现在已添加到文件的末尾：

>>> with open('dog_breeds.txt', 'r') as reader:

>>> print(reader.read())

Pug

Jack Russel Terrier

English Springer Spaniel

German Shepherd

Staffordshire Bull Terrier

Cavalier King Charles Spaniel

Golden Retriever

West Highland White Terrier

Boxer

Border Terrier

Beagle

同时使用两个文件

有时您可能想要读取文件并同时写入另一个文件。如果您在学习如何写入文件时同时显示的示例，则可以将其实际组合为以下内容：

d_path = 'dog_breeds.txt'

d_r_path = 'dog_breeds_reversed.txt'

with open(d_path, 'r') as reader, open(d_r_path, 'w') as writer:

dog_breeds = reader.readlines()

writer.writelines(reversed(dog_breeds))

创建自己的Context Manager

可能有一段时间，您需要通过将文件对象放在自定义类中来更好地控制文件对象。执行此操作时，除非添加一些魔术方法__enter__和__exit__，否则无法再使用with语句. 通过添加这些，您将创建所谓的上下文管理器(Context Manager)。

调用with语句时会调用__enter__()。从with语句块退出时调用__exit__()。

这是一个可用于制作自定义类的模板：

class my_file_reader():

def __init__(self, file_path):

self.__path = file_path

self.__file_object = None

def __enter__(self):

self.__file_object = open(self.__path)

return self

def __exit__(self, type, val, tb):

self.__file_object.close()

# Additional methods implemented below

现在您已经拥有了上下文管理器的自定义类，您可以通过类似内置的open()的方式来使用它：

with my_file_reader('dog_breeds.txt') as reader:

# Perform custom class operations

pass

这是一个很好的例子。还记得我们有可爱的杰克罗素形象吗？也许你想打开其他.png文件，但不想每次都解析头文件。这是一个如何做到这一点的例子。此示例还使用自定义迭代器。如果您不熟悉它们，请查看Python迭代器：

class PngReader():

# 每个 .png 文件都包含相同的头文件.

# 使用它来验证该文件确实是 png

_expected_magic = b'\x89PNG\r\n\x1a\n'

def __init__(self, file_path):

# 确保文件有正确的扩展名

if not file_path.endswith('.png'):

raise NameError("File must be a '.png' extension")

self.__path = file_path

self.__file_object = None

def __enter__(self):

self.__file_object = open(self.__path, 'rb')

magic = self.__file_object.read(8)

if magic != self._expected_magic:

raise TypeError("The File is not a properly formatted .png file!")

return self

def __exit__(self, type, val, tb):

self.__file_object.close()

def __iter__(self):

# This and __next__() are used to create a custom iterator

# See https://dbader.org/blog/python-iterators

return self

def __next__(self):

# Read the file in "Chunks"

# See https://en.wikipedia.org/wiki/Portable_Network_Graphics#%22Chunks%22_within_the_file

initial_data = self.__file_object.read(4)

# The file hasn't been opened or reached EOF. This means we

# can't go any further so stop the iteration by raising the

# StopIteration.

if self.__file_object is None or initial_data == b'':

raise StopIteration

else:

# Each chunk has a len, type, data (based on len) and crc

# Grab these values and return them as a tuple

chunk_len = int.from_bytes(initial_data, byteorder='big')

chunk_type = self.__file_object.read(4)

chunk_data = self.__file_object.read(chunk_len)

chunk_crc = self.__file_object.read(4)

return chunk_len, chunk_type, chunk_data, chunk_crc

现在可以打开.png文件并使用自定义上下文管理器正确分析它们：

>>> with PngReader('jack_russell.png') as reader:

>>> for l, t, d, c in reader:

>>> print(f"{l:05}, {t}, {c}")

00013, b'IHDR', b'v\x121k'

00001, b'sRGB', b'\xae\xce\x1c\xe9'

00009, b'pHYs', b'(

00345, b'iTXt', b"L\xc2'Y"

16384, b'IDAT', b'i\x99\x0c('

16384, b'IDAT', b'\xb3\xfa\x9a$'

16384, b'IDAT', b'\xff\xbf\xd1\n'

16384, b'IDAT', b'\xc3\x9c\xb1}'

16384, b'IDAT', b'\xe3\x02\xba\x91'

16384, b'IDAT', b'\xa0\xa99='

16384, b'IDAT', b'\xf4\x8b.\x92'

16384, b'IDAT', b'\x17i\xfc\xde'

16384, b'IDAT', b'\x8fb\x0e\xe4'

16384, b'IDAT', b')3={'

01040, b'IDAT', b'\xd6\xb8\xc1\x9f'

00000, b'IEND', b'\xaeB`\x82'

不要重复造轮子

在处理文件时可能会遇到常见情况。大多数情况可以使用其他模块处理。您可能需要使用的两种常见文件类型是.csv和.json。Real Python已经汇总了一些关于如何处理这些内容的精彩文章：

此外，还有内置库，您可以使用它们来帮助您：

wave：读写WAV文件(音频)

aifc：读写AIFF和AIFC文件(音频)

sunau：读取和写入Sun AU文件

tarfile：读取和写入tar归档文件

zipfile：使用ZIP存档

configparser：轻松创建和解析配置文件

msilib：读取和写入Microsoft Installer文件

plistlib：生成并解析Mac OS X .plist文件

还有更多的东西。此外，PyPI还有更多第三方工具可用。一些流行的是以下：

PyPDF2：PDF工具包

xlwings：读取和写入Excel文件

Pillow：图像阅读和操作

结束语

你做到了！您现在知道如何使用Python处理文件，包括一些高级技术。使用Python中的文件现在比以往任何时候都更容易，当你开始这样做时，这是一种有益的感觉。

在本教程中，您已经了解到：

什么是文件

如何正确打开和关闭文件

如何读写文件

使用文件时的一些高级技术

一些库使用常见的文件类型

如果您有任何疑问，请在评论中与我们联系。