学习Demo

前言

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 对象常用的函数：

1.1 文件读

函数 open() 返回 文件对象，通常的用法需要两个参数：open(filename, mode)。

• filename：filename 变量是一个包含了你要访问的文件名称的字符串值。
• mode：mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

不同模式打开文件的完全列表：

"""
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模块中，这一点要注意一下。

常用的方法如下表所示：

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内置的数据类型对应如下：

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实例对象。