Python-入门-文件操作(十四)

蔚落 2023-10-02 21:51 17阅读 0赞

#### 文章目录 ####

*  Python-入门-文件操作
 *   *  什么是文件路径，Python中如何书写文件路径？
     *  绝对路径和相对路径
     *  打开文件open
     *   二进制文件和文本文件的区别
     *   读取文件read
     *  按行读取
     *  写入文件write和writelines
     *  关闭文件close
     *  移动文件指针和获取当前指针的位置seek()和tell()
     *  自动资源释放with
     *  with底层原理
     *  对象的持久化存储
     *  逐行读取多个文件
     *  随机读取文件指定行
     *  os.path 模块
     *  文件名称的匹配fnmatch
     *  生成临时文件和临时目录

## Python-入门-文件操作 ##

和其它编程语言一样，Python 也具有操作文件（I/O）的能力，比如打开文件、读取和追加数据、插入和删除数据、关闭文件、删除文件等。

除了提供文件操作基本的函数之外，Python 还提供了很多模块，例如 fileinput 模块、pathlib 模块等，通过引入这些模块，我们可以获得大量实现文件操作可用的函数和方法（类属性和类方法），大大提供编写代码的效率。

### 什么是文件路径，Python中如何书写文件路径？ ###

当程序运行时，变量是保存数据的好方法，但变量、序列以及对象中存储的数据是暂时的，程序结束后就会丢失，如果希望程序结束后数据仍然保持，就需要将数据保存到文件中。Python 提供了内置的文件对象，以及对文件、目录进行操作的内置模块，通过这些技术可以很方便地将数据保存到文件（如文本文件等）中。

关于文件，它有两个关键属性，分别是“文件名”和“路径”。其中，文件名指的是为每个文件设定的名称，而路径则用来指明文件在计算机上的位置。例如，我的 Windows 7 笔记本上有一个文件名为 projects.docx（句点之后的部分称为文件的“扩展名”，它指出了文件的类型），它的路径在 D:\\demo\\exercise，也就是说，该文件位于 D 盘下 demo 文件夹中 exercise 子文件夹下。

通过文件名和路径可以分析出，project.docx 是一个 Word 文档，demo 和 exercise 都是指“文件夹”（也称为目录）。文件夹可以包含文件和其他文件夹，例如 project.docx 在 exercise 文件夹中，该文件夹又在 demo 文件夹中。

注意，路径中的 D:\\ 指的是“根文件夹”，它包含了所有其他文件夹。在 Windows 中，根文件夹名为 D:\\，也称为 D: 盘。在 OS X 和 Linux 中，根文件夹是 /。本教程使用的是 Windows 风格的根文件夹，如果你在 OS X 或 Linux 上输入交互式环境的例子，请用 / 代替。

另外，附加卷（诸如 DVD 驱动器或 USB 闪存驱动器），在不同的操作系统上显示也不同。在 Windows 上，它们表示为新的、带字符的根驱动器。诸如 D:\\ 或 E:\\。在 OS X 上，它们表示为新的文件夹，在 /Volumes 文件夹下。在 Linux 上，它们表示为新的文件夹，在 /mnt 文件夹下。同时也要注意，虽然文件夹名称和文件名在 Windows 和 OS X 上是不区分大小写的，但在 Linux 上是区分大小写的。

> Windows上的反斜杠以及OS X和Linux上的正斜杠

在 Windows 上，路径书写使用反斜杠 “” 作为文件夹之间的分隔符。但在 OS X 和 Linux 上，使用正斜杠 “/” 作为它们的路径分隔符。如果想要程序运行在所有操作系统上，在编写 Python 脚本时，就必须处理这两种情况。

好在，用 os.path.join() 函数来做这件事很简单。如果将单个文件和路径上的文件夹名称的字符串传递给它，os.path.join() 就会返回一个文件路径的字符串，包含正确的路径分隔符。代码：

import os
    if __name__ == '__main__':
        join = os.path.join('demo', 'exercise')
        print(join)# demo\exercise

因为此程序是在 Windows 上运行的，所以 os.path.join(‘demo’, ‘exercise’) 返回 `demo\exercise`。如果在 OS X 或 Linux 上调用这个函数，该字符串就会是 ‘demo/exercise’。

不仅如此，如果需要创建带有文件名称的文件存储路径，os.path.join() 函数同样很有用。例如

import os
    if __name__ == '__main__':
        myFiles = ['accounts.txt', 'details.csv', 'invite.docx']
        for filename in myFiles:
            print(os.path.join('C:\\demo\\exercise', filename))

![在这里插入图片描述][588a9d4bc8684311b0985d135d9c576c.png]

### 绝对路径和相对路径 ###

在介绍绝对路径和相对路径之前，先要了解一下什么是当前工作目录。

