type
status
date
slug
summary
tags
category
icon
password
Property
IO
在计算机中指Input/Output
,也就是输入和输出。由于程序和运行时数据是在内存中驻留,由CPU这个超快的计算核心来执行,涉及到数据交换的地方,通常是磁盘、网络等,就需要IO接口。通常,程序完成
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
执行的结果。使用异步IO
来编写程序性能会远远高于同步IO
,但是异步IO
的缺点是编程模型复杂。文件读写
读写文件是最常见的
IO
操作。Python
内置了读写文件的函数,用法和C是兼容的。在磁盘上读写文件的功能都是由操作系统提供的,现代操作系统不允许普通的程序直接操作磁盘,所以,读写文件就是请求操作系统打开一个文件对象(通常称为文件描述符),然后,通过操作系统提供的接口从这个文件对象中读取数据(读文件),或者把数据写入这个文件对象(写文件)。
读文件
要以读文件的模式打开一个文件对象,使用
Python
内置的open()
函数,传入文件名和标示符:如果文件不存在,
open()
函数就会抛出一个IOError
的错误,并且给出错误码和详细的信息告诉你文件不存在如果文件打开成功,接下来,调用
read()
方法可以一次读取文件的全部内容,Python
把内容读到内存,用一个str
对象表示:最后一步是调用
close()
方法关闭文件。文件使用完毕后必须关闭,因为文件对象会占用操作系统的资源,并且操作系统同一时间能打开的文件数量也是有限的:由于文件读写时都有可能产生
IOError
,一旦出错,后面的f.close()
就不会调用。所以,为了保证无论是否出错都能正确地关闭文件,可以使用try ... finally
来实现:每次都这么写实在太繁琐,所以,
Python
引入了with
语句来自动帮调用close()
方法:这和前面的
try ... finally
是一样的,但是代码更佳简洁,并且不必调用f.close()
方法。调用
read()
会一次性读取文件的全部内容,如果文件有10G,内存就爆了,所以,要保险起见,可以反复调用read(size)
方法,每次最多读取size
个字节的内容。另外,调用readline()
可以每次读取一行内容,调用readlines()
一次读取所有内容并按行返回list
。因此,要根据需要决定怎么调用。如果文件很小,
read()
一次性读取最方便;如果不能确定文件大小,反复调用read(size)
比较保险;如果是配置文件,调用readlines()
最方便:file-like Object
像
open()
函数返回的这种有个read()
方法的对象,在Python
中统称为file-like Object
。除了file
外,还可以是内存的字节流,网络流,自定义流等等。file-like Object
不要求从特定类继承,只要写个read()
方法就行。StringIO
就是在内存中创建的file-like Object
,常用作临时缓冲。二进制文件
前面默认都是读取UTF-8编码的文本文件;要读取二进制文件,比如图片、视频等等,用
'rb'
模式打开文件即可:字符编码
要读取非
UTF-8
编码的文本文件,需要给open()
函数传入encoding
参数,例如,读取GBK
编码的文件:遇到有些编码不规范的文件,可能会遇到
UnicodeDecodeError
,因为在文本文件中可能夹杂了一些非法编码的字符。遇到这种情况,open()
函数还接收一个errors
参数,表示如果遇到编码错误后如何处理。最简单的方式是直接忽略:写文件
写文件和读文件是一样的,唯一区别是调用
open()
函数时,传入标识符'w'
或者'wb'
表示写文本文件或写二进制文件:可以反复调用
write()
来写入文件,但是务必要调用f.close()
来关闭文件。写文件时,操作系统往往不会立刻把数据写入磁盘,而是放到内存缓存起来,空闲的时候再慢慢写入。只有调用
close()
方法时,操作系统才保证把没有写入的数据全部写入磁盘。忘记调用close()
的后果是数据可能只写了一部分到磁盘,剩下的丢失了。所以,还是用with
语句来得保险:要写入特定编码的文本文件,请给
open()
函数传入encoding
参数,将字符串自动转换成指定编码。以
'w'
模式写入文件时,如果文件已存在,会直接覆盖(相当于删掉后新写入一个文件),如果希望追加到文件末尾可以传入'a'
以追加(append)模式写入StringIO
很多时候,数据读写不一定是文件,也可以在内存中读写,
StringIO
就是在内存中读写str
。要把str
写入StringIO
,需要先创建一个StringIO
,然后像文件一样写入即可:getvalue()
方法用于获得写入后的str
,要读取StringIO
,可以用一个str
初始化StringIO
,然后像读文件一样读取:BytesIO
StringIO
操作的只能是str
,如果要操作二进制数据,就需要使用BytesIO
。BytesIO
实现了在内存中读写bytes
,创建一个BytesIO
,然后写入一些bytes
:写入的不是
str
,而是经过UTF-8
编码的bytes
。和
StringIO
类似,可以用一个bytes
初始化BytesIO
,然后像读文件一样读取:操作文件和目录
如果要操作文件、目录,可以在命令行下面输入操作系统提供的各种命令来完成。比如
dir
、cp
等命令。如果要在
Python
程序中执行这些目录和文件的操作怎么办?其实操作系统提供的命令只是简单地调用了操作系统提供的接口函数,Python
内置的os
模块也可以直接调用操作系统提供的接口函数。在操作系统中定义的环境变量,全部保存在
os.environ
这个变量中,可以直接查看:要获取某个环境变量的值,可以调用
os.environ.get('key')
:操作文件和目录的函数一部分放在
os
模块中,一部分放在os.path
模块中。查看、创建和删除目录可以这么调用:把两个路径合成一个时,不要直接拼字符串,而要通过
os.path.join()
函数,这样可以正确处理不同操作系统的路径分隔符- 在
Linux/Unix/Mac
下,os.path.join()
返回这样的字符串:part-1/part-2
- 而
Windows
下会返回这样的字符串:part-1\part-2
同样的道理,要拆分路径时,也不要直接去拆字符串,而要通过
os.path.split()
函数,这样可以把一个路径拆分为两部分,后一部分总是最后级别的目录或文件名:os.path.splitext()
可以直接得到文件扩展名,很多时候非常方便:这些合并、拆分路径的函数并不要求目录和文件要真实存在,它们只对字符串进行操作。
文件操作使用下面的函数。假定当前目录下有一个
test.txt
文件:是复制文件的函数居然在
os
模块中不存在!原因是复制文件并非由操作系统提供的系统调用。理论上讲,通过上一节的读写文件可以完成文件复制,只不过要多写很多代码。幸运的是
shutil
模块提供了copyfile()
的函数,可以在shutil
模块中找到很多实用函数,它们可以看做是os
模块的补充。利用
Python
的特性来过滤文件,比如要列出当前目录下的所有目录,只需要一行代码:要列出所有的
.py
文件,也只需一行代码:序列化
在程序运行的过程中,所有的变量都是在内存中,比如,定义一个
dict
:可以随时修改变量,比如把
name
改成'Bill'
,但是一旦程序结束,变量所占用的内存就被操作系统全部回收。如果没有把修改后的'Bill'
存储到磁盘上,下次重新运行程序,变量又被初始化为'Bob'
。把变量从内存中变成可存储或传输的过程称之为序列化(pickling),
Python
提供了pickle
模块来实现序列化。序列化之后,就可以把序列化后的内容写入磁盘,或者通过网络传输到别的机器上。反过来,把变量内容从序列化的对象重新读到内存里称之为反序列化,即
unpickling
。把一个对象序列化并写入文件:
pickle.dumps()
方法把任意对象序列化成一个bytes
,然后,就可以把这个bytes
写入文件。或者用另一个方法pickle.dump()
直接把对象序列化后写入一个file-like Object
:当要把对象从磁盘读到内存时,可以先把内容读到一个
bytes
,然后用pickle.loads()
方法反序列化出对象,也可以直接用pickle.load()
方法从一个file-like Object
中直接反序列化出对象。打开另一个
Python
命令行来反序列化刚才保存的对象:Pickle
的问题和所有其他编程语言特有的序列化问题一样,就是它只能用于Python
,并且可能不同版本的Python
彼此都不兼容,因此,只能用Pickle
保存那些不重要的数据,不能成功地反序列化也没关系。JSON
如果要在不同的编程语言之间传递对象,就必须把对象序列化为标准格式,比如
XML
,但更好的方法是序列化为JSON
,因为JSON
表示出来就是一个字符串,可以被所有语言读取,也可以方便地存储到磁盘或者通过网络传输。JSON
不仅是标准格式,并且比XML
更快,而且可以直接在Web
页面中读取,非常方便。JSON
表示的对象就是标准的JavaScript
语言的对象,JSON
和Python
内置的数据类型对应如下:Python
内置的json
模块提供了非常完善的Python
对象到JSON
格式的转换,把Python
对象变成一个JSON
:dumps()
方法返回一个str
,内容就是标准的JSON
。类似的,dump()
方法可以直接把JSON
写入一个file-like Object
。要把
JSON
反序列化为Python
对象,用loads()
或者对应的load()
方法,前者把JSON
的字符串反序列化,后者从file-like Object
中读取字符串并反序列化:由于
JSON
标准规定JSON
编码是UTF-8
,所以总是能正确地在Python
的str
与JSON
的字符串之间转换Python
的dict
对象可以直接序列化为JSON
的{}
,不过,很多时候,我们更喜欢用class
表示对象,比如定义Student
类,然后序列化:错误的原因是
Student
对象不是一个可序列化为JSON的对象。如果连class
的实例对象都无法序列化为JSON,这肯定不合理!仔细看看
dumps()
方法的参数列表,可以发现,除了第一个必须的obj
参数外,dumps()
方法还提供了一大堆的可选参数:些可选参数就是让我们来定制JSON序列化。前面的代码之所以无法把
Student
类实例序列化为JSON,是因为默认情况下,dumps()
方法不知道如何将Student
实例变为一个JSON的{}
对象。可选参数
default
就是把任意一个对象变成一个可序列为JSON的对象,只需要为Student
专门写一个转换函数,再把函数传进去即可:这样,
Student
实例首先被student2dict()
函数转换成dict
,然后再被顺利序列化为JSON:不过,下次如果遇到一个
Teacher
类的实例,照样无法序列化为JSON。我们可以偷个懒,把任意class
的实例变为dict
:因为通常
class
的实例都有一个__dict__
属性,它就是一个dict
,用来存储实例变量。也有少数例外,比如定义了__slots__
的class。同样的道理,如果要把JSON反序列化为一个
Student
对象实例,loads()
方法首先转换出一个dict
对象,传入的object_hook
函数负责把dict
转换为Student
实例:打印出的是反序列化的
Student
实例对象 <__main__.Student object at 0x10cd3c190>
异步IO
在一个线程中,CPU执行代码的速度极快,然而,一旦遇到IO操作,如读写文件、发送网络数据时,就需要等待IO操作完成,才能继续进行下一步操作。这种情况称为同步IO。
在IO操作的过程中,当前线程被挂起,而其他需要CPU执行的代码就无法被当前线程执行了。
因为一个IO操作就阻塞了当前线程,导致其他代码无法执行,所以必须使用多线程或者多进程来并发执行代码,为多个用户服务。每个用户都会分配一个线程,如果遇到IO导致线程被挂起,其他用户的线程不受影响。
多线程和多进程的模型虽然解决了并发问题,但是系统不能无上限地增加线程。由于系统切换线程的开销也很大,所以,一旦线程数量过多,CPU的时间就花在线程切换上了,真正运行代码的时间就少了,结果导致性能严重下降。
由于要解决的问题是CPU高速执行能力和IO设备的龟速严重不匹配,多线程和多进程只是解决这一问题的一种方法。
另一种解决IO问题的方法是异步IO。当代码需要执行一个耗时的IO操作时,它只发出IO指令,并不等待IO结果,然后就去执行其他代码了。一段时间后,当IO返回结果时,再通知CPU进行处理。
可以想象如果按普通顺序写出的代码实际上是没法完成异步IO的:
所以,同步IO模型的代码是无法实现异步IO模型的。
异步IO模型需要一个消息循环,在消息循环中,主线程不断地重复“读取消息-处理消息”这一过程:
消息模型其实早在应用在桌面应用程序中了。一个GUI程序的主线程就负责不停地读取消息并处理消息。所有的键盘、鼠标等消息都被发送到GUI程序的消息队列中,然后由GUI程序的主线程处理。
由于GUI线程处理键盘、鼠标等消息的速度非常快,所以用户感觉不到延迟。某些时候,GUI线程在一个消息处理的过程中遇到问题导致一次消息处理时间过长,此时,用户会感觉到整个GUI程序停止响应了,敲键盘、点鼠标都没有反应。这种情况说明在消息模型中,处理一个消息必须非常迅速,否则,主线程将无法及时处理消息队列中的其他消息,导致程序看上去停止响应。
消息模型是如何解决同步IO必须等待IO操作这一问题的呢?当遇到IO操作时,代码只负责发出IO请求,不等待IO结果,然后直接结束本轮消息处理,进入下一轮消息处理过程。当IO操作完成后,将收到一条“IO完成”的消息,处理该消息时就可以直接获取IO操作结果。
在“发出IO请求”到收到“IO完成”的这段时间里,同步IO模型下,主线程只能挂起,但异步IO模型下,主线程并没有休息,而是在消息循环中继续处理其他消息。这样,在异步IO模型下,一个线程就可以同时处理多个IO请求,并且没有切换线程的操作。对于大多数IO密集型的应用程序,使用异步IO将大大提升系统的多任务处理能力。
协程
协程(Coroutine),又称微线程,纤程。协程的概念很早就提出来了,但直到最近几年才在某些语言(如Lua)中得到广泛应用。
子程序,或者称为函数,在所有语言中都是层级调用,比如A调用B,B在执行过程中又调用了C,C执行完毕返回,B执行完毕返回,最后是A执行完毕。
所以子程序调用是通过栈实现的,一个线程就是执行一个子程序。
子程序调用总是一个入口,一次返回,调用顺序是明确的。而协程的调用和子程序不同。
协程看上去也是子程序,但执行过程中,在子程序内部可中断,然后转而执行别的子程序,在适当的时候再返回来接着执行。
注意,在一个子程序中中断,去执行其他子程序,不是函数调用,有点类似CPU的中断。比如子程序A、B:
假设由协程执行,在执行A的过程中,可以随时中断,去执行B,B也可能在执行过程中中断再去执行A,结果可能是:
但是在A中是没有调用B的,所以协程的调用比函数调用理解起来要难一些。
看起来A、B的执行有点像多线程,但协程的特点在于是一个线程执行,那和多线程比,协程有何优势?
最大的优势就是协程极高的执行效率。因为子程序切换不是线程切换,而是由程序自身控制,因此,没有线程切换的开销,和多线程比,线程数量越多,协程的性能优势就越明显。
第二大优势就是不需要多线程的锁机制,因为只有一个线程,也不存在同时写变量冲突,在协程中控制共享资源不加锁,只需要判断状态就好了,所以执行效率比多线程高很多。
因为协程是一个线程执行,那怎么利用多核CPU呢?最简单的方法是多进程+协程,既充分利用多核,又充分发挥协程的高效率,可获得极高的性能。
Python对协程的支持是通过generator实现的。
在generator中,不但可以通过
for
循环来迭代,还可以不断调用next()
函数获取由yield
语句返回的下一个值。但是Python的
yield
不但可以返回一个值,它还可以接收调用者发出的参数。来看例子:
传统的生产者-消费者模型是一个线程写消息,一个线程取消息,通过锁机制控制队列和等待,但一不小心就可能死锁。
如果改用协程,生产者生产消息后,直接通过
yield
跳转到消费者开始执行,待消费者执行完毕后,切换回生产者继续生产,效率极高:注意到
consumer
函数是一个generator
,把一个consumer
传入produce
后:- 首先调用
c.send(None)
启动生成器;
- 然后,一旦生产了东西,通过
c.send(n)
切换到consumer
执行;
consumer
通过yield
拿到消息,处理,又通过yield
把结果传回;
produce
拿到consumer
处理的结果,继续生产下一条消息;
produce
决定不生产了,通过c.close()
关闭consumer
,整个过程结束。
整个流程无锁,由一个线程执行,
produce
和consumer
协作完成任务,所以称为“协程”,而非线程的抢占式多任务。最后套用Donald Knuth的一句话总结协程的特点:“子程序就是协程的一种特例。”
asyncio
asyncio
是Python 3.4版本引入的标准库,直接内置了对异步IO的支持。asyncio
的编程模型就是一个消息循环。从asyncio
模块中直接获取一个EventLoop
的引用,然后把需要执行的协程扔到EventLoop
中执行,就实现了异步IO。用
asyncio
实现Hello world
代码如下:@asyncio.coroutine
把一个generator标记为coroutine类型,然后,我们就把这个coroutine
扔到EventLoop
中执行。hello()
会首先打印出Hello world!
,然后,yield from
语法可以让我们方便地调用另一个generator
。由于asyncio.sleep()
也是一个coroutine
,所以线程不会等待asyncio.sleep()
,而是直接中断并执行下一个消息循环。当asyncio.sleep()
返回时,线程就可以从yield from
拿到返回值(此处是None
),然后接着执行下一行语句。把
asyncio.sleep(1)
看成是一个耗时1秒的IO操作,在此期间,主线程并未等待,而是去执行EventLoop
中其他可以执行的coroutine
了,因此可以实现并发执行。用Task封装两个
coroutine
试试:观察执行过程:
由打印的当前线程名称可以看出,两个
coroutine
是由同一个线程并发执行的。如果把
asyncio.sleep()
换成真正的IO操作,则多个coroutine
就可以由一个线程并发执行。用
asyncio
的异步网络连接来获取sina、sohu和163的网站首页:执行结果如下:
可见3个连接由一个线程通过
coroutine
并发完成。async/await
用
asyncio
提供的@asyncio.coroutine
可以把一个generator
标记为coroutine
类型,然后在coroutine
内部用yield from
调用另一个coroutine
实现异步操作。为了简化并更好地标识异步IO,从
Python 3.5
开始引入了新的语法async
和await
,可以让coroutine
的代码更简洁易读。async
和await
是针对coroutine
的新语法,要使用新的语法,只需要做两步简单的替换:- 把
@asyncio.coroutine
替换为async
;
- 把
yield from
替换为await
。
对比一下上一节的代码:
用新语法重新编写如下:
剩下的代码保持不变。
aiohttp
asyncio
可以实现单线程并发IO操作。如果仅用在客户端,发挥的威力不大。如果把asyncio
用在服务器端,例如Web服务器,由于HTTP连接就是IO操作,因此可以用单线程+coroutine
实现多用户的高并发支持。asyncio
实现了TCP、UDP、SSL等协议,aiohttp
则是基于asyncio
实现的HTTP框架。编写一个HTTP服务器,分别处理以下URL:
/
- 首页返回b'<h1>Index</h1>'
/hello/{name}
- 根据URL参数返回文本hello, %s!
aiohttp
的初始化函数init()
也是一个coroutine
,loop.create_server()
则利用asyncio
创建TCP服务