Python之IO编程——文件读写、StringIO/BytesIO、操作文件和目录、序列化

IO编程

    IO在计算机中指Input/Output，也就是输入和输出。由于程序和运行时数据是在内存中驻留，由CPU这个超快的计算核心来执行，涉及到数据交换的地方，通常是磁盘、网络等，就需要IO接口。从磁盘读取文件到内存，就只有Input操作，反过来，把数据写到磁盘文件里，就只是一个Output操作。    由于CPU和内存的速度远远高于外设的速度，所以，在IO编程中，就存在速度严重不匹配的问题。举个例子来说，比如要把100M的数据写入磁盘，CPU输出100M的数据只需要0.01秒，可是磁盘要接收这100M数据可能需要10秒，怎么办呢？有两种办法：
    第一种是CPU等着，也就是程序暂停执行后续代码，等100M的数据在10秒后写入磁盘，再接着往下执行，这种模式称为同步IO；
    另一种方法是CPU不等待，只是告诉磁盘，“您老慢慢写，不着急，我接着干别的事去了”，于是，后续代码可以立刻接着执行，这种模式称为异步IO。    同步和异步的区别就在于是否等待IO执行的结果。异步IO来编写程序性能会远远高于同步IO，但是异步IO的缺点是编程模型复杂

一、文件读写

    读写文件是最常见的IO操作。Python内置了读写文件的函数，用法和C是兼容的。读写文件就是请求操作系统打开一个文件对象（通常称为文件描述符），然后，通过操作系统提供的接口从这个文件对象中读取数据（读文件），或者把数据写入这个文件对象（写文件）。

    1.从文件中读取数据        

         1.1读取整个文件

    要读取文件，需要一个包含几行文本的文件。下面首先来创建一个文件pi_digits.txt，它包含精确到小数点后30位的圆周率值，且在小数点后每10位处都换行：

#pi_digits.txt
3.1415926535
8979323846
2643383279

with open('pi_digits.txt') as file_object:
contents = file_object.read()
print(contents)

    函数open() 接受一个参数：要打开的文件的名称。Python在当前执行的文件所在的目录中查找指定的文件，函数open() 返回一个表示文件的对象。在这里，open('pi_digits.txt') 返回一个表示文件pi_digits.txt 的对象；Python将这个对象存储在我们将在后面使用的变量中。
    关键字with 在不再需要访问文件后将其关闭。
    PS:在这个程序中，注意到我们调用了open() ，但没有调用close() ；调用open() 和close() 来打开和关闭文件，如果程序存在bug，导致close() 语句未执行，文件将不会关闭。未妥善地关闭文件可能会导致数据丢失或受损。如果在程序中过早地调用close() ，需要使用文件时它已关闭（无法访问），会导致更多的错误。通过使用前面所示的结构，可让Python去确定：你只管打开文件，并在需要时使用它，Python自会在合适的时候自动将其关闭。
    函数read() 读取这个文件的全部内容，并将其作为一个长长的字符串存储在变量contents中。这样，通过打印contents 的值，就可将这个文本文件的全部内容显示出来。相比于原始文件，该输出不同的地方是末尾多了一个空行。read() 到达文件末尾时返回一个空字符串，而将这个空字符串显示出来时就是一个空行。要删除多出来的空行，可在print 语句中使用rstrip() ：with open('pi_digits.txt') as file_object:
contents = file_object.read()
print(contents.rstrip())    

    调用

read()

会一次性读取文件的全部内容，如果文件有10G，内存就爆了，所以，要保险起见，可以反复调用

read(size)

方法，每次最多读取size个字节的内容。另外，调用

readline()

可以每次读取一行内容，调用

readlines()

一次读取所有内容并按行返回

list

。因此，要根据需要决定怎么调用。
    如果文件很小，

read()

一次性读取最方便；如果不能确定文件大小，反复调用

read(size)

比较保险；如果是配置文件，调用

readlines()

最方便：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()
b'\xff\xd8\xff\xe1\x00\x18Exif\x00\x00...' # 十六进制表示的字节

    字符编码：要读取非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')

    1.2文件路径

    程序文件存储在文件夹python_work中，而在文件夹python_work中，有一个名为text_files的文件夹，用于存储程序文件操作的文本文件。使用相对文件路径来打开该文件夹中的文件。相对文件路径让Python到指定的位置去查找，而该位置是相对于当前运行的程序所在目录的。在Linux和OS X中，你可以这样编写代码：

