前言
IO在计算机中指Input/Output，也就是输入和输出。由于程序和运行时数据是在内存中驻留，由CPU这个超快的计算核心来执行，涉及到数据交换的地方，通常是磁盘、网络等，就需要IO接口。通常，程序完成IO操作会有Input和Output两个数据流。当然也有只用一个的情况，比如，从磁盘读取文件到内存，就只有Input操作，反过来，把数据写到磁盘文件里，就只是一个Output操作。
由于CPU和内存的速度远远高于外设的速度，所以，在IO编程中，就存在速度严重不匹配的问题。举个例子来说，比如要把100M的数据写入磁盘，CPU输出100M的数据只需要0.01秒，可是磁盘要接收这100M数据可能需要10秒，怎么办呢？有两种办法：
-
第一种是CPU等着，也就是程序暂停执行后续代码，等100M的数据在10秒后写入磁盘，再接着往下执行，这种模式称为同步IO；
-
另一种方法是CPU不等待，磁盘继续写，在磁盘写数据的时候CPU干别的事去了，直到磁盘写完成，后续代码可以立刻接着执行，这种模式称为异步IO。
同步和异步的区别就在于是否等待IO执行的结果。
很明显，使用异步IO来编写程序性能会远远高于同步IO，但是异步IO的缺点是编程模型复杂。想想看，你得知道什么时候通知你磁盘写好了，而通知你的方法也各不相同，如回调模式、轮询模式。总之，异步IO的复杂度远远高于同步IO。
操作IO的能力都是由操作系统提供的，每一种编程语言都会把操作系统提供的低级C接口封装起来方便使用，Python也不例外。我们后面会详细讨论Python的IO编程接口。
注意，本章的IO编程都是同步模式，异步IO由于复杂度太高，后续涉及到服务器端程序开发时我们再讨论。
一、文件读写
file 对象常用的函数：
| 方法 | 描述 |
|---|---|
file.close() |
关闭文件。关闭后文件不能再进行读写操作。 |
file.flush() |
刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。 |
file.fileno() |
返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。 |
file.isatty() |
如果文件连接到一个终端设备返回 True，否则返回 False。 |
file.next() |
返回文件下一行。 |
file.read([size]) |
从文件读取指定的字节数，如果未给定或为负则读取所有。 |
file.readline([size]) |
读取整行，包括 "\n" 字符。 |
file.readlines([sizeint]) |
读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。 |
file.seek(offset[, whence]) |
设置文件当前位置 |
file.tell() |
返回文件当前位置。 |
file.truncate([size]) |
从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后 V 后面的所有字符被删除，其中 Widnows 系统下的换行代表2个字符大小。 |
file.write(str) |
将字符串写入文件，没有返回值。 |
file.writelines(sequence) |
向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。 |
1.1 文件读
函数 open() 返回 文件对象，通常的用法需要两个参数：open(filename, mode)。
- filename：filename 变量是一个包含了你要访问的文件名称的字符串值。
- mode：mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
不同模式打开文件的完全列表：
| 模式 | 描述 |
|---|---|
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 |
| w | 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
"""
def open(file, mode='r', buffering=None, encoding=None, errors=None,
newline=None, closefd=True):
"""
f = open('song', 'r')
print(f) # <_io.TextIOWrapper name='song' mode='r' encoding='UTF-8'>
1.1.1 文件对象的方法
-
read()
如果文件打开成功，接下来，调用read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。size是一个可选的数字类型的参数。 当size被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。 -
readline()
readline()会从文件中读取单独的一行。换行符为\n。readline()如果返回一个空字符串, 说明已经已经读取到最后一行。 -
readlines()
readlines()将返回该文件中包含的所有行。
如果设置可选参数sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。 -
close()
文件使用完毕后必须关闭，因为文件对象会占用操作系统的资源，并且操作系统同一时间能打开的文件数量也是有限的。如果尝试再调用该文件，则会抛出异常。
f1 = open('song1', 'r', encoding='gbk', errors='ignore')
print(f1.read())
"""
saaf鏄鍚﹁冭檻sk娴忚坖fdjg
fgajg
kkk
ll
"""
f = open('song1', 'r')
print(f.read())
"""
saaf是否考虑sk浏览jfdjg
fgajg
kkk
ll
"""
print(f.readline()) # saaf是否考虑sk浏览jfdjg
print(f.readlines()) # ['saaf是否考虑sk浏览jfdjg\n', 'fgajg\n', 'kkk\n', 'll\n']
print(f.readlines(25)) # ['saaf是否考虑sk浏览jfdjg\n', 'fgajg\n']
f.close()
1.1.2 健壮的文件读代码
由于文件读写时都有可能产生IOError，一旦出错，后面的close()就不会调用。所以，为了保证无论是否出错都能正确地关闭文件，我们可以使用try ... finally来实现：
try:
f = open('song1', 'r')
print(f.read())
finally:
if f:
f.close()
"""
saaf是否考虑sk浏览jfdjg
fgajg
kkk
ll
"""
但是每次都这么写实在太繁琐，所以，Python引入了with语句来自动帮我们调用close()方法：
with open('song1', 'r') as f:
print(f.read())
"""
saaf是否考虑sk浏览jfdjg
fgajg
kkk
ll
"""
这和前面的try ... finally是一样的，但是代码更佳简洁，并且不必调用close()方法。
调用read()会一次性读取文件的全部内容，如果文件有10G，内存就爆了，所以，要保险起见，可以反复调用read(size)方法，每次最多读取size个字节的内容。另外，调用readline()可以每次读取一行内容，调用readlines()一次读取所有内容并按行返回list。因此，要根据需要决定怎么调用。
如果文件很小，read()一次性读取最方便；如果不能确定文件大小，反复调用read(size)比较保险；如果是配置文件，调用readlines()最方便：
for line in f.readlines():
print(line.strip()) # 把末尾的'\n'删掉
"""
saaf是否考虑sk浏览jfdjg
fgajg
kkk
ll
"""
1.2 文件写
-
write()
write(string)将string写入到文件中, 然后返回写入的字符数。 -
tell()
返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。 -
seek()
移动文件读取指针到指定位置。offset:开始的偏移量，需要向前或向后移动的字节数,正往结束方向移动，负往开始方向移动。whence：可选参数， 给offset参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头算起(默认值)，1代表开始从当前位置开始算起，2代表从文件末尾开始算起。当有换行时，会被换行截断。
f = open('song2', 'a')
num = f.write("Python 是一个非常好的语言。\n是的，的确非常好!!\n")
print(num)
print(f.tell())
f.close()
with open('song2', 'w') as f:
f.write('Hello, world!')
二、StringIO和BytesIO
2.1 StringIO
很多时候，数据读写不一定是文件，也可以在内存中读写。
StringIO顾名思义就是在内存中读写str。要把str写入StringIO，我们需要先创建一个StringIO，然后，像文件一样写入即可
from io import StringIO
f = StringIO()
print(f.write('hello')) # 5
f.write(' ')
f.write('world!')
# getvalue()方法用于获得写入后的str。
print(f.getvalue()) # hello world!
f1 = StringIO('Hello!\nHi!\nGoodbye!')
while True:
s = f1.readline()
if s == '':
break
print(s.strip())
"""
Hello!
Hi!
Goodbye!
"""
2.2 BytesIO
StringIO操作的只能是str，如果要操作二进制数据，就需要使用BytesIO。BytesIO实现了在内存中读写bytes，我们创建一个BytesIO，然后写入一些bytes：
from io import BytesIO
f = BytesIO()
f.write('中文'.encode('utf-8')) # 3
print(f.getvalue()) # b'\xe4\xb8\xad\xe6\x96\x87'
"""
请注意，写入的不是str，而是经过UTF-8编码的bytes。和StringIO类似，可以用一个bytes初始化BytesIO，然后，像读文件一样读取：
"""
f1 = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
print(f1.read()) # b'\xe4\xb8\xad\xe6\x96\x87'
三、操作文件和目录
如果我们要操作文件、目录，可以在命令行下面输入操作系统提供的各种命令来完成。比如dir、cp等命令。
如果要在Python程序中执行这些目录和文件的操作怎么办？其实操作系统提供的命令只是简单地调用了操作系统提供的接口函数，Python内置的os模块也可以直接调用操作系统提供的接口函数。
# 操作系统类型(如果是posix，说明系统是Linux、Unix或Mac OS X，如果是nt，就是Windows系统。)
print(os.name) # posix
# 要获取详细的系统信息，可以调用uname()函数(uname()函数在Windows上不提供，也就是说，os模块的某些函数是跟操作系统相关的)
print(os.uname())
"""
posix.uname_result(sysname='Darwin', nodename='yang.local', release='17.3.0',
version='Darwin Kernel Version 17.3.0: Thu Nov 9 18:09:22 PST 2017;
root:xnu-4570.31.3~1/RELEASE_X86_64', machine='x86_64')
"""
3.1 环境变量
在操作系统中定义的环境变量，全部保存在os.environ这个变量中，可以直接查看：
print(os.environ)
"""
environ({'PATH': '/Users/yang/Desktop/Python/PythonLearning/venv/bin:/Users/yang/.rvm
/gems/ruby-2.4.1/bin:/Users/yang/.rvm/gems/ruby-2.4.1@global/bin:/Users/yang/.rvm/rubies
/ruby-...})
"""
要获取某个环境变量的值，可以调用os.environ.get('key')：
os.environ.get('PATH')
"""
/Users/yang/Desktop/Python/PythonLearning/venv/bin:/Users/yang/.rvm/gems/ruby-2.4.1/bin:/Users/yang/.rvm/gems
/ruby-2.4.1@global/bin:/Users/yang/.rvm/rubies/ruby-2.4.1/bin:/Library/Java
/JavaVirtualMachines/jdk1.8.0_131.jdk/Contents/Home/bin:/usr/local/bin:/
usr/bin:/bin:/usr/sbin:/sbin:.:/Users/yang/.rvm/bin
"""
3.2 操作文件和目录
操作文件和目录的函数一部分放在os模块中，一部分放在os.path模块中，这一点要注意一下。
常用的方法如下表所示：
| 序号 | 方法及描述 |
|---|---|
| 1 |
os.access(path, mode)检验权限模式 |
| 2 |
os.chdir(path)改变当前工作目录 |
| 3 |
os.chflags(path, flags)设置路径的标记为数字标记。 |
| 4 |
os.chmod(path, mode)更改权限 |
| 5 |
os.chown(path, uid, gid)更改文件所有者 |
| 6 |
os.chroot(path)改变当前进程的根目录 |
| 7 |
os.close(fd)关闭文件描述符 fd |
| 8 |
os.closerange(fd_low, fd_high)关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略 |
| 9 |
os.dup(fd)复制文件描述符 fd |
| 10 |
os.dup2(fd, fd2)将一个文件描述符 fd 复制到另一个 fd2 |
| 11 |
os.fchdir(fd)通过文件描述符改变当前工作目录 |
| 12 |
os.fchmod(fd, mode)改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。 |
| 13 |
os.fchown(fd, uid, gid)修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。 |
| 14 |
os.fdatasync(fd)强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。 |
| 15 |
os.fdopen(fd[, mode[, bufsize]])通过文件描述符 fd 创建一个文件对象，并返回这个文件对象 |
| 16 |
os.fpathconf(fd, name)返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。 |
| 17 |
os.fstat(fd)返回文件描述符fd的状态，像stat()。 |
| 18 |
os.fstatvfs(fd)返回包含文件描述符fd的文件的文件系统的信息，像 statvfs()
|
| 19 |
os.fsync(fd)强制将文件描述符为fd的文件写入硬盘。 |
| 20 |
os.ftruncate(fd, length)裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。 |
| 21 |
os.getcwd()返回当前工作目录 |
| 22 |
os.getcwdu()返回一个当前工作目录的Unicode对象 |
| 23 |
os.isatty(fd)如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。 |
| 24 |
os.lchflags(path, flags)设置路径的标记为数字标记，类似 chflags()，但是没有软链接 |
| 25 |
os.lchmod(path, mode)修改连接文件权限 |
| 26 |
os.lchown(path, uid, gid)更改文件所有者，类似 chown，但是不追踪链接。 |
| 27 |
os.link(src, dst)创建硬链接，名为参数 dst，指向参数 src |
| 28 |
os.listdir(path)返回path指定的文件夹包含的文件或文件夹的名字的列表。 |
| 29 |
os.lseek(fd, pos, how)设置文件描述符fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效 |
| 30 |
os.lstat(path)像stat(),但是没有软链接 |
| 31 |
os.major(device)从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。 |
| 32 |
os.makedev(major, minor)以major和minor设备号组成一个原始设备号 |
| 33 |
os.makedirs(path[, mode])递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。 |
| 34 |
os.minor(device)从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。 |
| 35 |
os.mkdir(path[, mode])以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。 |
| 36 |
os.mkfifo(path[, mode])创建命名管道，mode 为数字，默认为 0666 (八进制) |
| 37 |
os.mknod(filename[, mode=0600, device])创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。 |
| 38 |
os.open(file, flags[, mode])打开一个文件，并且设置需要的打开选项，mode参数是可选的 |
| 39 |
os.openpty()打开一个新的伪终端对。返回 pty 和 tty的文件描述符。 |
| 40 |
os.pathconf(path, name)返回相关文件的系统配置信息。 |
| 41 |
os.pipe()创建一个管道. 返回一对文件描述符(r, w) 分别为读和写 |
| 42 |
os.popen(command[, mode[, bufsize]])从一个 command 打开一个管道 |
| 43 |
os.read(fd, n)从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。 |
| 44 |
os.readlink(path)返回软链接所指向的文件 |
| 45 |
os.remove(path)删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。 |
| 46 |
os.removedirs(path)递归删除目录。 |
| 47 |
os.rename(src, dst)重命名文件或目录，从 src 到 dst
|
| 48 |
os.renames(old, new)递归地对目录进行更名，也可以对文件进行更名。 |
| 49 |
os.rmdir(path)]删除path指定的空目录，如果目录非空，则抛出一个OSError异常。 |
| 50 |
os.stat(path)获取path指定的路径的信息，功能等同于C API中的stat()系统调用。 |
| 51 |
os.stat_float_times([newvalue])决定stat_result是否以float对象显示时间戳 |
| 52 |
os.statvfs(path)获取指定路径的文件系统统计信息 |
| 53 |
os.symlink(src, dst)创建一个软链接 |
| 54 |
os.tcgetpgrp(fd)返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组 |
| 55 |
os.tcsetpgrp(fd, pg)设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。 |
| 56 |
os.tempnam([dir[, prefix]])Python3 中已删除。返回唯一的路径名用于创建临时文件。 |
| 57 |
os.tmpfile()Python3 中已删除。返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。 |
| 58 |
os.tmpnam()Python3 中已删除。为创建一个临时文件返回一个唯一的路径 |
| 59 |
os.ttyname(fd)返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。 |
| 60 |
os.unlink(path)删除文件路径 |
| 61 |
os.utime(path, times)返回指定的path文件的访问和修改的时间。 |
| 62 |
os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])输出在文件夹中的文件名通过在树中游走，向上或者向下。 |
| 63 |
os.write(fd, str)写入字符串到文件描述符 fd中. 返回实际写入的字符串长度 |
3.2.1 部分示例：
"""
把两个路径合成一个时，不要直接拼字符串，而要通过os.path.join()函数，这样可以正确处理不
同操作系统的路径分隔符。在Linux/Unix/Mac下，os.path.join()返回这样的字符串：
part-1/part-2;而Windows下会返回这样的字符串：part-1\part-2
"""
# 在某个目录下创建一个新目录，首先把新目录的完整路径表示出来:
# print(os.path.join('/Users/yang/Desktop', 'testdir')) # /Users/yang/Desktop/testdir
# 然后创建一个目录:
#print(os.mkdir('/Users/yang/Desktop/testdir')) # None
# 删掉一个目录:
# print(os.rmdir('/Users/yang/Desktop/testdir')) # None
-
os.path.split()可以把一个路径拆分为两部分，后一部分总是最后级别的目录或文件名。 -
os.path.splitext()可以直接让你得到文件扩展名。 - 复制文件的函数居然在os模块中不存在,
shutil模块提供了copyfile()的函数，你还可以在shutil模块中找到很多实用函数，它们可以看做是os模块的补充。
# 列出当前目录下的所有目录
print([x for x in os.listdir('.') if os.path.isdir(x)])
# 要列出所有的.py文件
print([x for x in os.listdir('.') if os.path.isfile(x) and os.path.splitext(x)[1]=='.py'])
"""
['LYJudgeSentence.py', 'ly_IOProgram.py', '__init__.py', 'ly_variable.py', 'LYMethod.py',
'ly_module.py', 'ly_string.py', 'ly_method.py', 'ly_judge_sentence.py', 'LYString.py',
'ly_sum.py']
"""
四、序列化
在程序运行的过程中，所有的变量都是在内存中，比如，定义一个dict：
d = dict(name='Bob', age=20, score=88)
可以随时修改变量，比如把name改成'Bill'，但是一旦程序结束，变量所占用的内存就被操作系统全部回收。如果没有把修改后的'Bill'存储到磁盘上，下次重新运行程序，变量又被初始化为'Bob'。
我们把变量从内存中变成可存储或传输的过程称之为序列化(pickling)，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。
序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。
反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化(unpickling)。
Python提供了pickle模块来实现序列化。
首先，我们尝试把一个对象序列化并写入文件：
import pickle
d = dict(name='Bob', age=20, score=88)
# print(pickle.dumps(d))
"""
b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x03\x00\x00\x00Bobq\x02X\x03\x00\x00\x00
ageq\x03K\x14X\x05\x00\x00\x00scoreq\x04KXu.'
"""
pickle.dumps()方法把任意对象序列化成一个bytes，然后，就可以把这个bytes写入文件。或者用另一个方法pickle.dump()直接把对象序列化后写入一个file-like Object：
f = open('song1.txt', 'wb')
print(pickle.dump(d, f))
f.close()
看看写入的song1.txt文件，一堆乱七八糟的内容，这些都是Python保存的对象内部信息。
当我们要把对象从磁盘读到内存时，可以先把内容读到一个bytes，然后用pickle.loads()方法反序列化出对象，也可以直接用pickle.load()方法从一个file-like Object中直接反序列化出对象。我们打开另一个Python命令行来反序列化刚才保存的对象：
f = open('song1.txt', 'rb')
d = pickle.load(f)
f.close()
print(d) # {'name': 'Bob', 'age': 20, 'score': 88}
变量的内容又回来了！
当然，这个变量和原来的变量是完全不相干的对象，它们只是内容相同而已。
Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。
4.1 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)
print(json.dumps(d)) # {"name": "Bob", "age": 20, "score": 88}
dumps()方法返回一个str，内容就是标准的JSON。类似的，dump()方法可以直接把JSON写入一个file-like Object。
要把JSON反序列化为Python对象，用loads()或者对应的load()方法，前者把JSON的字符串反序列化，后者从file-like Object中读取字符串并反序列化：
json_str = '{"age": 20, "score": 88, "name": "Bob"}'
print(json.loads(json_str)) # {'age': 20, 'score': 88, 'name': 'Bob'}
由于JSON标准规定JSON编码是UTF-8，所以我们总是能正确地在Python的str与JSON的字符串之间转换。
4.2 JSON进阶
Python的dict对象可以直接序列化为JSON的{}，不过，很多时候，我们更喜欢用class表示对象，比如定义Student类，然后序列化：
import json
class Student(object):
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
s = Student('Bob', 20, 88)
print(json.dumps(s))
运行代码，毫不留情地得到一个TypeError：
Traceback (most recent call last):
File "/Users/yang/Desktop/Python/PythonLearning/demo1/ly_IOProgram.py", line 265, in <module>
print(json.dumps(s))
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/__init__.py", line 231, in dumps
return _default_encoder.encode(obj)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/encoder.py", line 199, in encode
chunks = self.iterencode(o, _one_shot=True)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/encoder.py", line 257, in iterencode
return _iterencode(o, 0)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/encoder.py", line 180, in default
o.__class__.__name__)
TypeError: Object of type 'Student' is not JSON serializable
错误的原因是Student对象不是一个可序列化为JSON的对象。
如果连class的实例对象都无法序列化为JSON，这肯定不合理！
别急，我们仔细看看dumps()方法的参数列表，可以发现，除了第一个必须的obj参数外，dumps()方法还提供了一大堆的可选参数：
https://docs.python.org/3/library/json.html#json.dumps
这些可选参数就是让我们来定制JSON序列化。前面的代码之所以无法把Student类实例序列化为JSON，是因为默认情况下，dumps()方法不知道如何将Student实例变为一个JSON的{}对象。
可选参数default就是把任意一个对象变成一个可序列为JSON的对象，我们只需要为Student专门写一个转换函数，再把函数传进去即可：
def student2dict(std):
return {
'name': std.name,
'age': std.age,
'score': std.score
}
这样，Student实例首先被student2dict()函数转换成dict，然后再被顺利序列化为JSON：
print(json.dumps(s, default=student2dict))
{"age": 20, "name": "Bob", "score": 88}
不过，下次如果遇到一个Teacher类的实例，照样无法序列化为JSON。我们可以偷个懒，把任意class的实例变为dict：
print(json.dumps(s, default=lambda obj: obj.__dict__))
因为通常class的实例都有一个__dict__属性，它就是一个dict，用来存储实例变量。也有少数例外，比如定义了__slots__的class。
同样的道理，如果我们要把JSON反序列化为一个Student对象实例，loads()方法首先转换出一个dict对象，然后，我们传入的object_hook函数负责把dict转换为Student实例：
def dict2student(d):
return Student(d['name'], d['age'], d['score'])
>>> json_str = '{"age": 20, "score": 88, "name": "Bob"}'
>>> print(json.loads(json_str, object_hook=dict2student))
<__main__.Student object at 0x31bd2c210>
打印出的是反序列化的Student实例对象。
网友评论