Python 完美诠释"高内聚"概念的 IO 流 API 体系结构

1. 前言

第一次接触 Python 语言的 IO API 时，是惊艳的。相比较其它语言所提供的 IO 流 API 。

无论是站在使用者的角度还是站在底层设计者的角度，都可以称得上无与伦比。

很多人在学习 JAVA 语言中的 IO 流 API 时，几乎是崩溃的。其 API 太多、API 之间的关系过于复杂。类的层次结构需要花费很多时间才能搞明白。API 设计者未免有炫技之嫌。

而 Python 的 IO 流操作，才真正应了哪句话：人生苦短，我学 python 。

以 open( ) 函数 为操作起点，便捷、快速地完成所有操作，绝对算得上轻量级设计的典范，且高度诠释了“高内聚”概念。使用起来颇有“四两拨千金”的轻松。

通过了解 open( ) 函数的参数设计，其开闭设计思想可谓使用到了极致。

2. open( ) 函数

2.1 函数原型

def open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True):

    ……

2.2 函数功能

打开一个指定位置的文件并返回 IO 流对象。

2.3 函数参数

Tip: open( ) 函数的参数看起来虽然有点多，在使用时，很多参数都可以采用默认设置，它会提供最优的工作方案。

file 参数： 指定文件位置。可以是一个字符串描述的文件路径，也可以是一个文件描述符（int 类型）。

Tip： 当使用字符串描述时，可以是绝对路径，也可以是相对路径。

绝对路径： 以绝对位置作为路径的起点。 不同的操作系统中会有差异性，windows 以逻辑盘符为绝对起点，Liunx 以 "/" 根目录为绝对起点。
```
file=open("d:/guoke.txt")
```
Tip： 上述代码运行时，需要保证在系统的 d 盘下有一个名字 "guoke.txt" 的文件。

相对路径： 所谓相对路径指以某一个已经存在的路径（或叫参照目录、当前目录）做起点。默认情况下，相对路径以当前项目目录作为参照目录。可以使用 os 模块 中的 getcwd( ) 方法获取当前参照目录的信息。
```
import os

print(os.getcwd())

# 本代码的测试项目放在 d:\myc 下;项目名称：filedmeo

# 输出结果

# D:\myc\filedmeo
```
如下代码需要保证在项目目录中存在 " guoke.txt "
```
file = open("guoke.txt")

# 执行时， python 解释器会自动拼接一个完整路径 D:\myc\filedmeo\guoke.txt
```
参照目录 可以是不固定的，而是可变的。

改变相对路径的参考目录：
```
import os

# 把 d 盘作为当前目录

os.chdir("d:/")

print(os.getcwd())

file = open("guoke.txt")

# python 解释器会从 d 盘根目录下查找 guoke.txt 文件
```
描述符： 使用 open( ) 函数打开一个文件后，python 解释器系统会为此文件指定一个唯一的数字标识符。可以用此描述符作为 open( ) 参数。
```
file = open("guo_ke.txt")

# fileno() 获取文件的描述符

file1 = open(file.fileno())
```
Tip： 用户文件的描述符从 3 开始。0，1，2 是系统保留文件描述符。
- 0：表示标准输入（键盘）设备描述符。
```
file = open(0)

print("请输入一个数字：")

res = file.readline()

print("回显:", res)

'''

输出结果

请输入一个数字：

88

回显: 88

'''
```
- 1：表示标准输出设备（显示器）描述符。
```
file = open(1, "w")

file.write("you are welcome!")

#类似于 print("you are welcome!") 的功能
```
- 2：表示标准错误输出设备（显示器）描述符。
```
file = open(2, "w")

file.write("you are welcome!")

#输出文字会以红色亮显
```

mode： 文件操作模式。默认为 "r" ，表示只读模式。

模式关键字	描述	异常
'r'	以只读方式打开文件	文件不存时，会抛出 FileNotFoundError 异常
‘r+’	以可读、可写方式打开文件	文件不存时，会抛出 FileNotFoundError 异常
‘w’	以可写方式打开文件	文件不存在时，创建一个字节 0 的空文件
‘w+’	以可写、可读方式打开文件（清空原内容）	文件不存在时，创建一个字节 0 的空文件
‘a’	以追加方式打开文件	文件不存在时，创建一个字节 0 的空文件
‘a+’	以可追加、可读方式打开文件	文件不存在时，创建一个字节 0 的空文件
‘t’	以文本文件格式打开文件	默认
‘b’	以二进制格式打开文件
‘x’	创建空文件并且可写	文件存在时，抛出 FileExistsError 异常

