文件的打开和关闭

  1. 内置open函数打开文件
    2. 在 Python 中，如果想要操作文件，首先需要创建或者打开指定的文件，并创建一个文件对象，而这些工作可以通过内置的 open() 函数实现。

    open() 函数用于创建或打开指定文件，返回一个操作文件的对象，该函数的常用语法格式如下：

    file = open(file_name [, mode='r' [ , buffering=-1 [ , encoding = None ]]])

    此格式中，用 [ ] 括起来的部分为可选参数，即可以使用也可以省略。其中，各个参数所代表的含义如下：
    • file：表示open函数要创建的文件对象。
    • file_name：要创建或打开文件的文件名称，该名称要用引号（单引号或双引号都可以）括起来。需要注意的是，如果要打开的文件和当前执行的代码文件位于同一目录，则直接写文件名即可；否则，此参数需要指定打开文件所在的完整路径。
    • mode：可选参数，用于指定文件的打开模式。可选的打开模式如表 1 所示。如果不写，则默认以只读（r）模式打开文件。
    • buffing：可选参数，用于指定对文件做读写操作时，是否使用缓冲区。
    • encoding：手动设定打开文件时所使用的编码格式，不同平台的 ecoding 参数值也不同，以 Windows 为例，其默认为 cp936（实际上就是 GBK 编码,即记事本保存的编码格式为ANSI）。

    表 1 open 函数支持的文件打开模式
    模式 意义 注意事项
    r 只读模式打开文件，读文件内容的指针会放在文件的开头。 操作的文件必须存在。
    rb 以二进制格式、采用只读模式打开文件，读文件内容的指针位于文件的开头，一般用于非文本文件，如图片文件、音频文件等。
    r+ 打开文件后，既可以从头读取文件内容，也可以从开头向文件中写入新的内容，写入的新内容会覆盖文件中等长度的原有内容。
    rb+ 以二进制格式、采用读写模式打开文件，读写文件的指针会放在文件的开头，通常针对非文本文件（如音频文件）。
    w 以只写模式打开文件，若该文件存在，打开时会清空文件中原有的内容。 若文件存在，会清空其原有内容（覆盖文件）；反之，则创建新文件。
    wb 以二进制格式、只写模式打开文件，一般用于非文本文件（如音频文件）
    w+ 打开文件后，会对原有内容进行清空，并对该文件有读写权限。
    wb+ 以二进制格式、读写模式打开文件，一般用于非文本文件
    a 以追加模式打开一个文件，对文件只有写入权限，如果文件已经存在，文件指针将放在文件的末尾（即新写入内容会位于已有内容之后）；反之，则会创建新文件。  
    ab 以二进制格式打开文件，并采用追加模式，对文件只有写权限。如果该文件已存在，文件指针位于文件末尾（新写入文件会位于已有内容之后）；反之，则创建新文件。  
    a+ 以读写模式打开文件；如果文件存在，文件指针放在文件的末尾（新写入文件会位于已有内容之后）；反之，则创建新文件。  
    ab+ 以二进制模式打开文件，并采用追加模式，对文件具有读写权限，如果文件存在，则文件指针位于文件的末尾（新写入文件会位于已有内容之后）；反之，则创建新文件。  

    总结如下：

    1. r 表示从文件表读取
    2. w 表示写入文件
    3. a 表示追加写入
    4. b 表示以二进制方式操作文件
    5. + 表示可读写文件

     

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

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

    不同文件打开模式的功能
    图 2 不同文件打开模式的功能
    【例 1】默认打开 "a.txt" 文件。 
    1. #当前程序文件同目录下没有 a.txt 文件
    2. file = open("a.txt")
    3. print(file)
    当以默认模式打开文件时，默认使用 r 权限，由于该权限要求打开的文件必须存在，因此运行此代码会报如下错误：

    FileNotFoundError Traceback (most recent call last)
    <ipython-input-4-dad991fb07c9> in <module>
    ----> 1 file=open("a.txt")
    2 print(file)

    FileNotFoundError: [Errno 2] No such file or directory: 'a.txt'


    现在，在程序文件同目录下，手动创建一个 a.txt 文件，并再次运行该程序，其运行结果为：

    <_io.TextIOWrapper name='a.txt' mode='r' encoding='cp936'>

    可以看到，当前输出结果中，输出了 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 参数的值。

    果 buffering 参数值为大于 1 的整数，该整数用于指定缓冲区的大小（单位是字节）；如果 buffering 参数的值为负数，则代表使用默认的缓冲区大小。

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

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

    open()函数返回的文件对象常用的属性

    成功打开文件之后，可以调用文件对象本身拥有的属性获取当前文件的部分信息，其常见的属性为：
    • file.name：返回文件的名称；
    • file.mode：返回打开文件时，采用的文件打开模式；
    • file.encoding：返回打开文件时使用的编码格式；
    • file.closed：判断文件是否己经关闭。
    举个例子： 
    1. # 以默认方式打开文件
    2. f = open('my_file.txt')
    3.  
    4. # 输出文件是否已经关闭
    5. print(f.closed)
    6.  
    7. # 输出访问模式
    8. print(f.mode)
    9.  
    10. #输出编码格式
    11. print(f.encoding)
    12.  
    13. # 输出文件名
    14. print(f.name)
    程序执行结果为：

    False
    r
    cp936
    my_file.txt

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

  2. 利用文件对象关闭文件——file.close()
    3. 对于使用 open() 函数打开的文件，使用close() 函数将其手动关闭。
    close() 函数是专门用来关闭已打开文件的，其语法格式也很简单，如下所示：

    file.close()

    其中，file 表示已打开的文件对象。

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

    举个例子，分析如下代码： 
    1. import os
    2. f = open("my_file.txt",'w')
    3. #...
    4. os.remove("my_file.txt")

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

    Traceback (most recent call last):
      File "C:\Users\mengma\Desktop\demo.py", line 4, in <module>
        os.remove("my_file.txt")
    PermissionError: [WinError 32] 另一个程序正在使用此文件，进程无法访问。: 'my_file.txt'

    显然，由于我们使用了 open() 函数打开了 my_file.txt 文件，但没有及时关闭，直接导致后续的 remove() 函数运行出现错误。因此，正确的程序应该是这样的： 
    1. import os
    2. f = open("my_file.txt",'w')
    3. f.close()
    4. #...
    5. os.remove("my_file.txt")
    当确定 my_file.txt 文件可以被删除时，再次运行程序，可以发现该文件已经被成功删除了。

    再举个例子，如果我们不调用 close() 函数关闭已打开的文件，确定不影响读取文件的操作，但会导致 write() 或者 writeline() 函数向文件中写数据时，写入失败。例如：
    1. f = open("my_file.txt", 'w')
    2. f.write("http://c.biancheng.net/shell/")
    程序执行后，虽然 Python 解释器不报错，但打开 my_file.txt 文件会发现，根本没有写入成功。这是因为，在向以文本格式（而不是二进制格式）打开的文件中写入数据时，Python 出于效率的考虑，会先将数据临时存储到缓冲区中，只有使用 close() 函数关闭文件时，才会将缓冲区中的数据真正写入文件中。

    因此，在上面程序的最后添加如下代码： 
    1. f.close()
    再次运行程序，就会看到 "http://c.biancheng.net/shell/" 成功写入到了 a.txt 文件。

    当然在某些实际场景中，我们可能需要在将数据成功写入到文件中，但并不想关闭文件。这也是可以实现的，调用 flush() 函数即可，例如： 
    1. f = open("my_file.txt", 'w')
    2. f.write("http://c.biancheng.net/shell/")
    3. f.flush()
    打开 my_file.txt 文件，会发现已经向文件中成功写入了字符串“http://c.biancheng.net/shell/”。
  3. with ... as ...上下文管理器打开文件
    4. 使用 with as 操作打开的文件对象（本身就是上下文管理器），无论期间是否抛出异常，都能保证 with as 语句执行完毕后自动关闭已经打开的文件。

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

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

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

    举个例子，假设有一个 a.txt 文件，其存储内容如下：

    C语言中文网
    http://c.biancheng.net

    在和 a.txt 同级目录下，创建一个 .py 文件，并编写如下代码： 
    1. with open('a.txt', 'a') as f:
    2.     f.write("\nPython教程")
    运行结果为：

    C语言中文网
    http://c.biancheng.net
    Python教程

    with open("a.txt") as fr,open("b.txt",mode="w") as fw:
        fw.writelines(fr.readlines( ))

with open("a.txt") as fr:
        with open("b.txt",mode="w") as fw:
            fw.writelines(fr.readlines( ))
    可以看到，通过使用 with as 语句，即便最终没有关闭文件，修改文件内容的操作也能成功。
    （了解）简单的理解，同时包含 __enter__() 和 __exit__() 方法的对象就可以使用with as上下文管理器。文件对象内部实现了__enter__() 和 __exit__() 方法
    1. __enter__(self)：进入上下文管理器自动调用的方法，该方法会在 with as 代码块执行之前执行。如果 with 语句有 as子句，那么该方法的返回值会被赋值给 as 子句后的变量；该方法可以返回多个值，因此在 as 子句后面也可以指定多个变量（多个变量必须由“()”括起来组成元组）。
    2. __exit__（self, exc_type, exc_value, exc_traceback）：退出上下文管理器自动调用的方法。该方法会在 with as 代码块执行之后执行。如果 with as 代码块成功执行结束，程序自动调用该方法，调用该方法的三个参数都为 None：如果 with as 代码块因为异常而中止，程序也自动调用该方法，使用 sys.exc_info 得到的异常信息将作为调用该方法的参数。