9. Python的IO编程

Python文件读写官方文档

9.1 IO编程

'''
IO编程
阅读: 5369299
IO在计算机中指Input/Output，也就是输入和输出。由于程序和运行时数据是在内存中驻留，
由CPU这个超快的计算核心来执行，涉及到数据交换的地方，通常是磁盘、网络等，就需要IO接口。

比如你打开浏览器，访问新浪首页，浏览器这个程序就需要通过网络IO获取新浪的网页。浏览器
首先会发送数据给新浪服务器，告诉它我想要首页的HTML，这个动作是往外发数据，叫Output，
随后新浪服务器把网页发过来，这个动作是从外面接收数据，叫Input。所以，通常，程序完成
IO操作会有Input和Output两个数据流。当然也有只用一个的情况，比如，从磁盘读取文件到
内存，就只有Input操作，反过来，把数据写到磁盘文件里，就只是一个Output操作。

IO编程中，Stream（流）是一个很重要的概念，可以把流想象成一个水管，数据就是水管里的
水，但是只能单向流动。Input Stream就是数据从外面（磁盘、网络）流进内存，
Output Stream就是数据从内存流到外面去。对于浏览网页来说，浏览器和新浪服务器之间至少
需要建立两根水管，才可以既能发数据，又能收数据。

由于CPU和内存的速度远远高于外设的速度，所以，在IO编程中，就存在速度严重不匹配的问题。
举个例子来说，比如要把100M的数据写入磁盘，CPU输出100M的数据只需要0.01秒，可是磁盘要
接收这100M数据可能需要10秒，怎么办呢？有两种办法：

第一种是CPU等着，也就是程序暂停执行后续代码，等100M的数据在10秒后写入磁盘，再接着往
下执行，这种模式称为同步IO；

另一种方法是CPU不等待，只是告诉磁盘，“您老慢慢写，不着急，我接着干别的事去了”，于是
，后续代码可以立刻接着执行，这种模式称为异步IO。

同步和异步的区别就在于是否等待IO执行的结果。好比你去麦当劳点餐，你说“来个汉堡”，
服务员告诉你，对不起，汉堡要现做，需要等5分钟，于是你站在收银台前面等了5分钟，拿到汉
堡再去逛商场，这是同步IO。

你说“来个汉堡”，服务员告诉你，汉堡需要等5分钟，你可以先去逛商场，等做好了，我们再通
知你，这样你可以立刻去干别的事情（逛商场），这是异步IO。

很明显，使用异步IO来编写程序性能会远远高于同步IO，但是异步IO的缺点是编程模型复杂。
想想看，你得知道什么时候通知你“汉堡做好了”，而通知你的方法也各不相同。如果是服务员
跑过来找到你，这是回调模式，如果服务员发短信通知你，你就得不停地检查手机，这是轮询
模式。总之，异步IO的复杂度远远高于同步IO。

操作IO的能力都是由操作系统提供的，每一种编程语言都会把操作系统提供的低级C接口封装起
来方便使用，Python也不例外。我们后面会详细讨论Python的IO编程接口。

注意，本章的IO编程都是同步模式，异步IO由于复杂度太高，后续涉及到服务器端程序开发时
我们再讨论。
'''

8.2 文件读写

8.2.1 文件读操作

'''文件读写'''
'''
读写文件是最常见的IO操作。Python内置了读写文件的函数，用法和C是兼容的。

读写文件前，我们先必须了解一下，在磁盘上读写文件的功能都是由操作系统提供的，现代操作
系统不允许普通的程序直接操作磁盘，所以，读写文件就是请求操作系统打开一个文件对象
（通常称为文件描述符），然后，通过操作系统提供的接口从这个文件对象中读取数据
（读文件），或者把数据写入这个文件对象（写文件）。
读文件
要以读文件的模式打开一个文件对象，使用Python内置的open()函数，传入文件名和标示符：
'''
f = open("C:\\Users\\Administrator\\Desktop\\test\\test.txt","r")
'''
标示符'r'表示读，这样，我们就成功地打开了一个文件。

如果文件不存在，open()函数就会抛出一个IOError的错误，并且给出错误码和详细的信息告诉
你文件不存在：

>>> f=open('/Users/michael/notfound.txt', 'r')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: '/Users/michael/notfound.txt'
如果文件打开成功，接下来，调用read()方法可以一次读取文件的全部内容，Python把内容读
到内存，用一个str对象表示：
'''
print(f.read())
'''
最后一步是调用close()方法关闭文件。文件使用完毕后必须关闭，因为文件对象会占用操作
系统的资源，并且操作系统同一时间能打开的文件数量也是有限的：
'''
f.close()