with open('text_files/filename.txt') as file_object:

    在Windows系统中，在文件路径中使用反斜杠（\ ）而不是斜杠（/ ）：

with open('text_files\filename.txt') as file_object:

    在相对文件路径行不通时，可使用绝对文件路径，绝对路径通常比相对路径更长，因此将其存储在一个变量中，再将该变量传递给open() 会有所帮助。在Linux和OS X中，绝对路径类似于下面这样：file_path = '/home/ehmatthes/other_files/text_files/filename.txt'
with open(file_path) as file_object:    在Windows系统中，它们类似于下面这样：file_path = 'C:\Users\ehmatthes\other_files\text_files\filename.txt'
with open(file_path) as file_object:    通过使用绝对路径，可读取系统任何地方的文件。就目前而言，最简单的做法是，要么将数据文件存储在程序文件所在的目录，要么将其存储在程序文件所在目录下的一个文件夹（如text_files）中。

        1.3逐行读取

    读取文件时，常常需要检查其中的每一行：你可能要在文件中查找特定的信息，或者要以某种方式修改文件中的文本。    例如，你可能要遍历一个包含天气数据的文件，并使用天气描述中包含字样sunny的行。在新闻报道中，你可能会查找包含标签<headline> 的行，并按特定的格式设置它。要以每次一行的方式检查文件，可对文件对象使用for 循环：

❶ filename = 'pi_digits.txt'

❷ with open(filename) as file_object:
❸     for line in file_object:
    print(line)

    在这个文件中，每行的末尾都有一个看不见的换行符，而print 语句也会加上一个换行符，因此每行末尾都有两个换行符：一个来自文件，另一个来自print 语句。3.1415926535

8979323846

2643383279    要消除这些多余的空白行，可在print 语句中使用rstrip() ：filename = 'pi_digits.txt'

with open(filename) as file_object:
    for line in file_object:
        print(line.rstrip())

        1.4创建一个包含文件各行内容的列表

      使用关键字with 时，open() 返回的文件对象只在with 代码块内可用。如果要在with 代码块外访问文件的内容，可在with 代码块内将文件的各行存储在一个列表中，并在with 代码块外使用该列表：你可以立即处理文件的各个部分，也可推迟到程序后面再处理。

filename = 'pi_digits.txt'
with open(filename) as file_object:
lines = file_object.readlines()

for line in lines:
print(line.rstrip())

        1.5使用文件内容

        将文件读取到内存中后，就可以以任何方式使用这些数据了。下面以简单的方式使用圆周率的值。首先，我们将创建一个字符串，它包含文件中存储的所有数字，且没有任何空格：

filename = 'pi_digits.txt'

with open(filename) as file_object:
lines = file_object.readlines()

pi_string = ''
for line in lines:
    pi_string += line.strip()  #变量pi_string存储的字符串中，包含原来位于每行左边的空格，为删除这些空格，可使用strip()

print(pi_string)
print(len(pi_string))

注意
 　读取文本文件时，Python将其中的所有文本都解读为字符串。如果你读取的是数字，并要将其作为数值使用，就必须使用函数int() 将其转换为整数，或使用函数float() 将其转换为浮点数。

        1.6包含一百万位的大型文件

    对于你可处理的数据量，Python没有任何限制；只要系统的内存足够多，你想处理多少数据都可以。包含精确到小数点后1 000 000位，打印前52位，判断是否包含你的生日。

filename = 'pi_million_digits.txt'

with open(filename) as file_object:
lines = file_object.readlines()

pi_string = ''
for line in lines:
pi_string += line.strip()

print(pi_string[:52] + "...")
print(len(pi_string))

birthday = input("Enter your birthday, in the form mmddyy: ")
if birthday in pi_string:
    print("Your birthday appears in the first million digits of pi!")
else:
    print("Your birthday does not appear in the first million digits of pi.")

    2.写入文件

    保存数据的最简单的方式之一是将其写入到文件中

        2.1写入空文件

    要将文本写入文件，你在调用open() 时需要提供另一个实参，告诉Python你要写入打开的文件。传入标识符