只要在模式组合中有 'r' 关键字，则文件必须提前存在：

file = open("guo_ke.txt")

file = open("guo_ke.txt", 'r')

file = open("guo_ke.txt", 'rt')

file = open("guo_ke.txt", 'r+t')

只要在模式组合中有 ‘w’ 关键字，则文件可以不必预先存在，如果存在，则原文件中内容会被清空。

# 可写

file = open("guo_ke.txt", 'w')

# 可写、可读

file = open("guo_ke.txt", 'w+')

只要在模式组合中有 ‘a’ 关键字，则文件可以不必预先存在，如果存在，原文件中内空不会被清空

# 追加写

file = open("guo_ke.txt", 'a')

# 追加写、且可读

file = open("guo_ke.txt", 'a+')

buffering： 设置缓冲策略。可取值为 0、1、>1 。
- 0：在二进制模式下关闭缓冲。
- 1：在文本模式下使用行缓冲。
  
  行缓冲：以行数据为单位进行缓存。
- >1 的整数： 指定缓冲区的大小（以字节为单位）。
如果没有指定 buffering 参数，则会提供默认缓冲策略：
- 二进制文件使用固定大小的缓冲块。
  
  在许多系统上，缓冲区的长度通常为 4096 或 8192 字节。
- "Interactive" 文本文件（ isatty() 返回 True 的文件）使用行缓冲。其他文本文件使用和二进制文件相同的缓冲策略。
  
  isatty( ) 方法检测文件是否连接到一个终端设备。
encoding： 指定解码或编码文件时使用的编码名称。

只能用于文本文件。默认使用平台编码。
errors： 指定如何处理编码和解码时抛出的错误。可选项如下：
- strict： 如果存在编码错误，则引发 ValueError 异常。默认值 None 具有相同的效果。
- ignore： 忽略错误。有可能会数据丢失。
- replace： 会将替换标记（例如 '?' ）插入有错误数据的地方。
newline： 在读或写文本内容时如何处理换行符号。可取值 None，' '，'\n'，'\r' 和 '\r\n'。

OS 不同，换行符的描述也有差异。Unix 的行结束 '\n'、Windows 中为 '\r\n'
- 从流中读数据时，如果 newline 为 None，则启用平台约定换行模式。
- 写入流时，如果 newline 为 None，则写入的任何 '\n' 字符都将转换为系统默认行分隔符。如果 newline 是 ' ' 或 '\n'，则直接写入。如果 newline 是任何其他合法值，则写入的任何 '\n' 字符将被转换为给定的字符串。

closefd：

file = open("guo_ke.txt",closefd=False)

'''

输出结果

Traceback (most recent call last):

  File "D:/myc/filedmeo/文件嵌套.py", line 1, in <module>

    file = open("guo_ke.txt",closefd=False)

ValueError: Cannot use closefd=False with file name

'''

如果通过一个字符串路径描述打开文件， closefd 必须为 True （默认值），否则将引发错误。

file = open("guo_ke.txt", )

# 通过 file 文件的描述符打开文件

file1 = open(file.fileno(), closefd=False)

file1.close()

print("先打开文件：", file.closed)

print("后打开文件：", file1.closed)

'''

输出结果

先打开文件： False

后打开文件： True

'''

当 open file1 文件时设置为 closefd=False ，则当 file1 文件关闭后，file 文件将保持打开状态。

opener：可理解为 open( ) 函数是一个高级封装对象，本质是通过 opener 参数接入了一个真正的具有底层文件操作能力的接口。

import os

def opener(path, flags):

    return os.open(path, flags)

# 调用 opener('guo_ke.txt','r') 时的参数来自于 open() 的第一个和第二个

with open('guo_ke.txt', 'r', opener=opener) as f:

    print(f.read())

默认 opener 参数引用的就是 os.open( ) 方法。

3. 读写操作

调用 open( ) 函数后会返回一个 IO 流对象。IO 流对象中提供了常规的与读写相关的属性和方法。