'''
由于文件读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用。所以，为了
保证无论是否出错都能正确地关闭文件，我们可以使用try ... finally来实现：
'''
try:
    f = open("C:\\Users\\Administrator\\Desktop\\test\\test.txt", 'r')
    print(f.read())
finally:
    if f:
        f.close()
'''
但是每次都这么写实在太繁琐，所以，Python引入了with语句来自动帮我们调用close()方法：
'''
with open("C:\\Users\\Administrator\\Desktop\\test\\test.txt", 'r') as f:
    print(f.read())
'''
这和前面的try ... finally是一样的，但是代码更佳简洁，并且不必调用f.close()方法。

调用read()会一次性读取文件的全部内容，如果文件有10G，内存就爆了，所以，要保险起见，
可以反复调用read(size)方法，每次最多读取size个字节的内容。另外，调用readline()可以
每次读取一行内容，调用readlines()一次读取所有内容并按行返回list。因此，要根据需要
决定怎么调用。
#如果文件很小，read()一次性读取最方便；如果不能确定文件大小，反复调用read(size)比
较保险；如果是配置文件，调用readlines()最方便：
'''
with open("C:\\Users\\Administrator\\Desktop\\test\\test.txt", 'r') as f:
    for line in f.readlines():
        print(line.strip()) # 把末尾的'\n'删掉

'''
file-like Object
像open()函数返回的这种有个read()方法的对象，在Python中统称为file-like Object。
除了file外，还可以是内存的字节流，网络流，自定义流等等。file-like Object不要求从
特定类继承，只要写个read()方法就行。

StringIO就是在内存中创建的file-like Object，常用作临时缓冲。
'''

'''
二进制文件
前面讲的默认都是读取文本文件，并且是UTF-8编码的文本文件。要读取二进制文件，比如
图片、视频等等，用'rb'模式打开文件即可：
'''
#f = open('/Users/michael/test.jpg', 'rb')
#f.read()


'''
字符编码
要读取非UTF-8编码的文本文件，需要给open()函数传入encoding参数，例如，读取GBK编码的文件：

f = open('/Users/michael/gbk.txt', 'r', encoding='gbk')
f.read()
'测试'
遇到有些编码不规范的文件，你可能会遇到UnicodeDecodeError，因为在文本文件中可能夹杂
了一些非法编码的字符。遇到这种情况，open()函数还接收一个errors参数，表示如果遇到
编码错误后如何处理。最简单的方式是直接忽略：

f = open('/Users/michael/gbk.txt', 'r', encoding='gbk', errors='ignore')
'''

8.2.2 文件写操作

'''写文件'''
'''
写文件和读文件是一样的，唯一区别是调用open()函数时，传入标识符'w'或者'wb'表示写
文本文件或写二进制文件：
'''
with open("C:\\Users\\Administrator\\Desktop\\test\\test.txt", 'w') as f:
    for i in range(10):
        f.write("Hello "+ str(i) + "\n")

'''
要写入特定编码的文本文件，请给open()函数传入encoding参数，将字符串自动转换成指定编码。

细心的童鞋会发现，以'w'模式写入文件时，如果文件已存在，会直接覆盖（相当于删掉后新写
入一个文件）。如果我们希望追加到文件末尾怎么办？可以传入'a'以追加（append）模式写入。

所有模式的定义及含义可以参考Python的官方文档。
'''

'''
小结
在Python中，文件读写是通过open()函数打开的文件对象完成的。
使用with语句操作文件IO是个好习惯。
'''

9.3 StringIO和BytesIO

9.3.1 StringIO

