1. asyncio

1.1asyncio/await 用法

async/await 是 python3.5中新加入的特性，将异步从原来的yield 写法中解放出来，变得更加直观。
在3.5之前，如果想要使用异步，主要使用yield语法。举例如下：

import asyncio

@asyncio.coroutine  # 修饰符，等同于 asyncio.coroutine(hello())
def hello():
    print('Hello world! (%s)' % threading.currentThread())
    yield from asyncio.sleep(1)  # 执行到这一步以后，直接切换到下一个任务，等到一秒后再切回来
    print('Hello again! (%s)' % threading.currentThread())

loop = asyncio.get_event_loop()  
tasks = [hello(), hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

引入了async/await以后，hello()可以写成这样：

async def hello():
    print("Hello world!")
    r = await asyncio.sleep(1)
    print("Hello again!")

注意此时已经不需要使用@asyncio.coroutin进行修饰，而是在def之前加async表示这是个异步函数，其内有异步操作。此外，使用await 替换了yield from, 表示这一步为异步操作。

加一项，关于时间获取：

import time
now = lambda: time.time()    # 获取当前时间
# 待执行程序执行
start = now()    # 在获取一下时间
print('TIME: ', now() - start)     # 动态获取行进时间

不同于：
start = time.time()
# 待执行程序执行
end = time.time()
print('TIME: ', end - start)    # 获取时间是固定的

1.2关于run_until_complete和run_server的区别

一般先要设置一个loop循环 loop = asyncio.get_event_loop()

我们一直通过 run_until_complete 来运行 loop ，等到 future 完成，run_until_complete 也就返回了。

输出：

现在改用 run_forever：

输出：

三秒钟过后，future 结束，但是程序并不会退出。run_forever 会一直运行，直到 stop 被调用，但是你不能像下面这样调 stop：

run_forever 不返回，stop 永远也不会被调用。所以，只能在协程中调 stop：

这样并非没有问题，假如有多个协程在 loop 里运行：

第二个协程没结束，loop 就停止了——被先结束的那个协程给停掉的。

要解决这个问题，可以用 gather 把多个协程合并成一个 future，并添加回调，然后在回调里再去停止 loop。

看一个小测试：

# 一个关于协程的小测试：run_forever的回调关闭循环
import asyncio
import functools

async def compute(x, y):
    print("Compute %s + %s ..." % (x, y))
    await asyncio.sleep(2.0)
    return x + y

async def print_sum(x, y):
    result = await compute(x, y)
    print("%s + %s = %s" % (x, y, result))

def done_callback(loop,futu):
    # 这里还可以执行futu的相关操作
    print('关闭loop循环')
    loop.stop()

loop = asyncio.get_event_loop()
# tasks = [print_sum(1, 2), print_sum(3, 4), print_sum(5, 6)]
# loop.run_until_complete(asyncio.wait(tasks))  # run_until_complete 完成后释放，结束loop，相当于loop.close()

futus = asyncio.gather(print_sum(1, 2), print_sum(3, 4), print_sum(5, 6))
futus.add_done_callback(functools.partial(done_callback, loop))
loop.run_forever()  # 执行多个协程之后再回调一个done_callback来停止循环，其实run_until_complete就是基于run_forever()

1.1.2 loop.close()?

简单来说，loop 只要不关闭，就还可以再运行。：

但是如果关闭了，就不能再运行了：

1.1.3 回调函数：add_done_callback

回调函数，执行且按照顺序，假如协程是一个 IO 的读操作，等读完数据后，我们希望得到通知，以便下一步数据的处理。这一需求可以通过往 future 添加回调来实现。

import asyncio
async def hello1():
    print("1, Hello world!")
    #r = await asyncio.sleep(1)
    print("1, Hello again!")
    for i in range(5):
        print(i)

async def hello2():
    print("2, Hello world!")
    #r = await asyncio.sleep(1)
    print("2, Hello again!")
    for i in range(5,10):
        print(i)

def done_callback1(futu):  # futu是异步的函数名称
    print('Done1')

def done_callback2(futu):
    print('Done2')

futu = asyncio.ensure_future(hello1())
futu.add_done_callback(done_callback1) 
futu = asyncio.ensure_future(hello2())
futu.add_done_callback(done_callback2)

loop.run_until_complete(futu)
>>> 1, Hello world!
>>> 1, Hello again!
>>> 0
>>> 1
>>> 2
>>> 3
>>> 4
>>> 2, Hello world!
>>> 2, Hello again!
>>> 5
>>> 6
>>> 7
>>> 8
>>> 9
>>> Done1
>>> Done2

1.1.4 多个协程运行的三种写法

# 多个协程同步执行
# 第一种写法
loop.run_until_complete(asyncio.gather(hello1(), hello2()))

# 第二种写法
coros = [hello1(), hello2()]
loop.run_until_complete(asyncio.gather(*coros))

# 第三种写法
futus = [asyncio.ensure_future(hello1()),
             asyncio.ensure_future(hello2())]

loop.run_until_complete(asyncio.gather(*futus))

当然也可以这么写：
tasks = [ asyncio.ensure_future(hello1()), asyncio.ensure_future(hello2())] 
loop = asyncio.get_event_loop() 
loop.run_until_complete(asyncio.wait(tasks))

2. aiohttp

aiohttp是一个用于web服务的库，网上的资料，包括廖雪峰的网站中的资料大部分是关于服务器端(server)的，关于客户端(client)的资料不多。

2.1 基本用法

async with aiohttp.get('https://github.com') as r:
        await r.text()

其中r.text(), 可以在括号中指定解码方式，编码方式，例如

await resp.text(encoding='windows-1251')

或者也可以选择不编码，适合读取图像等，是无法编码的

await resp.read()

例子：一个简单的小例子：

import asyncio,aiohttp

async def fetch_async(url):
print(url)
async with aiohttp.request("GET",url) as r:
reponse = await r.text(encoding="utf-8")　　#或者直接await r.read()不编码，直接读取，适合于图像等无法编码文件
print(reponse)

tasks = [fetch_async('http://www.baidu.com/'), fetch_async('http://www.chouti.com/')]

event_loop = asyncio.get_event_loop()
results = event_loop.run_until_complete(asyncio.gather(*tasks))     # 这里使用asyncio.gather()和asyncio.wait()不一样。gather把多个函数包装成单个tasks，因为loop.run_until_complete只接受
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 单个tasks,而wait()用于调用单一函数
event_loop.close()

2.2 设置timeout

需要加一个with aiohttp.Timeout(x)

with aiohttp.Timeout(0.001):
    async with aiohttp.get('https://github.com') as r:
        await r.text()

2.3 使用session获取数据

这里要引入一个类，aiohttp.ClientSession. 首先要建立一个session对象，然后用该session对象去打开网页。session可以进行多项操作，比如post, get, put, head等等，如下面所示

import asyncio,aiohttp

async def fetch_async(url):
    print(url)
    async with aiohttp.ClientSession() as session:　　#协程嵌套，只需要处理最外层协程即可fetch_async
        async with session.get(url, timeout=60) as resp:  #设置超时处理60s
            print(resp.status)
　　　　　　　print(resp.charset)　　　　  　　　　　　#查看默认编码,默认使用utf-8
　　　　　　　print(await resp.read())　　　　　　　　#使用read()方法时，不会进行编码，是以字节的形式读取
            print(await resp.text())　　　　　　　　#因为这里使用到了await关键字，实现异步，所有他上面的函数体需要声明为异步async
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#resp.text()会自动将服务器端返回的内容进行解码decode,我们也可以自定义 resp.text(encoding='gb2312')
　　　　　　　print(await resp.content.read())　　　 #使用字节流形式获取数据，而不像text(),read()方法那样一次性获取数据，注意：session.get()是Response对象，他继承于StreamResponse

　　　　　　　print(resp.cookies)　　　　　　　　　　　#获取当前cookies
　　　　　　　print(resp.headers)　　　　　　　　　　　#查看响应头dict形式
　　　　　　　print(resp.raw_headers)　　　　　　　　　#查看原生headers，字节型
　　　　　　  print(resp.history)　　　　　　　　　　　　

tasks = [fetch_async('http://www.baidu.com/'), fetch_async('http://www.cnblogs.com/ssyfj/')]

event_loop = asyncio.get_event_loop()
results = event_loop.run_until_complete(asyncio.gather(*tasks))
event_loop.close()

如果要使用其他方法，则相应的语句要改成

session.put('http://httpbin.org/put', data=b'data')
session.delete('http://httpbin.org/delete')
session.head('http://httpbin.org/get')
session.options('http://httpbin.org/get')
session.patch('http://httpbin.org/patch', data=b'data')

2.4 自定义headers

这个比较简单，将headers放于session.get/post的选项中即可。注意headers数据要是dict格式

url = 'https://api.github.com/some/endpoint'
headers = {'content-type': 'application/json'}
await session.get(url, headers=headers)

async def func1(url,params,filename):  #用自定义headers异步读写文件
    async with aiohttp.ClientSession() as session:
        headers = {'Content-Type':'text/html; charset=utf-8'}
        async with session.get(url,params=params,headers=headers) as r:
            with open(filename,"wb") as fp:
                while True:
                    chunk = await r.content.read(10)
                    if not chunk:
                        break
                    fp.write(chunk)

2.5 使用代理

conn = aiohttp.ProxyConnector(proxy="http://some.proxy.com", proxy_auth=aiohttp.BasicAuth('user', 'pass'))  # 如果需要代理认证的话，就需要加这个proxy_auth选项
async with aiohttp.ClientSession(connector=conn) as session:
　　async with session.get('http://python.org') as resp:
   　　print(resp.status)

2.6 自定义cookie

url = 'http://httpbin.org/cookies'
async with ClientSession({'cookies_test': 'Monday'}) as session:
    async with session.get(url) as resp:
        assert await resp.json() == {"cookies":
                                         {"cookies_test": "Monday"}}

2.7 在URL中传递参数

我们经常需要通过 get 在url中传递一些参数，参数将会作为url问号后面的一部分发给服务器。在aiohttp的请求中，允许以dict的形式来表示问号后的参数。举个例子，如果你想传递 key1=value1 key2=value2 到 httpbin.org/get 你可以使用下面的代码：

params = {'key1': 'value1', 'key2': 'value2'}
async with session.get('http://httpbin.org/get',
                       params=params) as resp:
                       assert resp.url == 'http://httpbin.org/get?key2=value2&key1=value1'

可以看到，代码正确的执行了，说明参数被正确的传递了进去。不管是一个参数两个参数，还是更多的参数，都可以通过这种方式来传递。除了这种方式之外，还有另外一个，使用一个 list 来传递（这种方式可以传递一些特殊的参数，例如下面两个key是相等的也可以正确传递）：

params = [('key', 'value1'), ('key', 'value2')]
async with session.get('http://httpbin.org/get',
                       params=params) as r:
    assert r.url == 'http://httpbin.org/get?key=value2&key=value1'

除了上面两种，我们也可以直接通过传递字符串作为参数来传递，但是需要注意，通过字符串传递的特殊字符不会被编码：

async with session.get('http://httpbin.org/get',
                       params='key=value+1') as r:
        assert r.url == 'http://httpbin.org/get?key=value+1'

3. 样例

3.1下面这个简单的爬虫，是用来爬取我博客下所有的文章的

import urllib.request as request
from bs4 import BeautifulSoup as bs
import asyncio
import aiohttp

@asyncio.coroutine
async def getPage(url,res_list):
    print(url)
    headers = {'User-Agent':'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'}
    # conn = aiohttp.ProxyConnector(proxy="http://127.0.0.1:8087")
    async with aiohttp.ClientSession() as session:
        async with session.get(url,headers=headers) as resp:
            assert resp.status==200
            res_list.append(await resp.text())


class parseListPage():
    def __init__(self,page_str):
        self.page_str = page_str
    def __enter__(self):
        page_str = self.page_str
        page = bs(page_str,'lxml')
        # 获取文章链接
        articles = page.find_all('div',attrs={'class':'article_title'})
        art_urls = []
        for a in articles:
            x = a.find('a')['href']
            art_urls.append('http://blog.csdn.net'+x)
        return art_urls
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass


page_num = 5
page_url_base = 'http://blog.csdn.net/u014595019/article/list/'
page_urls = [page_url_base + str(i+1) for i in range(page_num)]
loop = asyncio.get_event_loop()
ret_list = []
tasks = [getPage(host,ret_list) for host in page_urls]
loop.run_until_complete(asyncio.wait(tasks))

articles_url = []
for ret in ret_list:
    with parseListPage(ret) as tmp:
        articles_url += tmp
ret_list = []

tasks = [getPage(url, ret_list) for url in articles_url]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

3.2

来源：oschina

链接：https://my.oschina.net/u/4388710/blog/3923469

标签

def

httpbin

异步：asyncio和aiohttp的一些应用（1）