'w'

或者

'wb'

表示写文本文件或写二进制文件：

filename = 'programming.txt'

with open(filename, 'w') as file_object:
file_object.write("I love programming.\n")
file_object.write("I love creating new games.")#像显示到终端的输出一样，还可以使用空格、制表符和空行来设置这些输出的格式。

    第一个实参也是要打开的文件的名称；第二个实参（'w' ）告诉Python，我们要以写入模式 打开这个文件。打开文件时，可指定读取模式 （'r' ）、写入模式 （'w' ）、附加模式 （'a' ）或让你能够读取和写入文件的模式（'r+' ）。如果省略了模式实参，Python将以默认的只读模式打开文件。
    如果要写入的文件不存在，函数open() 将自动创建它。然而，以写入（'w' ）模式打开文件时，如果指定的文件已经存在，Python将在返回文件对象前清空该文件。    注意: 　Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先使用函数str() 将其转换为字符串格式

        2.2附加到文件

    如果你要给文件添加内容，而不是覆盖原有的内容，可以附加模式 打开文件。你以附加模式打开文件时，Python不会在返回文件对象前清空文件，而你写入到文件的行都将添加到文件末尾。如果指定的文件不存在，Python将为你创建一个空文件。

filename = 'programming.txt'

with open(filename, 'a') as file_object:
file_object.write("I also love finding meaning in large datasets.\n")
file_object.write("I love creating apps that can run in a browser.\n")

二、StringIO和BytesIO

StringIO    很多时候，数据读写不一定是文件，也可以在内存中读写。StringIO顾名思义就是在内存中读写str。要把str写入StringIO，我们需要先创建一个StringIO，然后，像文件一样写入即可：>>> from io import StringIO
>>> f = StringIO()
>>> f.write('hello')
5
>>> f.write(' ')
1
>>> f.write('world!')
6
>>> print(f.getvalue())
hello world!

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())
...
Hello!
Hi!
Goodbye!BytesIO
    StringIO操作的只能是str，如果要操作二进制数据，就需要使用BytesIO。BytesIO实现了在内存中读写bytes，我们创建一个BytesIO，然后写入一些bytes： 写入的不是str，而是经过UTF-8编码的bytes。>>> from io import BytesIO
>>> f = BytesIO()
>>> f.write('中文'.encode('utf-8'))
6
>>> print(f.getvalue())
b'\xe4\xb8\xad\xe6\x96\x87'和StringIO类似，可以用一个bytes初始化BytesIO，然后，像读文件一样读取：

>>> from io import BytesIO
>>> f = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
>>> f.read()
b'\xe4\xb8\xad\xe6\x96\x87'

小结：StringIO和BytesIO是在内存中操作str和bytes的方法，使得和读写文件具有一致的接口。三、操作文件和目录
    操作文件和目录的函数一部分放在

os

模块中，一部分放在

os.path

模块中，这一点要注意一下。查看、创建和删除目录可以这么调用：# 查看当前目录的绝对路径:
>>> os.path.abspath('.')
'/Users/michael'
# 在某个目录下创建一个新目录，首先把新目录的完整路径表示出来:
>>> os.path.join('/Users/michael', 'testdir')
'/Users/michael/testdir'
# 然后创建一个目录:
>>> os.mkdir('/Users/michael/testdir')
# 删掉一个目录:
>>> os.rmdir('/Users/michael/testdir')    把两个路径合成一个时，不要直接拼字符串，而要通过

os.path.join()

函数，这样可以正确处理不同操作系统的路径分隔符。在Linux/Unix/Mac下，

os.path.join()

返回这样的字符串：

part-1/part-2

    Windows下会返回这样的字符串：

part-1\part-2

    同样的道理，要拆分路径时，也不要直接去拆字符串，而要通过

os.path.split()

函数，这样可以把一个路径拆分为两部分，后一部分总是最后级别的目录或文件名：

>>> os.path.split('/Users/michael/testdir/file.txt')
('/Users/michael/testdir', 'file.txt')

os.path.splitext()

可以直接让你得到文件扩展名，很多时候非常方便：

>>> os.path.splitext('/path/to/file.txt')
('/path/to/file', '.txt')

    这些合并、拆分路径的函数并不要求目录和文件要真实存在，它们只对字符串进行操作。文件操作使用下面的函数。假定当前目录下有一个

