用Python读写文件指南

python基础

浏览数:410

2019-8-27

用Python读写文件(指南)

本文为译文, 原文链接:

Reading and Writing Files in Python (Guide)

by James Mertz

[TOC]

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

在本教程中,您将学习:

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

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

什么是文件?

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

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

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

  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

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

字符编码

您可能面临的另一个常见问题是字节数据的编码。编码是从字节数据到人类可读字符的转换。这通常通过指定表示字符的数值来完成。两种最常见的编码是ASCIIUNICODE格式。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:
    # 在这儿做进一步的文件处理

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

字符 含义
'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)
<class '_io.TextIOWrapper'>

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

缓冲二进制文件类型

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

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

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

使用这些类型的文件,open()将返回一个BufferedReaderBufferedWriter文件对象:

>>> 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'>

读写打开的文件

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

方法 它能做什么
.read(size=-1) 这将根据size字节数从文件中读取。如果没有传递参数或None或传参-1,那么整个文件被读取。
.readline(size=-1) 这最多读取行中的size字符大小。这将一直延伸到行尾,然后再绕回来。如果未传递任何参数,或者None或传递-1,则读取整行(或行的其余部分)。
.readlines() 这将从文件对象中读取剩余行并将其作为列表返回。

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

图片:CC BY 3.0(https://creativecommons.org/licenses/by/3.0)],来自Wikimedia Commons

您实际上可以在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字符的字符串转换为\ndos2unix()调用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.jsonReal Python已经汇总了一些关于如何处理这些内容的精彩文章:

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

  • 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还有更多第三方工具可用。一些流行的是以下:

结束语

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

在本教程中,您已经了解到:

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

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

作者:东风微鸣