IO编程

学习自廖雪峰的官方网站
IO编程
由于程序和运行时用到的数据都是常驻内存，所以这个IOinput、output指的是内存的进出，进出的地方一般是硬盘、网络、键盘、显示器等等。
Stream（流）是一个很重要的概念，单向的数据管道。
CPU和内存的速度远远高于外设的速度，所以，在IO编程中，就存在速度严重不匹配的问题。所以有同步IO和异步IO。等着IO完成就是同步IO，先去忙别的就是一部IO。
使用异步IO来编写程序性能会远远高于同步IO，但是异步IO的缺点是编程模型复杂。
基本概念：input， output，stream
存在问题：输入和接收速度不匹配
解决方法：同步、异步(回调–好了叫我，轮询—好了没…好了没)
收获新知：编程语言都会把操作系统提供的低级C接口封装起来方便使用。
文件读写
读写文件前，我们先必须了解一下，在磁盘上读写文件的功能都是由操作系统提供的，现代操作系统不允许普通的程序直接操作磁盘，所以，读写文件就是请求操作系统打开一个文件对象（通常称为文件描述符），然后，通过操作系统提供的接口从这个文件对象中读取数据（读文件），或者把数据写入这个文件对象（写文件）。
我在当前目录下建立了一个test.txt

f = open('test.txt', 'r')
a=f.read()
print(a)
f.close()

标识符r表示只读，这个是默认的，如果不写参数，默认就是只读，w表示写入权限。


总结一下：
默认为文本模式，若想读写二进制文件要加b。
开头必须是r只读，w只是写入，a只是追加。
使用r和w指针在文件开头，使用a指针在文件末尾。
加了+以后，r可以写了，w和a可以读了。
使用w和a的话，如果文件不存在会创建。
读文件时，若文件不存在，opem（）函数会抛出IOError。
若打开成功，用read（）方法可以一次性读取文件全部内容，全放到内存里。
读取的内容是一个str类型，若是加了b，则读取的是二进制类型bytes
操作完以后一定要用f.close()关闭文件，因为会占用资源。
若是读取或者写入出错，就不会执行到f.close()，所以用try ... finally来实现。

try:
    f = open('/path/to/file', 'r')
    print(f.read())
finally:
    if f:
        f.close()

但是每次都这么写实在太繁琐，所以，Python引入了with语句来自动帮我们调用close()方法：

with open('/path/to/file', 'r') as f:
    print(f.read())

使用read()会一次性读取整个文件内容，返回的是str类型，若文件太大，可以用read(size)，一次性读取size个字节的内容。
使用readline()每次读取一行内容，返回的也是str类型，想要多行就要循环读取。这个函数不读取’\n‘。
使用readlines()一次性读取所有内容并按行返回，返回值是个list，读取带\n，若要去掉用str.strip()
file-like Object
像open()函数返回的这种有个read()方法的对象，在Python中统称为file-like Object。除了file外，还可以是内存的字节流，网络流，自定义流等等。file-like Object不要求从特定类继承，只要写个read()方法就行。

StringIO就是在内存中创建的file-like Object，常用作临时缓冲。
默认读取的是UTF-8编码的文本文件。想要读取别的编码的文件，可以指定encoding参数，还可以指定遇到编码错误如何处理：

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

写文件
跟读一样，只是使用f.write()来写，一样可以指定编码，可以指定用w，w+，a，a+，可以用with来保证文件关闭。
StringIO
StringIO顾名思义就是在内存中读写str。
要把str写入StringIO，我们需要先创建一个StringIO，然后，像文件一样写入即可：

from io import StringIO
f=StringIO()
f.write('hello ')
f.write('world')
print(f.getvalue())#读取stringIO里面的内容
f.seek(2)#指针移动到2的位置
print(f.tell())#告诉你指针现在的位置
print(f.readline())

结果：

hello world
2
llo world

也可以直接初始化StringIO

 f = StringIO('Hello!\nHi!\nGoodbye!')

BytesIO就是操作二进制数据的了。

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

操作文件和目录
Python内置的os模块也可以直接调用操作系统提供的接口函数。