test.txt

文件：# 对文件重命名:
>>> os.rename('test.txt', 'test.py')
# 删掉文件:
>>> os.remove('test.py')    复制文件的函数在

os

模块中不存在！原因是复制文件并非由操作系统提供的系统调用。但是

shutil

模块提供了

copyfile()

的函数，你还可以在

shutil

模块中找到很多实用函数，它们可以看做是

os

模块的补充。
    利用Python的特性来过滤文件，列出当前目录下的所有目录，只需要一行代码：

>>> [x for x in os.listdir('.') if os.path.isdir(x)]
['.lein', '.local', '.m2', '.npm', '.ssh', '.Trash', '.vim', 'Applications', 'Desktop', ...]

    列出所有的

.py

文件，也只需一行代码：

>>> [x for x in os.listdir('.') if os.path.isfile(x) and os.path.splitext(x)[1]=='.py']
['apis.py', 'config.py', 'models.py', 'pymonitor.py', 'test_db.py', 'urls.py', 'wsgiapp.py']

四、序列化    变量从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。Python提供了

pickle

模块来实现序列化。
把一个对象序列化并写入文件：
>>> import pickle
>>> d = dict(name='Bob', age=20, score=88)
>>> pickle.dumps(d)
b'\x80\x03}q\x00(X\x03\x00\x00\x00ageq\x01K\x14X\x05\x00\x00\x00scoreq\x02KXX\x04\x00\x00\x00nameq\x03X\x03\x00\x00\x00Bobq\x04u.'

>>> f = open('dump.txt', 'wb')
>>> pickle.dump(d, f)
>>> f.close()

    把对象从磁盘读到内存时，可以先把内容读到一个

bytes

，然后用

pickle.loads()

方法反序列化出对象

>>> f = open('dump.txt', 'rb')
>>> d = pickle.load(f)
>>> f.close()
>>> d
{'age': 20, 'score': 88, 'name': 'Bob'}

  1、JSON

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

json

模块提供了非常完善的Python对象到JSON格式的转换
    JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

JSON	Python
{}	dict
[]	list
"string"	str
1234.56	int或float
true/false	True/False
null	None

    1.1使用模块json 来存储数据    

    1.1.1使用json.dump() 和json.load()

    Python内置的

json

模块提供了非常完善的Python对象到JSON格式的转换。我们先看看如何把Python对象变成一个JSON，

>>> import json
>>> d = dict(name='Bob', age=20, score=88)
>>> json.dumps(d)
'{"age": 20, "score": 88, "name": "Bob"}' #dumps()方法返回一个str，内容就是标准的JSON

    函数json.dump() 接受两个实参：要存储的数据以及可用于存储数据的文件对象。下面演示了如何使用json.dump() 来存储数字列表：

import json
numbers = [2, 3, 5, 7, 11, 13]
filename = 'numbers.json'
with open(filename, 'w') as f_obj:
json.dump(numbers, f_obj)

    这个程序没有输出，但我们可以打开文件numbers.json，看看其内容。数据的存储格式与Python中一样。
     对中文进行JSON序列化时，

json.dumps()

提供了一个

ensure_ascii

参数

import json
obj = dict(name='小明', age=20)
s = json.dumps(obj, ensure_ascii=False)
print(s)

     要把JSON反序列化为Python对象，用loads()或者对应的load()方法，前者把JSON的字符串反序列化，后者从file-like Object中读取字符串并反序列化：

>>> json_str = '{"age": 20, "score": 88, "name": "Bob"}'
>>> json.loads(json_str)
{'age': 20, 'score': 88, 'name': 'Bob'}

   使用json.load() 将这个列表读取到内存中：

import json

filename = 'numbers.json'
with open(filename) as f_obj:
numbers = json.load(f_obj)

print(numbers)

    1.2保存和读取用户生成的数据

    对于用户生成的数据，使用json 保存它们大有裨益，因为如果不以某种方式进行存储，等程序停止运行时用户的信息将丢失。    程序运行时，我们将尝试从文件username.json中获取用户名，因此我们首先编写一个尝试恢复用户名的try 代码块。如果这个文件不存在，我们就在except 代码块中提示用户输入用户名，并将其存储在username.json中，以便程序再次运行时能够获取它：