当前工作目录就是当前代码执行所在的目录在 Python 中，利用 `os.getcwd()`\`函数可以取得当前工作路径的字符串，还可以利用 `os.chdir()`\` 改变它。

了解了当前工作目录的具体含义之后，接下来介绍绝对路径和相对路径各自的含义和用法。

> 什么是绝对路径

明确一个文件所在的路径，有 2 种表示方式，分别是：

*  绝对路径：总是从根文件夹开始，Window 系统中以盘符（C：、D：）作为根文件夹，而 OS X 或者 Linux 系统中以 / 作为根文件夹。
 *  相对路径：指的是文件相对于当前工作目录所在的位置。例如，当前工作目录为 “C:\\Windows\\System32”，若文件 demo.txt 就位于这个 System32 文件夹下，则 demo.txt 的相对路径表示为 “./demo.txt”（其中 ./就表示当前所在目录,而…/就表示上级目录）。

![在这里插入图片描述][7b4ba5f3224346cdad0ddf612668aa4f.png]

> 处理绝对路径和相对路径

Python os.path 模块提供了一些函数，可以实现绝对路径和相对路径之间的转换，以及检查给定的路径是否为绝对路径，比如说：

*  调用 os.path.abspath(path) 将返回 path 参数的绝对路径的字符串，这是将相对路径转换为绝对路径的简便方法。
 *  调用 os.path.isabs(path)，如果参数是一个绝对路径，就返回 True，如果参数是一个相对路径，就返回 False。
 *  调用 os.path.relpath(path, start) 将返回从 start 路径到 path 的相对路径的字符串。如果没有提供 start，就使用当前工作目录作为开始路径。
 *  调用 os.path.dirname(path) 将返回一个字符串，它包含 path 参数中最后一个斜杠之前的所有内容；
 *  调用 os.path.basename(path) 将返回一个字符串，它包含 path 参数中最后一个斜杠之后的所有内容。

>>> os.getcwd()
    'C:\\Windows\\System32'
    >>> os.path.abspath('.')
    'C:\\Windows\\System32'
    >>> os.path.abspath('.\\Scripts')
    'C:\\Windows\\System32\\Scripts'
    >>> os.path.isabs('.')
    False
    >>> os.path.isabs(os.path.abspath('.'))
    True
    >>> os.path.relpath('C:\\Windows', 'C:\\')
    'Windows'
    >>> os.path.relpath('C:\\Windows', 'C:\\spam\\eggs')
    '..\\..\\Windows'
    >>> path = 'C:\\Windows\\System32\\calc.exe'
    >>> os.path.basename(path)
    'calc.exe'
    >>> os.path.dirname(path)
    'C:\\Windows\\System32'

除此之外，如果同时需要一个路径的目录名称和基本名称，就可以调用 os.path.split() 获得这两个字符串的元组，例如：

>>> path = 'C:\\Windows\\System32\\calc.exe'
    >>> os.path.split(path)
    ('C:\\Windows\\System32', 'calc.exe')

同时，如果提供的路径不存在，许多 Python 函数就会崩溃并报错，但好在 os.path 模块提供了以下函数用于检测给定的路径是否存在，以及它是文件还是文件夹：

*  如果 path 参数所指的文件或文件夹存在，调用 os.path.exists(path) 将返回 True，否则返回 False。
 *  如果 path 参数存在，并且是一个文件，调用 os.path.isfile(path) 将返回 True，否则返回 False。
 *  如果 path 参数存在，并且是一个文件夹，调用 os.path.isdir(path) 将返回 True，否则返回 False。

下面是在交互式环境中尝试这些函数的结果：

>>> os.path.exists('C:\\Windows')
    True
    >>> os.path.exists('C:\\some_made_up_folder')
    False
    >>> os.path.isdir('C:\\Windows\\System32')
    True
    >>> os.path.isfile('C:\\Windows\\System32')
    False
    >>> os.path.isdir('C:\\Windows\\System32\\calc.exe')
    False
    >>> os.path.isfile('C:\\Windows\\System32\\calc.exe')
    True

文件的应用级操作可以分为以下 3 步，每一步都需要借助对应的函数实现：

1.  打开文件：使用 open() 函数，该函数会返回一个文件对象；
2.  对已打开文件做读/写操作：读取文件内容可使用 read()、readline() 以及 readlines() 函数；向文件中写入内容，可以使用 write() 函数。
3.  关闭文件：完成对文件的读/写操作之后，最后需要关闭文件，可以使用 close() 函数。

一个文件，必须在打开之后才能对其进行操作，并且在操作结束之后，还应该将其关闭，这 3 步的顺序不能打乱。

### 打开文件open ###

在Python 中，如果想要操作文件，首先需要创建或者打开指定的文件，并创建一个文件对象，而这些工作可以通过内置的 open() 函数实现。  
open() 函数用于创建或打开指定文件，该函数的常用语法格式如下：`file = open(file_name [, mode='r' [ , buffering=-1 [ , encoding = None ]]])`

此格式中，用 \[\] 括起来的部分为可选参数，即可以使用也可以省略。其中，各个参数所代表的含义如下：

*  file：表示要创建的文件对象。
 *  file\_name：要创建或打开文件的文件名称，该名称要用引号（单引号或双引号都可以）括起来。需要注意的是，如果要打开的文件和当前执行的代码文件位于同一目录，则直接写文件名即可；否则，此参数需要指定打开文件所在的完整路径。
 *  mode：可选参数，用于指定文件的打开模式。可选的打开模式如表 1 所示。如果不写，则默认以只读（r）模式打开文件。
 *  buffering：可选参数，用于指定对文件做读写操作时，是否使用缓冲区（本节后续会详细介绍）。
 *  encoding：手动设定打开文件时所使用的编码格式，不同平台的 ecoding 参数值也不同，以 Windows 为例，其默认为 cp936（实际上就是 GBK 编码）。

open() 函数支持的文件打开模式如表所示。  
![在这里插入图片描述][ee4cd894457a429aadee11da94717380.png]

文件打开模式，直接决定了后续可以对文件做哪些操作。例如，使用 r 模式打开的文件，后续编写的代码只能读取文件，而无法修改文件内容。

将以上几个容易混淆的文件打开模式的功能做了很好的对比：

![在这里插入图片描述][d4eb11bdbd604cb28d908d853af3b612.png]

#当前程序文件同目录下没有 a.txt 文件
    	# 当以默认模式打开文件时，默认使用 r 权限，由于该权限要求打开的文件必须存在，
     	# 因此运行此代码会报如下错误： FileNotFoundError: [Errno 2] No such file or directory: 'a.txt'
    	# 所以打开的文件必须存在
        file = open("a.txt") 
        print(file)

使用 open() 打开文件时，默认采用 GBK 编码。但当要打开的文件不是 GBK 编码格式时，可以在使用 open() 函数时，手动指定打开文件的编码格式，例如：

file = open("a.txt",encoding="utf-8")

注意，手动修改 encoding 参数的值，仅限于文件以文本的形式打开，也就是说，以二进制格式打开时，不能对 encoding 参数的值做任何修改，否则程序会抛出 ValueError 异常，如下所示：

`ValueError: binary mode doesn't take an encoding argument`

> open()是否需要缓冲区

通常情况下、建议大家在使用 open() 函数时打开缓冲区，即不需要修改 buffing 参数的值。如果 buffing 参数的值为 0（或者 False），则表示在打开指定文件时不使用缓冲区；如果 buffing 参数值为大于 1 的整数，该整数用于指定缓冲区的大小（单位是字节）；如果 buffing 参数的值为负数，则代表使用默认的缓冲区大小。

为什么呢？原因很简单，目前为止计算机内存的 I/O 速度仍远远高于计算机外设（例如键盘、鼠标、硬盘等）的 I/O 速度，如果不使用缓冲区，则程序在执行 I/O 操作时，内存和外设就必须进行同步读写操作，也就是说，内存必须等待外设输入（输出）一个字节之后，才能再次输出（输入）一个字节。这意味着，内存中的程序大部分时间都处于等待状态。

而如果使用缓冲区，则程序在执行输出操作时，会先将所有数据都输出到缓冲区中，然后继续执行其它操作，缓冲区中的数据会有外设自行读取处理；同样，当程序执行输入操作时，会先等外设将数据读入缓冲区中，无需同外设做同步读写操作。

> open()文件对象常用的属性

成功打开文件之后，可以调用文件对象本身拥有的属性获取当前文件的部分信息，其常见的属性为：

*  file.name：返回文件的名称；
 *  file.mode：返回打开文件时，采用的文件打开模式；
 *  file.encoding：返回打开文件时使用的编码格式；
 *  file.closed：判断文件是否己经关闭。

# 以默认方式打开文件
        f = open('my_file.txt')
        # 输出文件是否已经关闭
        print(f.closed)
        # 输出访问模式
        print(f.mode)
        #输出编码格式
        print(f.encoding)
        # 输出文件名
        print(f.name)

注意，使用 open() 函数打开的文件对象，必须手动进行关闭，因为Python 垃圾回收机制无法自动回收打开文件所占用的资源。

###  二进制文件和文本文件的区别 ###

> 最表象的区别：

