用Python读写文件(指南)

本文为译文, 原文链接:

Reading and Writing Files in Python (Guide)

by James Mertz

[TOC]

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

在本教程中，您将学习：

• 什么组成了一个文件，为什么它在python中很重要
• 用Python读写文件的基础知识
• 读写文件的一些基本场景

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

什么是文件?

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

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

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

1. 标题(Header)：有关文件内容的元数据（文件名，大小，类型等）
2. 数据(Data)：由创建者或编辑者编写的文件内容
3. 文件结束符（EOF）：表示文件结尾的特殊字符

FileFormat.02335d06829d.png

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

文件路径

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

1. 文件夹路径：文件系统上的文件夹位置，后续文件夹由正斜杠/（Unix）或反斜杠\（Windows）分隔
2. 文件名：文件的实际名称
3. 扩展名：文件路径的末尾(句号（.）后的内容)，用于表示文件类型

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

/
│
├── 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()

如果您不熟悉try-finally块的内容，请查看Python Exceptions：An Introduction。

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

with open('dog_breeds.txt') as reader:
    # 在这儿做进一步的文件处理

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

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

with open('dog_breeds.txt', 'r') as reader:
    # 在这儿做进一步的文件处理

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

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

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

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

• 文本文件
• 缓冲的二进制文件
• 原始二进制文件

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

文本文件类型

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

open('abc.txt')

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

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

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

>>> file = open('dog_breeds.txt')
>>> type(file)
<class '_io.TextIOWrapper'>

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

缓冲二进制文件类型

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

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

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

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

>>> file = open('dog_breeds.txt', 'rb')
>>> type(file)
<class '_io.BufferedReader'>
>>> file = open('dog_breeds.txt', 'wb')
>>> type(file)
<class '_io.BufferedWriter'>

原始二进制文件类型

原始文件类型是：

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

因此通常不使用它。

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

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

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

>>> file = open('dog_breeds.txt', 'rb', buffering=0)
>>> type(file)
<class '_io.FileIO'>

读写打开的文件

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

使用上面使用的相同文件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()和.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

图片：CC BY 3.0（https://creativecommons.org/licenses/by/3.0）]，来自Wikimedia Commons

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

果然，当您打开文件并单独读取这些字节时，您可以看到这确实是一个.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'(<]\x19'
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已经汇总了一些关于如何处理这些内容的精彩文章：

• 用Python读写CSV文件
• 在Python中使用JSON数据

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

• wave：读写WAV文件（音频）
• aifc：读写AIFF和AIFC文件（音频）
• sunau：读取和写入Sun AU文件
• tarfile：读取和写入tar归档文件
• zipfile：使用ZIP存档
• configparser：轻松创建和解析配置文件
• xml.etree.ElementTree：创建或读取基于XML的文件
• msilib：读取和写入Microsoft Installer文件
• plistlib：生成并解析Mac OS X .plist文件

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

• PyPDF2：PDF工具包
• xlwings：读取和写入Excel文件
• Pillow：图像阅读和操作

结束语

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

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

• 什么是文件
• 如何正确打开和关闭文件
• 如何读写文件
• 使用文件时的一些高级技术
• 一些库使用常见的文件类型

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