import os
print(os.name)#若为nt，是win系统，若是posix，是Linux，Unix，或Mac OS X系统
print(os.uname())#系统详细信息，win上不提供这个函数。

操作系统中定义的环境变量，全部存在os.environ这个变量中。
要想查看某个环境变量的值，使用os.environ.get('key')来得到环境变量key的值。

注意：操作文件和目录的函数一部分放在os模块中，一部分放在os.path模块中。查看、创建和删除目录可以这么调用：

os.path.abspath('.')
os.path.join('/Users/michael', 'testdir')
os.mkdir('/Users/michael/testdir')
os.rmdir('/Users/michael/testdir')
os.path.split('/Users/michael/testdir/file.txt')
os.path.splitext('/path/to/file.txt')

分别是：
当前目录的绝对路径，拼接路径，创建目录，删除目录，拆分目录一：把前面和最后一个（目录名或者文件名）分开；拆分目录二：把前面的部分和文件拓展名拆分开。
注意：这些合并、拆分路径的函数并不要求目录和文件要真实存在，它们只对字符串进行操作。
对目录来说，创建和删除用os，显示、拼接、拆分用os.path
对文件来说：

os.rename('test.txt', 'test.py')#前面也可写绝对路径
os.remove('test.py')

使用os.listdir()可以列出输入路径下的所有目录和文件，返回的是一个list。使用os.path.isdir()可以看输入的是不是存在的目录，用os.path.isfile()判断对象是不是一个文件。
列出当前路径下的所有的目录，不要文件：

>>> [x for x in os.listdir('.') if os.path.isdir(x)]

列出当前目录下的所有.py文件：

[x for x in os.listdir('.') if os.path.isfile(x) and os.path.splitext(x)[1]=='.py']

注意：所有对路径和文件的操作，参数通通都是字符串，要加引号才行。
序列化
把变量从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等。把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。Python提供了pickle模块来实现序列化。

import pickle
d = dict(name='Bob', age=20, score=88)
f=open('dump.txt','wb')
pickle.dumps(d)
pickle.dump(d,f)
f.close()
g=open('dump.txt','rb')
a=pickle.load(g)
g.close()
print(a)
#结果：
{'name': 'Bob', 'age': 20, 'score': 88}

Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。
JSON
在编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取。
JSON和Python内置的数据类型对应如下：（前面是JSON，后面是python）
{}对应dict；[]对应list；“string”对应str；数字对应int/float；
true/false对应True/False；null对应None。
JSON标准规定JSON编码是UTF-8。

dump是将对象序列化并保存到文件中
dumps是将对象序列化
load将序列化字符串从文件读取并反序列化
loads将序列化字符串反序列化

import json

q = {'a': '11', 'b': 'ok'}
w = json.dumps(q)
print(q)
print(w)

print(type(q))
print(type(w))

结果：

{'a': '11', 'b': 'ok'}
{"a": "11", "b": "ok"}
<class 'dict'>
<class 'str'>

理解起来就是：带s的json.dumps()和json.loads()就是序列化，在这简单理解为dumps把python格式的数据转化为字符串，loads就是反过来，把字符串格式转换为python格式。转换为字符串就可以正常写入文件读取文件等等（这只是可以这样做，并不是说序列化是为了写入文件读取文件啥的）。
返回值：dumps()返回的是一个str，内容是标准的JSON，以上这两个函数都可以操作file-like Object。
不加s就很好理解了，就是可以写入文件或者从文件读取。
JSON进阶
上面是有对应关系的数据类型相互转换，但是python中的类对象就不能直接转为json格式。
所以就是自己编写函数使python格式转换为dict等可以转换为json格式的格式种类。然后把这个函数传进去；反过来也是一样，可以返回一个类对象。

import json

class Student(object):
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

def dict2student(d):
    return Student(d['name'], d['age'], d['score'])

s = Student('Bob', 20, 88)
a=json.dumps(s, default=lambda obj: obj.__dict__)

print(a)
b=json.loads(a, object_hook=dict2student)
print(b)

结果：

{"name": "Bob", "age": 20, "score": 88}
<__main__.Student object at 0x000001E8A53AC2C8>