'''
StringIO
很多时候，数据读写不一定是文件，也可以在内存中读写。

StringIO顾名思义就是在内存中读写str。

要把str写入StringIO，我们需要先创建一个StringIO，然后，像文件一样写入即可：
'''
from io import StringIO
f = StringIO()
f.write('hello')
f.write(' ')
f.write('world!')
print(f.getvalue())
'''
getvalue()方法用于获得写入后的str。

要读取StringIO，可以用一个str初始化StringIO，然后，像读文件一样读取：
'''
from io import StringIO
f = StringIO('Hello!\nHi!\nGoodbye!')
while True:
     s = f.readline()
     if s == '':
         break
     print(s.strip())

9.3.2 BytesIO

'''BytesIO'''
'''
StringIO操作的只能是str，如果要操作二进制数据，就需要使用BytesIO。

BytesIO实现了在内存中读写bytes，我们创建一个BytesIO，然后写入一些bytes：
'''
from io import BytesIO
f = BytesIO()
f.write('中文'.encode('utf-8'))
print(f.getvalue())
'''
请注意，写入的不是str，而是经过UTF-8编码的bytes。

和StringIO类似，可以用一个bytes初始化BytesIO，然后，像读文件一样读取：
'''
from io import BytesIO
f = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
f.read()
'''
小结
StringIO和BytesIO是在内存中操作str和bytes的方法，使得和读写文件具有一致的接口。
'''

9.4 序列化

9.4.1 使用pickle写入和读取文件

"""
序列化
阅读: 2282060
在程序运行的过程中，所有的变量都是在内存中，比如，定义一个dict：

d = dict(name='Bob', age=20, score=88)
可以随时修改变量，比如把name改成'Bill'，但是一旦程序结束，变量所占用的内存就被操作
系统全部回收。如果没有把修改后的'Bill'存储到磁盘上，下次重新运行程序，变量又被初始
化为'Bob'。
我们把变量从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他
语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。
序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。
反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。
Python提供了pickle模块来实现序列化。
首先，我们尝试把一个对象序列化并写入文件：
"""

import pickle
#序列化
f = open("C:\\Users\\Administrator\\Desktop\\test\\test.txt", 'wb')
d = {"name":"Bob", "age":20}
print(pickle.dumps(d))
# pickle.dumps()方法把任意对象序列化成一个bytes，然后，就可以把这个bytes写入文件。
# 或者用另一个方法pickle.dump()直接把对象序列化后写入一个file-like Object：
pickle.dump(d,f)
f.close()

"""
看看写入的dump.txt文件，一堆乱七八糟的内容，这些都是Python保存的对象内部信息。

当我们要把对象从磁盘读到内存时，可以先把内容读到一个bytes，然后用pickle.loads()
方法反序列化出对象，也可以直接用pickle.load()方法从一个file-like Object中直接
反序列化出对象。我们打开另一个Python命令行来反序列化刚才保存的对象：
"""
# 反序列化
f = open("C:\\Users\\Administrator\\Desktop\\test\\test.txt", 'rb')
d = pickle.load(f)
print(d)
f.close()
# {'name': 'Bob', 'age': 20}
"""
变量的内容又回来了！

当然，这个变量和原来的变量是完全不相干的对象，它们只是内容相同而已。

Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能
不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功
地反序列化也没关系。
"""

9.4.2 使用JSON写入和读取文件

"""
JSON
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更
好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以
方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在
Web页面中读取，非常方便。

JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

JSON类型	        Python类型
{}	            dict
[]	            list
"string"	    str
1234.56	        int或float
true/false	    True/False
null	        None
Python内置的json模块提供了非常完善的Python对象到JSON格式的转换。我们先看看如何把
Python对象变成一个JSON：
"""
import json
d = dict(name='Bob', age=20, score=88)
with open("C:\\Users\\Administrator\\Desktop\\test\\test.json", "w") as f:
    json.dump(d,f)
"""
dumps()方法返回一个str，内容就是标准的JSON。类似的，dump()方法可以直接把JSON写
入一个file-like Object。

要把JSON反序列化为Python对象，用loads()或者对应的load()方法，前者把JSON的字符
串反序列化，后者从file-like Object中读取字符串并反序列化：
"""
import json
with open("C:\\Users\\Administrator\\Desktop\\test\\test.json", "r") as f:
    f1 = json.load(f)
    print(f1)
#输出：{'name': 'Bob', 'age': 20, 'score': 88}