不同的二进制文件需要不同的软件来打开，例如BMP文件，需要一个读图的软件来打开才能看到里面保存的图像，MP3文件需要一个播放器软件才能听到里面的音频。而文本文件只需要记事本就可以打开查看里面的内容。

> 再深一点的区别：

二进制文件里存储的东西是二进制数据，就是01串。而文本文件中存储的是字符串，比如汉字。这点是从**逻辑层面**上所说的，不完全正确，但是便于理解，下面我会进阶的细说这里。

> 更深一点的区别：

二进制文件的读写速度非常快，因为它就是将数据在内存中的存储形式（二进制）原模原样放到文件中，读出来的东西不需要经过处理就可以直接放到内存中去用，但是这些二进制串我们是看不懂也处理不了的，所以就需要专门的解码软件来处理，才能将信息显现到我们面前，所以说二进制文件的读写比较快，但是对于我们程序员来说，可读性差。

而文本文件首先有一个编码方式，例如ASCII或者Unicode，当我们要存一些东西时，会先用一定的编码方式将这些东西转为对应的编码，再将这个编码写进文件里，读的时候要先解码，才能将对应的字符显示出来，所以读写比较慢，但是读出来的东西是字符串，我们能看懂，可读性比较好。

> 为什么记事本打开二进制文件会乱码？

再详细说一下文本文件的存储过程：数据在内存中都是以二进制存储的，所以要先从内存中将数据的二进制取出来，用ASCII（或Unicode）编码方式将其编码，再将这个编码存进文件中。特别有趣的地方就是：如果这些数据是字符，那么他们在内存中本身就是按ASCII码编好的，所以存进文件文件时不需要再进行编码了，也是原模原样将内存中的东西放进了文件中（与二进制文件存储方式一样是不是？）。但如果不是字符型数据，例如int i=10，他在内存中存的是10的二进制：1010，这个二进制经过ASCII编码之后，再解码出来肯定就不是10了。

这就解释了为什么用记事本打开二进制文件时会乱码的问题。首先记事本也是一种解码软件，但他是按ASCII或者Unicode来解码的，他会按自己的方式给二进制文件来解码并显示字符。所以用记事本打开二进制文件时，也不会全部乱码，仔细看那些用字符串形式存的数据肯定不会乱码。

> 总结

文本文件存的是字符，二进制文件存的是二进制数据。其实在物理层面上讲，我们的硬盘只能存储二进制。所以广义上讲文本文件也是二进制文件，只不过文本文件里只能存字符型数据，而字符型数据经过ASCII或Unicode解码之后我们能看懂。

换一个角度想，所有二进制文件在硬盘上都是01串，我们都看不懂，所以需要一个解码软件将这堆二进制转换成我们想要的信息形式。所以这时就回到了文本文件和二进制文件的最表象区别：解码软件不同！ 用记事本打开二进制文件会乱码，而二进制的解码软件基本都打不开文本文件。

在实际存储中最好是将数据分成字符数据和非字符数据两类：

*  如果存储的是字符数据，无论采用文本文件还是二进制文件都是没有任何区别的，这点上面解释过了。
 *  如果存储的是非字符数据，那么就要看我们使用的情况来决定：
    
    1.  如果是需要频繁的保存和访问数据，那么应该采取二进制文件进行存放，这样可以节省存储空间和转换时间。
    2.  如果需要频繁的向终端显示数据或从终端读入数据，那么就将这些数据转为字符串型，采用文本文件进行存放，这样可以节省转换时间。

###  读取文件read ###

《open()函数》一节中，介绍了如何通过 open() 函数打开一个文件。在其基础上，继续讲解如何读取已打开文件中的数据。

Python 提供了如下 3 种函数，它们都可以帮我们实现读取文件中数据的操作：

1.  read() 函数：逐个字节或者字符读取文件中的内容；
2.  readline() 函数：逐行读取文件中的内容；
3.  readlines() 函数：一次性读取文件中多行内容。

本节先讲解 read() 函数的用法，readline() 和 readlines() 函数会放到后续详细介绍

对于借助 open() 函数，并以可读模式（包括 r、r+、rb、rb+）打开的文件，可以调用 read() 函数逐个字节（或者逐个字符）读取文件中的内容。

如果文件是以文本模式（非二进制模式）打开的，则 read() 函数会逐个字符进行读取；反之，如果文件以二进制模式打开，则 read() 函数会逐个字节进行读取。

read() 函数的基本语法格式如下：`file.read([size])`

其中，file 表示已打开的文件对象；size 作为一个可选参数，用于指定一次最多可读取的字符（字节）个数，如果省略，则默认一次性读取所有内容。

#以 utf-8 的编码格式打开指定文件
        f = open("my_file.txt",encoding = "utf-8")
        #输出读取到的数据
        print(f.read())
        #关闭文件
        f.close()

注意，当操作文件结束后，必须调用 close() 函数手动将打开的文件进行关闭，这样可以避免程序发生不必要的错误。

当然，我们也可以通过使用 size 参数，指定 read() 每次可读取的最大字符（或者字节）数，例如：

#以 utf-8 的编码格式打开指定文件
        f = open("my_file.txt",encoding = "utf-8")
        #输出读取到的数据
        print(f.read(6))
        #关闭文件
        f.close()

再次强调，size 表示的是一次最多可读取的字符（或字节）数，因此，即便设置的 size 大于文件中存储的字符（字节）数，read() 函数也不会报错，它只会读取文件中所有的数据。

除此之外，对于以二进制格式打开的文件，read() 函数会逐个字节读取文件中的内容。例如：

#以二进制形式打开指定文件
        f = open("my_file.txt",'rb+')
        #输出读取到的数据
        print(f.read())
        #关闭文件
        f.close()

读取的二进制我们可以调用 decode() 方法，将其转换成我们认识的字符串。

注意: 在使用 read() 函数时，如果 Python 解释器提示`UnicodeDecodeError`异常，其原因在于，目标文件使用的编码格式和 open() 函数打开该文件时使用的编码格式不匹配。

举个例子，如果目标文件的编码格式为 GBK 编码，而我们在使用 open() 函数并以文本模式打开该文件时，手动指定 encoding 参数为 UTF-8。这种情况下，由于编码格式不匹配，当我们使用 read() 函数读取目标文件中的数据时，Python 解释器就会提示`UnicodeDecodeError`异常。

要解决这个问题，要么将 open() 函数中的 encoding 参数值修改为和目标文件相同的编码格式，要么重新生成目标文件（即将该文件的编码格式改为和 open() 函数中的 encoding 参数相同）。

除此之外，还有一种方法：先使用二进制模式读取文件，然后调用 bytes 的 decode() 方法，使用目标文件的编码格式，将读取到的字节串转换成认识的字符串。

#以二进制形式打开指定文件，该文件编码格式为 utf-8
        f = open("my_file.txt",'rb+')
        byt = f.read()
        print("\n转换后：")
        print(byt.decode('utf-8'))
        #关闭文件
        f.close()

### 按行读取 ###