class IO(Generic[AnyStr]):

    #返回文件的读写模式

    @abstractproperty

    def mode(self) -> str:

        pass

    #返回文件的名称

    @abstractproperty

    def name(self) -> str:

        pass

    #关闭文件

    @abstractmethod

    def close(self) -> None:

        pass

    #判断文件是否关闭

    @abstractproperty

    def closed(self) -> bool:

        pass

    #返回文件描述符号，每打开一个文件，python 会分配一个唯一的数字描述符号

    @abstractmethod

    def fileno(self) -> int:

        pass

    #刷新缓存中的内容

    @abstractmethod

    def flush(self) -> None:

        pass

    #是否连接到一个终端设备

    @abstractmethod

    def isatty(self) -> bool:

        pass

    # 参数 n 为 -1 或不传递时，一次性读取文件中的所有内容，如果文件内容过多，可分多次读取

    # 读取到文件末尾时，返回一个空字符串 ('')

    @abstractmethod

    def read(self, n: int = -1) -> AnyStr:

        pass

    # 文件是否可读

    @abstractmethod

    def readable(self) -> bool:

        pass

    # 从文件中读取一行；换行符（\n）留在字符串的末尾

    # 返回一个空的字符串时，表示已经到达了文件末尾

    # 空行使用 '\n' 表示

    @abstractmethod

    def readline(self, limit: int = -1) -> AnyStr:

        pass

    # 读取所有行并存储到列表中

    # 也可以使用 list(f)

    @abstractmethod

    def readlines(self, hint: int = -1) -> List[AnyStr]:

        pass

    # 移动读写光标，改变文件的读写位置

    # 通过向一个参考点添加 offset 来计算位置；参考点由 whence 参数指定。

    # whence 的 0 值表示从文件开头起算，1 表示使用当前文件位置，2 表示使用文件末尾作为参考点。

    # whence 如果省略则默认值为 0，即使用文件开头作为参考点。

    @abstractmethod

    def seek(self, offset: int, whence: int = 0) -> int:

        pass

   # 是否可以移动光标

    @abstractmethod

    def seekable(self) -> bool:

        pass

    # 返回文件的当前位置

    @abstractmethod

    def tell(self) -> int:

        pass

    # 清除内容

    @abstractmethod

    def truncate(self, size: int = None) -> int:

        pass

    # 是否可写

    @abstractmethod

    def writable(self) -> bool:

        pass

    # 向文件写入内容

    @abstractmethod

    def write(self, s: AnyStr) -> int:

        pass

    #向文件写入一行数据

    @abstractmethod

    def writelines(self, lines: List[AnyStr]) -> None:

        pass

调用 open( ) 函数中使用文本模式时返回的是 TextIO 对象，相比较父类，多了几个特定于文本操作的属性。

class TextIO(IO[str]):

    # 缓存信息

    @abstractproperty

    def buffer(self) -> BinaryIO:

        pass

    # 设置编码

    @abstractproperty

    def encoding(self) -> str:

        pass

    # 设备错误处理方案

    @abstractproperty

    def errors(self) -> Optional[str]:

        pass

    # 设置行缓存

    @abstractproperty

    def line_buffering(self) -> bool:

        pass

    # 换行符的设置方案

    @abstractproperty

    def newlines(self) -> Any:

        pass

3.1 文本文件读操作

基本操作

file = open("guo_ke.txt", mode='r')

print("读写模式：", file.mode)

print("文件名：", file.name)

print("文件是否关闭:", file.closed)

print("文件描述符号：", file.fileno())

print("文件是否可读", file.readable())

print("是否是标准输入流：", file.isatty())

print("文件是否可写:", file.writable())

print("缓存方案", file.buffer)

print("文件默认编码:", file.encoding)

print("编程错误处理方案", file.errors)

print("是否设置行缓存", file.line_buffering)

print("换行符的设置方案", file.newlines)

'''

输出结果

读写模式： r

文件名： guo_ke.txt

文件是否关闭: False

文件描述符号： 3

文件是否可读 True

是否是标准输入流： False

文件是否可写: False

缓存方案 <_io.BufferedReader name='guo_ke.txt'>

文件默认编码: cp936

编程错误处理方案 strict

是否设置行缓存 False

换行符的设置方案 None

'''

cp936 指的是系统的第 936 号编码方案，即 GBK 编码。

多样化的读方法：

无论是读还是写时，需要理解一个文件指针（光标）的概念，也可理解为文件位置。读或写时，只能从当前位置向前移动。

提前准备好一个文本文件，在文件中写入如下内容

You hide in my heart deeply.

Happiness! There is only you and I together time...

With you just I don't want to give anyone the chance.

Honey, can you marry me, I'll marry you!

Don't know love you count is a close reason?

read( ) 方法的使用

file = open("guo_ke.txt", "r")

print("----------读取所有内容--------------")

res = file.read()

print(res)

print("----------读取部分内容--------------")

# 重新回到文件头

file.seek(0)

res = file.read(100)

print(res)

# 关闭文件资源

file.close()