import json

# 如果以前存储了用户名，就加载它
#  否则，就提示用户输入用户名并存储它
filename = 'username.json'
try:
❶     with open(filename) as f_obj:    #尝试打开文件username.json。如果这个文件存在，就将其中的用户名读取到内存中（见❷）
❷         username = json.load(f_obj)
❸ except FileNotFoundError: #用户首次运行这个程序时，文件username.json不存在，将引发FileNotFoundError 异常
❹     username = input("What is your name? ")
❺     with open(filename, 'w') as f_obj:
json.dump(username, f_obj)
print("We'll remember you when you come back, " + username + "!")
else:
print("Welcome back, " + username + "!")

    无论执行的是except 代码块还是else 代码块，都将显示用户名和合适的问候语。如果这个程序是首次运行，输出将如下：

What is your name? Eric
We'll remember you when you come back, Eric!

否则，输出将如下：

Welcome back, Eric!

    

    1.3重构

    你经常会遇到这样的情况：代码能够正确地运行，但可做进一步的改进——将代码划分为一系列完成具体工作的函数。这样的过程被称为重构 。重构让代码更清晰、更易于理解、更容易扩展。

    要重构1.2代码，可将其大部分逻辑放到一个或多个函数中。1.2代码的重点是问候用户，因此我们将其所有代码都放到一个名为greet_user() 的函数中：

import json

def greet_user():
❶     """问候用户，并指出其名字"""
filename = 'username.json'
try:
with open(filename) as f_obj:
username = json.load(f_obj)
except FileNotFoundError:
username = input("What is your name? ")
with open(filename, 'w') as f_obj:
json.dump(username, f_obj)
print("We'll remember you when you come back, " + username + "!")
      else:
          print("Welcome back, " + username + "!")

greet_user()

这个程序更清晰些，但函数greet_user() 所做的不仅仅是问候用户，还在存储了用户名时获取它，而在没有存储用户名时提示用户输入一个。
下面来重构greet_user() ，让它不执行这么多任务。为此，我们首先将获取存储的用户名的代码移到另一个函数中：

import json

def get_stored_username():
❶     """如果存储了用户名，就获取它"""
filename = 'username.json'
try:
with open(filename) as f_obj:
username = json.load(f_obj)
except FileNotFoundError:
❷         return None
else:
return username

def greet_user():
"""问候用户，并指出其名字"""
username = get_stored_username()
❸     if username:
          print("Welcome back, " + username + "!")
else:
username = input("What is your name? ")
filename = 'username.json'
with open(filename, 'w') as f_obj:
json.dump(username, f_obj)
print("We'll remember you when you come back, " + username + "!")

greet_user()

    新增的函数get_stored_username() 目标明确，❶处的文档字符串指出了这一点。如果存储了用户名，这个函数就获取并返回它；如果文件username.json不存在，这个函数就返回None （见❷）。这是一种不错的做法：函数要么返回预期的值，要么返回None ；这让我们能够使用函数的返回值做简单测试。在❸处，如果成功地获取了用户名，就打印一条欢迎用户回来的消息，否则就提示用户输入用户名。

    我们还需将greet_user() 中的另一个代码块提取出来：将没有存储用户名时提示用户输入的代码放在一个独立的函数中：

import json

def get_stored_username():
"""如果存储了用户名，就获取它"""
--snip--

def get_new_username():
"""提示用户输入用户名"""
    username = input("What is your name? ")
filename = 'username.json'
with open(filename, 'w') as f_obj:
json.dump(username, f_obj)
return username

def greet_user():
"""问候用户，并指出其名字"""
username = get_stored_username()
if username:
print("Welcome back, " + username + "!")
else:
username = get_new_username()
print("We'll remember you when you come back, " + username + "!")

greet_user()

这个最终版本中，每个函数都执行单一而清晰的任务。我们调用greet_user() ，它打印一条合适的消息：要么欢迎老用户回来，要么问候新用户。为此，它首先调用get_stored_username() ，这个函数只负责获取存储的用户名（如果存储了的话），再在必要时调用get_new_username() ，这个函数只负责获取并存储新用户的用户名。要编写出清晰而易于维护和扩展的代码，这种划分工作必不可少。