前面讲到，如果想读取用 open() 函数打开的文件中的内容，除了可以使用 read() 函数，还可以使用 readline() 和 readlines() 函数。和 read() 函数不同，这 2 个函数都以“行”作为读取单位，即每次都读取目标文件中的一行。对于读取以文本格式打开的文件，读取一行很好理解；对于读取以二进制格式打开的文件，它们会以“\\n”作为读取一行的标志。

> readline()函数

readline() 函数用于读取文件中的一行，包含最后的换行符“\\n”。此函数的基本语法格式为：`file.readline([size])`

其中，file 为打开的文件对象；size 为可选参数，用于指定读取每一行时，一次最多读取的字符（字节）数。

和 read() 函数一样，此函数成功读取文件数据的前提是，使用 open() 函数指定打开文件的模式必须为可读模式（包括 r、rb、r+、rb+ 4 种）。

f = open("my_file.txt")
        读取一行数据
        byt = f.readline()
        print(byt)

由于 readline() 函数在读取文件中一行的内容时，会读取最后的换行符“\\n”，再加上 print() 函数输出内容时默认会换行，所以输出结果中会看到多出了一个空行。

不仅如此，在逐行读取时，还可以限制最多可以读取的字符（字节）数，例如：

#以二进制形式打开指定文件
        f = open("my_file.txt",'rb')
        byt = f.readline(6)
        print(byt)

由于这里没有完整读取一行的数据，因此不会读取到换行符。

> readlines()函数

readlines() 函数用于读取文件中的所有行，它和调用不指定 size 参数的 read() 函数类似，只不过该函数返回是一个字符串列表，其中每个元素为文件中的一行内容。

和 readline() 函数一样，readlines() 函数在读取每一行时，会连同行尾的换行符一块读取。

readlines() 函数的基本语法格式如下：`file.readlines()`其中，file 为打开的文件对象。和 read()、readline() 函数一样，它要求打开文件的模式必须为可读模式（包括 r、rb、r+、rb+ 4 种）。

f = open("my_file.txt",'rb')
        byt = f.readlines()
        print(byt)

### 写入文件write和writelines ###

前面学习了如何使用 read()、readline() 和 readlines() 这 3 个函数读取文件，如果我们想把一些数据保存到文件中，又该如何实现呢？

> write函数

Python 中的文件对象提供了 write() 函数，可以向文件中写入指定内容。该函数的语法格式如下：`file.write(string)`

其中，file 表示已经打开的文件对象；string 表示要写入文件的字符串（或字节串，仅适用写入二进制文件中）。

注意，在使用 write() 向文件中写入数据，需保证使用 open() 函数是以 r+、w、w+、a 或 a+ 的模式打开文件，否则执行 write() 函数会抛出 io.UnsupportedOperation 错误。

f = open("a.txt", 'w')
        f.write("写入一行新数据")
        f.close()

前面已经讲过，如果打开文件模式中包含 w（写入），那么向文件中写入内容时，会先清空原文件中的内容，然后再写入新的内容。因此运行上面程序，再次打开 a.txt 文件，只会看到新写入的内容

而如果打开文件模式中包含 a（追加），则不会清空原有内容，而是将新写入的内容会添加到原内容后边。例如，还原 a.txt 文件中的内容，并修改上面代码为：

f = open("a.txt", 'a')
        f.write("\n写入一行新数据")
        f.close()

因此，采用不同的文件打开模式，会直接影响 write() 函数向文件中写入数据的效果。  
  
另外，在写入文件完成后，一定要调用 close() 函数将打开的文件关闭，否则写入的内容不会保存到文件中。例如，将上面程序中最后一行 f.close() 删掉，再次运行此程序并打开 a.txt，你会发现该文件是空的。这是因为，当我们在写入文件内容时，操作系统不会立刻把数据写入磁盘，而是先缓存起来，只有调用 close() 函数时，操作系统才会保证把没有写入的数据全部写入磁盘文件中。

除此之外，如果向文件写入数据后，不想马上关闭文件，也可以调用文件对象提供的 flush() 函数，它可以实现将缓冲区的数据写入文件中。例如：

f = open("a.txt", 'w')
        f.write("写入一行新数据")
        f.flush()

有读者可能会想到，通过设置 open() 函数的 buffering=0 参数可以关闭缓冲区，这样数据不就可以直接写入文件中了？对于以二进制格式打开的文件，可以不使用缓冲区，写入的数据会直接进入磁盘文件；**但对于以文本格式打开的文件，必须使用缓冲区，否则 Python 解释器会 ValueError 错误**。

> writelines 函数

Python 的文件对象中，不仅提供了 write() 函数，还提供了 writelines() 函数，可以实现将字符串列表写入文件中。注意，写入函数只有 write() 和 writelines() 函数，而没有名为 writeline 的函数。

例如，还是以 a.txt 文件为例，通过使用 writelines() 函数，可以轻松实现将 a.txt 文件中的数据复制到其它文件中，实现代码如下：

f = open('a.txt', 'r')
        n = open('b.txt','w+')
        n.writelines(f.readlines())
        n.close()
        f.close()

执行此代码，在 a.txt 文件同级目录下会生成一个 b.txt 文件，且该文件中包含的数据和 a.txt 完全一样。

需要注意的是，使用 writelines() 函数向文件中写入多行数据时，不会自动给各行添加换行符。上面例子中，之所以 b.txt 文件中会逐行显示数据，是因为 readlines() 函数在读取各行数据时，读入了行尾的换行符。

### 关闭文件close ###

在前面章节中，对于使用 open() 函数打开的文件，我们一直都在用 close() 函数将其手动关闭。就来详细介绍一下 close() 函数。