'''

输出结果

----------读取所有内容--------------

You hide in my heart deeply.

Happiness! There is only you and I together time...

With you just I don't want to give anyone the chance.

Honey, can you marry me, I'll marry you!

Don't know love you count is a close reason?

----------读取部分内容--------------

You hide in my heart deeply.

Happiness! There is only you and I together time...

With you just I don

'''

这里有一个细节要注意：

第一次读取完所有文件内容后，读取位置已经移到了文件尾部。继续读取时是不能读到数据的。

可通过 seek( ) 方法，把光标移到文件头部。

readline( ) 方法的使用

file = open("guo_ke.txt", "r")

print("---------读取一行--------")

res = file.readline()

print("数据长度:", len(res))

print(res)

print("-----------限制内容-------------")

res = file.readline(10)

print("数据长度:", len(res))

print(res)

print("-----------以行为单位读取所有数据-------------")

#回到文件头部位置

file.seek(0)

while True:

    res = file.readline()

    print(res)

    if res == "":

        break

file.close()

'''

输出结果

---------读取一行--------

数据长度: 29

You hide in my heart deeply.

-----------限制内容-------------

数据长度: 10

Happiness!

-----------以行为单位读取所有数据-------------

You hide in my heart deeply.

Happiness! There is only you and I together time...

With you just I don't want to give anyone the chance.

Honey, can you marry me, I'll marry you!

Don't know love you count is a close reason?

'''

一行一行读取所有内容时，输出时会在行与行之间产生一个空行。原因是行结束符号 'n' 会被当成一个空行输出。

readline（ ) 还有一个兄弟 readlines() 。把数据以行为单位一次性存储一个列表中.

file = open("guo_ke.txt", "r")

print("-----------把文件中数据以行为单位存储在列表中---------")

res = file.readlines()

print(res)

file.close()

'''

输出结果

-----------把文件中数据以行为单位存储在列表中---------

['You hide in my heart deeply.\n', 'Happiness! There is only you and I together time...\n', "With you just I don't want to give anyone the chance.\n", "Honey, can you marry me, I'll marry you!\n", "Don't know love you count is a close reason?"]

'''

注意使用数据时换行符号的影响。

读取所有行也可以使用 ist(f) 方式。
file = open("guo_ke.txt", "r")

print(list(file))

文件对象支持以行为单位进行迭代操作。

file = open("guo_ke.txt", "r")

print("-----------迭代方式输出文件内容---------")

for f in file:

    print(f)

file.close()

3.2 文本文件写操作

如果使用 "w" 模式进行写操作时，会丢失原来数据。如果不希望这样的事情发生，可使用 "a" 模式对文写操作。

file = open("guo_ke_0.txt", "w")

file.write("this is a test")

# 添加新行

file.write("\n")

file.write("who are you?")

# 把列表中数据一次写入文件

lst = ["food\n", "fish\n", "cat\n"]

file.write("\n")

file.writelines(lst)

file.close()

3.3 编码的问题

对文件同时做读写操作时，请务必保证编码的一致性。

如下面的代码就会出现 UnicodeDecodeError 异常。

file = open("guo_ke_1.txt", mode="w", encoding="utf-8")

file.write("你好！果壳……")

file.close()

file_ = open("guo_ke_1.txt", mode="r", encoding="gbk")

res = file_.read()

print(res)

'''

输出结果

Traceback (most recent call last):

  File "D:/myc/filedmeo/乱码问题.py", line 6, in <module>

    res = file_.read()

UnicodeDecodeError: 'gbk' codec can't decode byte 0x80 in position 16: illegal multibyte sequence

'''

3.4 二进制文本件操作

调用 open( ) 函数时使用 mode='rb' 返回的是 BinaryIO 对象。此对象提供了对二进制文件的读写，对二进制文件的读写操作和文本的没有什么太多区别。

文本文件与二进制文本的操作使用一个参数就能灵活切换。

class BinaryIO(IO[bytes]):

    @abstractmethod

    def write(self, s: Union[bytes, bytearray]) -> int:

        pass

4. 总结

open( ) 函数是一个神奇的存在。无论是对文本文件还是二进进制文件，无论是读还是写，它都能工作的很好。不得不佩服 python 设计者的简洁设计理念。

像通过文件描述符打开文件，使用 opener 参数自定义底层实现，都可称得上神来之笔。

另使用文件后一定要关闭，除了可以直接调用 close( ) 方法外，还可能使用 with 语句，此语法结构能自动调用 close().

with open("guo_ke.txt") as f:

    pass