close() 函数是专门用来关闭已打开文件的，其语法格式也很简单，如下所示：`file.close()`\`其中，file 表示已打开的文件对象。

读者可能一直存在这样的疑问，即使用 open() 函数打开的文件，在操作完成之后，一定要调用 close() 函数将其关闭吗？答案是肯定的。文件在打开并操作完成之后，就应该及时关闭，否则程序的运行可能出现问题。

举个例子，分析如下代码：

import os
        f = open("my_file.txt",'w')
        #...
        os.remove("my_file.txt")

代码中，我们引入了 os 模块，调用了该模块中的 remove() 函数，该函数的功能是删除指定的文件。但是，如果运行此程序，Python 解释器会报如下错误：

显然，由于我们使用了 open() 函数打开了 my\_file.txt 文件，但没有及时关闭，直接导致后续的 remove() 函数运行出现错误。因此，正确的程序应该是这样的：

import os
        f = open("my_file.txt",'w')
        f.close()
        #...
        os.remove("my_file.txt")

再举个例子，如果我们不调用 close() 函数关闭已打开的文件，确定不影响读取文件的操作，但会导致 write() 或者 writeline() 函数向文件中写数据时，写入失败。例如：

f = open("my_file.txt", 'w')
        f.write("shell")

程序执行后，虽然 Python 解释器不报错，但打开 my\_file.txt 文件会发现，根本没有写入成功。这是因为，在向以文本格式（而不是二进制格式）打开的文件中写入数据时，Python 出于效率的考虑，会先将数据临时存储到缓冲区中，只有使用 close() 函数关闭文件时，才会将缓冲区中的数据真正写入文件中。因此，在上面程序的最后添加如下代码：`f.close()`

当然在某些实际场景中，我们可能需要在将数据成功写入到文件中，但并不想关闭文件。这也是可以实现的，调用 flush() 函数即可，例如：

f = open("my_file.txt", 'w')
        f.write("shell")
        f.flush()

### 移动文件指针和获取当前指针的位置seek()和tell() ###

在讲解 seek() 函数和 tell() 函数之前，首先来了解一下什么是文件指针。我们知道，使用 open() 函数打开文件并读取文件中的内容时，总是会从文件的第一个字符（字节）开始读起。那么，有没有办法可以自定指定读取的起始位置呢？答案是肯定，这就需要移动文件指针的位置。

文件指针用于标明文件读写的起始位置。假如把文件看成一个水流，文件中每个数据（以 b 模式打开，每个数据就是一个字节；以普通模式打开，每个数据就是一个字符）就相当于一个水滴，而文件指针就标明了文件将要从文件的哪个位置开始读起。图 1 简单示意了文件指针的概念。

![在这里插入图片描述][971fb6889b1744ceab37e1fd73317924.png]

可以看到，通过移动文件指针的位置，再借助 read() 和 write() 函数，就可以轻松实现，读取文件中指定位置的数据（或者向文件中的指定位置写入数据）。

**注意:** 当向文件中写入数据时，如果不是文件的尾部，写入位置的原有数据不会自行向后移动，新写入的数据会将文件中处于该位置的数据直接覆盖掉。,还有如果文件没有内容,那么想从文件开头100字节位置开始写那么前100字节默认都补充0占位置

实现对文件指针的移动，文件对象提供了 tell() 函数和 seek() 函数。tell() 函数用于判断文件指针当前所处的位置，而 seek() 函数用于移动文件指针到文件的指定位置。

> tell() 函数

tell() 函数的用法很简单，其基本语法格式如下：`file.tell()`\` 其中，file 表示文件对象。

例如，在同一目录下，编写如下程序对 a.txt 文件做读取操作，a.txt 文件中内容为：==[http://www.baidu.net==][http_www.baidu.net]

a.txt 的代码如下：
    
        f = open("a.txt",'r')
        print(f.tell())  # 0
        print(f.read(3)) # htt
        print(f.tell())  # 3

可以看到，当使用 open() 函数打开文件时，文件指针的起始位置为 0，表示位于文件的开头处，当使用 read() 函数从文件中读取 3 个字符之后，文件指针同时向后移动了 3 个字符的位置。这就表明，当程序使用文件对象读写数据时，文件指针会自动向后移动：读写了多少个数据，文件指针就自动向后移动多少个位置。

> seek()函数

seek() 函数用于将文件指针移动至指定位置，该函数的语法格式如下：`file.seek(offset[, whence])`

其中，各个参数的含义如下：

*  file：表示文件对象；
 *  whence：作为可选参数，用于指定文件指针要放置的位置，该参数的参数值有 3 个选择：0 代表文件头（默认值）、1 代表当前位置、2 代表文件尾。
 *  offset：表示相对于 whence 位置文件指针的偏移量，正数表示向后偏移，负数表示向前偏移。例如，当`whence == 0 &&offset == 3`（即 seek(3,0) ），表示文件指针移动至距离文件开头处 3 个字符的位置；当`whence == 1 &&offset == 5`（即 seek(5,1) ），表示文件指针向后移动，移动至距离当前位置 5 个字符处。

注意，当 offset 值非 0 时，Python 要求文件必须要以二进制格式打开，否则会抛出 io.UnsupportedOperation 错误。

下面程序示范了文件指针操作：

f = open('a.txt', 'rb')
        # 判断文件指针的位置
        print(f.tell())
        # 读取一个字节，文件指针自动后移1个数据
        print(f.read(1))
        print(f.tell())
    
        # 将文件指针从文件开头，向后移动到 5 个字符的位置
        f.seek(5)
        print(f.tell())
        print(f.read(1))
    
        # 将文件指针从当前位置，向后移动到 5 个字符的位置
        f.seek(5, 1)
        print(f.tell())
        print(f.read(1))
    
        # 将文件指针从文件结尾，向前移动到距离 2 个字符的位置
        f.seek(-1, 2)
        print(f.tell())
        print(f.read(1))

注意：由于程序中使用 seek() 时，使用了非 0 的偏移量，因此文件的打开方式中必须包含 b，否则就会报 io.UnsupportedOperation 错误，

### 自动资源释放with ###

任何一门编程语言中，文件的输入输出、数据库的连接断开等，都是很常见的资源管理操作。但资源都是有限的，在写程序时，必须保证这些资源在使用过后得到释放，不然就容易造成资源泄露，轻者使得系统处理缓慢，严重时会使系统崩溃。  
  
例如，前面在介绍文件操作时，一直强调打开的文件最后一定要关闭，否则会程序的运行造成意想不到的隐患。但是，即便使用 close() 做好了关闭文件的操作，如果在打开文件或文件操作过程中抛出了异常，还是无法及时关闭文件。  
  
为了更好地避免此类问题，不同的编程语言都引入了不同的机制。在 Python 中，对应的解决方式是使用 with as 语句操作上下文管理器（context manager），它能够帮助我们自动分配并且释放资源。

**什么是上下文管理器:** 简单的理解，同时包含 \_\_enter\_\_() 和 \_\_exit\_\_() 方法的对象就是上下文管理器。

例如，使用 with as 操作已经打开的文件对象（本身就是上下文管理器），无论期间是否抛出异常，都能保证 with as 语句执行完毕后自动关闭已经打开的文件。

首先学习如何使用 with as 语句。with as 语句的基本语法格式为：

with 表达式 [as target]：
        代码块

此格式中，用 \[\] 括起来的部分可以使用，也可以省略。其中，target 参数用于指定一个变量，该语句会将 expression 指定的结果保存到该变量中。with as 语句中的代码块如果不想执行任何语句，可以直接使用 pass 语句代替。

with open('a.txt', 'a') as f:
            f.write("\nPython教程")

可以看到，通过使用 with as 语句，即便最终没有关闭文件，修改文件内容的操作也能成功。

### with底层原理 ###

不使用with打开文件的代码

try:
        f = open('z.txt', mode='rt')
        print(f.read())
    except FileNotFoundError:
        print('文件不存在')
    finally:
        f.close()

使用with语句打开文件的代码：

with open('a.txt', mode='rt') as f:
        print(f.read())

通过对比我们可以发现使用with可以让代码简洁优雅！

一个类同时包含 **enter**() 和 **exit**() 方法的对象就是上下文管理器。也就是说，上下文管理器必须实现如下两个方法：

> enter(self)：进入上下文管理器自动调用的方法，该方法会在 with as 代码块执行之前执行。如果 with 语句有 as子句，那么该方法的返回值会被赋值给 as 子句后的变量；该方法可以返回多个值，因此在 as 子句后面也可以指定多个变量（多个变量必须由“()”括起来组成元组）。

> exit（self, exc\_type, exc\_value, exc\_traceback）：退出上下文管理器自动调用的方法。该方法会在 with as 代码块执行之后执行。如果 with as 代码块成功执行结束，程序自动调用该方法，调用该方法的三个参数都为 None：如果 with as 代码块因为异常而中止，程序也自动调用该方法，使用 sys.exc\_info 得到的异常信息将作为调用该方法的参数

当 with as 操作上下文管理器时，就会在执行语句体之前，先执行上下文管理器的 **enter**() 方法，然后再执行语句体，最后执行 **exit**() 方法。

构建上下文管理器，常见的有 2 种方式：基于类实现和基于生成器实现。

> **基于类的上下文管理器**

自定义一个实现上下文管理协议的类，并尝试用 with as 语句来管理它：

class FkResource:
        def __init__(self, tag): 
               self.tag = tag  
               print('构造器,初始化资源: %s' % tag) 
        # 定义__enter__方法，with体之前的执行的方法    
        def __enter__(self):
                print('[__enter__ %s]: ' % self.tag)
                # 该返回值将作为as子句中变量的值 
                return 'fkit' 
                # 可以返回任意类型的值    
        # 定义__exit__方法，with体之后的执行的方法   
        def __exit__(self, exc_type, exc_value, exc_traceback):
                print('[__exit__ %s]: ' % self.tag)        
                # exc_traceback为None，代表没有异常       
                 if exc_traceback is None: 
                       print('没有异常时关闭资源') 
                 else: 
                       print('遇到异常时关闭资源') 
                 return False  
                  # 可以省略，默认返回None也被看做是False
    
    with FkResource('孙悟空') as dr: 
       print(dr) 
       print('[with代码块] 没有异常')
       print('-----------------------------')
    
    with FkResource('白骨精'): 
       print('[with代码块] 异常之前的代码')
       raise Exception:
       print('[with代码块] ~~~~~~~~异常之后的代码')

运行上面的程序，可以看到如下输出结果：

![在这里插入图片描述][891c4dfede9446c6ae38432efb3a8db9.png]

上面程序定义了一个 FkResource 类，并包含了 enter() 和 exit() 两个方法，因此该类的对象可以被 with as 语句管理。

此外，程序中两次使用 with as 语句管理 FkResource 对象。第一次代码块没有出现异常，第二次代码块出现了异常。从上面的输出结果来看，使用 with as 语句管理资源，无论代码块是否有异常，程序总可以自动执行 exit() 方法。

注意，当出现异常时，如果 **exit** 返回 False（默认不写返回值时，即为 False），则会重新抛出异常，让 with as 之外的语句逻辑来处理异常；反之，如果返回 True，则忽略异常，不再对异常进行处理。

> **基于生成器的上下文管理器**

除了基于类的上下文管理器，它还可以基于生成器实现。接下来先看一个例子。比如，我们可以使用装饰器 contextlib.contextmanager，来定义自己所需的基于生成器的上下文管理器，用以支持 with as 语句：

from contextlib import contextmanager
    @contextmanager
    def file_manager(name, mode):
        try: 
               f = open(name, mode)
               yield f   
        finally:
                f.close()
    
    with file_manager('a.txt', 'w') as f: 
       f.write('hello world')

段代码中，函数 file\_manager() 就是一个生成器，当我们执行 with as 语句时，便会打开文件，并返回文件对象 f；当 with 语句执行完后，finally 中的关闭文件操作便会执行。另外可以看到，使用基于生成器的上下文管理器时，不再用定义 enter() 和 exit() 方法，但需要加上装饰器 @contextmanager，这一点新手很容易疏忽。

需要强调的是，基于类的上下文管理器和基于生成器的上下文管理器，这两者在功能上是一致的。只不过，基于类的上下文管理器更加灵活，适用于大型的系统开发，而基于生成器的上下文管理器更加方便、简洁，适用于中小型程序。但是，无论使用哪一种，不用忘记在方法“exit()”或者是 finally 块中释放资源，这一点尤其重要。

### 对象的持久化存储 ###

Python 中有个序列化过程叫作 pickle，它能够实现任意对象与文本之间的相互转化，也可以实现任意对象与二进制之间的相互转化。也就是说，pickle 可以实现 Python 对象的存储及恢复。值得一提的是，pickle 是 python 语言的一个标准模块，安装 python 的同时就已经安装了 pickle 库，因此它不需要再单独安装，使用 import 将其导入到程序中，就可以直接使用。

pickle 模块提供了以下 4 个函数供我们使用：

1.  dumps()：将 Python 中的对象序列化成二进制对象，并返回；
2.  loads()：读取给定的二进制对象数据，并将其转换为 Python 对象；
3.  dump()：将 Python 中的对象序列化成二进制对象，并写入文件；
4.  load()：读取指定的序列化数据文件，并返回对象。
5.

以上这 4 个函数可以分成两类，其中 dumps 和 loads 实现基于内存的 Python 对象与二进制互转；dump 和 load 实现基于文件的 Python 对象与二进制互转。

> pickle.dumps()函数 (对象转换二进制)

此函数用于将 Python 对象转为二进制对象，其语法格式如下：`dumps(obj, protocol=None, *, fix_imports=True)`\`

此格式中各个参数的含义为：

*  obj：要转换的 Python 对象；
 *  protocol：pickle 的转码协议，取值为 0、1、2、3、4，其中 0、1、2 对应 Python 早期的版本，3 和 4 则对应 Python 3.x 版本及之后的版本。未指定情况下，默认为 3。
 *  其它参数：为了兼容 Python 2.x 版本而保留的参数，Python 3.x 中可以忽略。

import pickle
        tup1 = ('I love Python', {
        1,2,3}, None)
        #使用 dumps() 函数将 tup1 转成 p1
        p1 = pickle.dumps(tup1)
        print(p1) # b'\x80\x04\x95\x1e\x00\x00\x00\x00\x00\x00\x00\x8c\rI love Python\x94\x8f\x94(K\x01K\x02K\x03\x90N\x87\x94.'

> pickle.loads()函数

此函数用于将二进制对象转换成 Python 对象，其基本格式如下：`loads(data, *, fix_imports=True, encoding='ASCII', errors='strict')`

其中，data 参数表示要转换的二进制对象，其它参数只是为了兼容 Python 2.x 版本而保留的，可以忽略。

在上例 的基础上，将 p1 对象反序列化为 Python 对象。

import pickle
    
        #使用 loads() 函数将 p1 转成 Python 对象
        t2 = pickle.loads(p1) 
        print(t2)  # ('I love Python', {1, 2, 3}, None)

注意，在使用 loads() 函数将二进制对象反序列化成 Python 对象时，会自动识别转码协议，所以不需要将转码协议当作参数传入。并且，当待转换的二进制对象的字节数超过 pickle 的 Python 对象时，多余的字节将被忽略。

> pickle.dump()函数

此函数用于将 Python 对象转换成二进制文件，其基本语法格式为：`dump (obj, file,protocol=None, *, fix mports=True)`\`

其中各个参数的具体含义如下：

*  obj：要转换的 Python 对象。
 *  file：转换到指定的二进制文件中，要求该文件必须是以"wb"的打开方式进行操作。
 *  protocol：和 dumps() 函数中 protocol 参数的含义完全相同，因此这里不再重复描述。
 *  其他参数：为了兼容以前 Python 2.x版本而保留的参数，可以忽略。

import pickle
        tup1 = ('I love Python', {
        1,2,3}, None)
        #使用 dumps() 函数将 tup1 转成 p1
        with open ("a.txt", 'wb') as f: #打开文件
            pickle.dump(tup1, f) #用 dump 函数将 Python 对象转成二进制对象文件

运行完此程序后，会在该程序文件同级目录中，生成 a.txt 文件，但由于其内容为二进制数据，因此直接打开会看到乱码。

> pickle.load()函数

此函数和 dump() 函数相对应，用于将二进制对象文件转换成 Python 对象。该函数的基本语法格式为：

`load(file, *, fix_imports=True, encoding='ASCII', errors='strict')`\`

其中，file 参数表示要转换的二进制对象文件（必须以 “rb” 的打开方式操作文件），其它参数只是为了兼容 Python 2.x 版本而保留的参数，可以忽略。

import pickle
        tup1 = ('I love Python', {
        1,2,3}, None)
        #使用 dumps() 函数将 tup1 转成 p1
        with open ("a.txt", 'wb') as f: #打开文件
            pickle.dump(tup1, f) #用 dump 函数将 Python 对象转成二进制对象文件
        with open ("a.txt", 'rb') as f: #打开文件
            t3 = pickle.load(f) #将二进制文件对象转换成 Python 对象
            print(t3)

看似强大的 pickle 模块，其实也有它的短板，即 pickle 不支持并发地访问持久性对象，在复杂的系统环境下，尤其是读取海量数据时，使用 pickle 会使整个系统的`I/O`读取性能成为瓶颈。这种情况下，可以使用 ZODB。  
  
ZODB 是一个健壮的、多用户的和面向对象的数据库系统，专门用于存储 Python 语言中的对象数据，它能够存储和管理任意复杂的 Python 对象，并支持事务操作和并发控制。并且，ZODB 也是在 Python 的序列化操作基础之上实现的，因此要想有效地使用 ZODB，必须先学好 pickle。有关 ZODB 的详细介绍，读者可自行搜索相关文档

### 逐行读取多个文件 ###

前面章节中，我们学会了使用 open() 和 read()（或者 readline()、readlines() ）组合，来读取单个文件中的数据。但在某些场景中，可能需要读取多个文件的数据，这种情况下，再使用这个组合，显然就不合适了。

庆幸的是，Python 提供了 fileinput 模块，通过该模块中的 input() 函数，我们能同时打开指定的多个文件，还可以逐个读取这些文件中的内容。

fileinput 模块中 input() 该函数的语法格式如下：

`fileinput.input（files="filename1, filename2, ...", inplace=False, backup='', bufsize=0, mode='r', openhook=None）`\`

此函数会返回一个 FileInput 对象，它可以理解为是将多个指定文件合并之后的文件对象。其中，各个参数的含义如下：

*  files：多个文件的路径列表；
 *  inplace：用于指定是否将标准输出的结果写回到文件，此参数默认值为 False；
 *  backup：用于指定备份文件的扩展名；
 *  bufsize：指定缓冲区的大小，默认为 0；
 *  mode：打开文件的格式，默认为 r（只读格式）；
 *  openhook：控制文件的打开方式，例如编码格式等。

注意，和 open() 函数不同，input() 函数不能指定打开文件的编码格式，这意味着使用该函数读取的所有文件，除非以二进制方式进行读取，否则该文件编码格式都必须和当前操作系统默认的编码格式相同，不然 Python 解释器可能会提示 UnicodeDecodeError 错误。

和 open() 函数返回单个的文件对象不同，fileinput 对象无需调用类似 read()、readline()、readlines() 这样的函数，直接通过 for 循环即可按次序读取多个文件中的数据。

值得一提的是，fileinput 模块还提供了很多使用的函数（如表 1 所示），通过调用这些函数，可以帮我们更快地实现想要的功能。

![在这里插入图片描述][2c64582fb1884317a8fd87c140de11ba.png]

讲了这么多，接下来举个例子。假设使用 input() 读取 2 个文件，分别为 my\_file.txt 和 file.txt，它们位于同一目录，如下所示：

import fileinput
        #使用for循环遍历 fileinput 对象
        for line in fileinput.input(files=('my_file.txt', 'file.txt')):
            # 输出读取到的内容
            print(line)
        # 关闭文件流
        fileinput.close()

注意: 读取文件内容的次序，取决于 input() 函数中文件名的先后次序。

### 随机读取文件指定行 ###

除了可以借助 fileinput 模块实现读取文件外，Python 还提供了 linecache 模块。和前者不同，linecache 模块擅长读取指定文件中的指定行。换句话说，如果我们想读取某个文件中指定行包含的数据，就可以使用 linecache 模块。  
  
值得一提的是，linecache 模块常用来读取 Python 源文件中的代码，它使用的是 UTF-8 编码格式来读取文件内容。这意味着，使用该模块读取的文件，其编码格式也必须为 UTF-8，否则要么读取出来的数据是乱码，要么直接读取失败（Python 解释器会报 SyntaxError 异常）。  
  
要使用 linecache 模块，就必须知道其包含了哪些函数。linecache 模块中常用的函数及其功能如表 1 所示。

![在这里插入图片描述][d096bfa69a614ddb9add47b894eb052b.png]

import linecache
        import string
        #读取string模块中第 3 行的数据
        print(linecache.getline(string.__file__, 3))
        # 读取普通文件的第2行
        print(linecache.getline('my_file.txt', 2))

在执行该程序之前，需保证 my\_file.txt 文件是以 UTF-8 编码格式保存的（Python 提供的模块，通常编码格式为 UTF-8）。

### os.path 模块 ###

os.path 模块不仅提供了一些操作路径字符串的方法，还包含一些或者指定文件属性的一些方法，如表 1 所示。

![在这里插入图片描述][0cd55441bdae49bb9cb3661515a9fcc5.png]

from os import path
        # 获取绝对路径
        print(path.abspath("my_file.txt")) # C:\Users\mengma\Desktop\my_file.txt
        # 获取共同前缀
        print(path.commonprefix(['C://my_file.txt', 'C://a.txt']))# C://
        # 获取共同路径
        print(path.commonpath(['http://c.biancheng.net/python/', 'http://c.biancheng.net/shell/'])) # http:\c.biancheng.net
        # 获取目录
        print(path.dirname('C://my_file.txt')) # C://
        # 判断指定目录是否存在
        print(path.exists('my_file.txt')) # True

### 文件名称的匹配fnmatch ###

fnmatch 模块主要用于文件名称的匹配，其能力比简单的字符串匹配更强大，但比使用正则表达式相比稍弱。。如果在数据处理操作中，只需要使用简单的通配符就能完成文件名的匹配，则使用 fnmatch 模块是不错的选择。fnmatch 模块中，常用的函数及其功能如表 1 所示。

![在这里插入图片描述][4a6d6c51f965430795040813befe7827.png]

fnmatch 模块匹配文件名的模式使用的就是 UNIX shell 风格，其支持使用如下几个通配符：

*  \*：可匹配任意个任意字符。
 *  ？：可匹配一个任意字符。
 *  \[字符序列\]：可匹配中括号里字符序列中的任意字符。该字符序列也支持中画线表示法。比如 \[a-c\] 可代表 a、b 和 c 字符中任意一个。
 *  \[!字符序列\]：可匹配不在中括号里字符序列中的任意字符。

例如，下面程序演示表 1 中一些函数的用法及功能：

import fnmatch
        #filter()
        print(fnmatch.filter(['dlsf', 'ewro.txt', 'te.py', 'youe.py'], '*.txt'))  # ['ewro.txt']
    
        #fnmatch()        my_file.txt
        for file in ['word.doc','index.py','my_file.txt']:
            if fnmatch.fnmatch(file,'*.txt'):
                print(file)
     
        #fnmatchcase()   ['my_file.txt']
        print([addr for addr in ['word.doc','index.py','my_file.txt','a.TXT'] if fnmatch.fnmatchcase(addr, '*.txt')])
    
    
        #translate()   (?s:a.*b\.txt)\Z
        print(fnmatch.translate('a*b.txt'))

### 生成临时文件和临时目录 ###

tempfile 模块专门用于创建临时文件和临时目录，它既可以在 UNIX 平台上运行良好，也可以在 Windows 平台上运行良好。tempfile 模块中常用的函数，如表 1 所示。

![在这里插入图片描述][cfb1c302b96b46268ddc13c086ffe884.png]

提示：表中有些函数包含很多参数，但这些参数都具有自己的默认值，因此如果没有特殊要求，可以不对其传参。

tempfile 模块还提供了 tempfile.mkstemp() 和 tempfile.mkdtemp() 两个低级别的函数。上面介绍的 4 个用于创建临时文件和临时目录的函数都是高级别的函数，高级别的函数支持自动清理，而且可以与 with 语句一起使用，而这两个低级别的函数则不支持，因此一般推荐使用高级别的函数来创建临时文件和临时目录。

此外，tempfile 模块还提供了 tempfile.tempdir 属性，通过对该属性赋值可以改变系统的临时目录。下面程序示范了如何使用临时文件和临时目录：

import tempfile
        # 创建临时文件
        fp = tempfile.TemporaryFile()
        print(fp.name)
        fp.write('两情若是久长时，'.encode('utf-8'))
        fp.write('又岂在朝朝暮暮。'.encode('utf-8'))
        # 将文件指针移到开始处，准备读取文件
        fp.seek(0)
        print(fp.read().decode('utf-8')) # 输出刚才写入的内容
        # 关闭文件，该文件将会被自动删除
        fp.close()
    
        # 通过with语句创建临时文件，with会自动关闭临时文件
        with tempfile.TemporaryFile() as fp:
            # 写入内容
            fp.write(b'I Love Python!')
            # 将文件指针移到开始处，准备读取文件
            fp.seek(0)
            # 读取文件内容
            print(fp.read()) # b'I Love Python!'
    
        # 通过with语句创建临时目录
        with tempfile.TemporaryDirectory() as tmpdirname:
            print('创建临时目录', tmpdirname)

上面程序以两种方式来创建临时文件：

1.  第一种方式是手动创建临时文件，读写临时文件后需要主动关闭它，当程序关闭该临时文件时，该文件会被自动删除。
2.  第二种方式则是使用 with 语句创建临时文件，这样 with 语句会自动关闭临时文件。

上面程序最后还创建了临时目录。由于程序使用 with 语句来管理临时目录，因此程序也会自动删除该临时目录。  
  
运行上面程序，可以看到如下输出结果：

C:\Users\admin\AppData\Local\Temp\tmphvehw9z1
    两情若是久长时，又岂在朝朝暮暮。
    b'I Love Python!'
    创建临时目录C:\Users\admin\AppData\Local\Temp\tmp3sjbnwob

![在这里插入图片描述][241d60d901ab468c8532f2a2d4413093.gif]

点赞 -收藏-关注-便于以后复习和收到最新内容有其他问题在评论区讨论-或者私信我-收到会在第一时间回复在本博客学习的技术不得以任何方式直接或者间接的从事违反中华人民共和国法律,内容仅供学习、交流与参考 免责声明：本文部分素材来源于网络，版权归原创者所有，如存在文章/图片/音视频等使用不当的情况，请随时私信联系我、以迅速采取适当措施，避免给双方造成不必要的经济损失。感谢,配合,希望我的努力对你有帮助^\_^

[588a9d4bc8684311b0985d135d9c576c.png]: https://img-blog.csdnimg.cn/588a9d4bc8684311b0985d135d9c576c.png
[7b4ba5f3224346cdad0ddf612668aa4f.png]: https://img-blog.csdnimg.cn/7b4ba5f3224346cdad0ddf612668aa4f.png
[ee4cd894457a429aadee11da94717380.png]: https://img-blog.csdnimg.cn/ee4cd894457a429aadee11da94717380.png
[d4eb11bdbd604cb28d908d853af3b612.png]: https://img-blog.csdnimg.cn/d4eb11bdbd604cb28d908d853af3b612.png
[971fb6889b1744ceab37e1fd73317924.png]: https://img-blog.csdnimg.cn/971fb6889b1744ceab37e1fd73317924.png
[http_www.baidu.net]: http://www.baidu.net==
[891c4dfede9446c6ae38432efb3a8db9.png]: https://img-blog.csdnimg.cn/891c4dfede9446c6ae38432efb3a8db9.png
[2c64582fb1884317a8fd87c140de11ba.png]: https://img-blog.csdnimg.cn/2c64582fb1884317a8fd87c140de11ba.png
[d096bfa69a614ddb9add47b894eb052b.png]: https://img-blog.csdnimg.cn/d096bfa69a614ddb9add47b894eb052b.png
[0cd55441bdae49bb9cb3661515a9fcc5.png]: https://img-blog.csdnimg.cn/0cd55441bdae49bb9cb3661515a9fcc5.png
[4a6d6c51f965430795040813befe7827.png]: https://img-blog.csdnimg.cn/4a6d6c51f965430795040813befe7827.png
[cfb1c302b96b46268ddc13c086ffe884.png]: https://img-blog.csdnimg.cn/cfb1c302b96b46268ddc13c086ffe884.png
[241d60d901ab468c8532f2a2d4413093.gif]: https://img-blog.csdnimg.cn/241d60d901ab468c8532f2a2d4413093.gif