Python异步爬虫详解

原创

mb5fe94cdd5807a 2021-01-03 19:43:46 ©著作权

文章标签 Java 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者mb5fe94cdd5807a的原创作品，请联系作者获取转载授权，否则将追究法律责任

一、同步与异步 异步编程可以大幅度的提高系统的吞吐量，提高单位时间内发出的请求数目。之前大邓写的爬虫都是同步，就是对aurl发起请求，等待响应。然后再访问burl，等待响应。。。

大量的时间消耗在等待上，如果能近似的同时对多个网址发起请求，等待响应，速度回快很多倍。这里的同时其实是为了让大家便于理解，其实所谓的同时也是有先后顺序的，所以叫异步。

文字描述太别扭，我们水平方向代表时间


#同步编程（同一时间只能做一件事，做完了才能做下一件事情）
<-a_url-><-b_url-><-c_url->

#异步编程 (可以近似的理解成同一时间有多个事情在做，但有先后)
<-a_url->
  <-b_url->
    <-c_url->
      <-d_url->
        <-e_url->
          <-f_url->
            <-g_url->
              <-h_url->
                <--i_url-->
                  <--j_url-->

你看同步编程同样的时间访问了3个网址，但是异步编程访问的效率提高了很多倍。

二、async&await 在python3.5之后，开始引入async和await语法结构，通过async关键词定义一个协程(不用管啥名字，总之就理解成异步吧)。其实我也有很多地方不熟悉，没关系，先会用，孰而知之。

2.1 并不成功的套路 网上看了些教程，总结出来大概是以下的模板：


import asyncio

#函数名:做现在的任务时不等待，能继续做别的任务。
async def donow_meantime_dontwait(url):
    response = await requests.get(url)


#函数名:快速高效的做任务
async def fast_do_your_thing():
    await asyncio.wait([donow_meantime_dontwait(url) for url in urls])
    
#下面两行都是套路，记住就好
loop = asyncio.get_event_loop()
loop.run_until_complete(fast_do_your_thing())

将模板改造，开始实验


import asyncio
import requests
import time


urls = ['https://book.douban.com/tag/小说','https://book.douban.com/tag/科幻',
        'https://book.douban.com/tag/漫画','https://book.douban.com/tag/奇幻',
        'https://book.douban.com/tag/历史','https://book.douban.com/tag/经济学']

async def requests_meantime_dont_wait(url):
    print(url)
    response = await requests.get(url)
    print("{url} 得到响应".format(url=url))


async def fast_requsts():
    start = time.time()
    await asyncio.wait([requests_meantime_dont_wait(url) for url in urls])
    end = time.time()
    print("耗时 {} 秒".format(end - start))


loop = asyncio.get_event_loop()
loop.run_until_complete(fast_requsts())

正以为成功了，出现bug。requests库返回的响应对象不能使用await关键词。

TypeError: object Response can't be used in 'await' expression 百度一下，await表达式中的对象必须是awaitable。


PEP 492 -- Coroutines with async and await syntax https://www.python.org/dev/peps/pep-0492/

awaitable对象

A native coroutine object returned from a native coroutine function
A generator-based coroutine object returned from a function decorated with types.coroutine() .
An object with an await method returning an iterator.

又百度了下，说是封装下就可变成原生异步函数。不懂啥意思，还是copy代码直接运行试试吧。

import asyncio
import requests
import time

urls = ['https://book.douban.com/tag/小说','https://book.douban.com/tag/科幻',
        'https://book.douban.com/tag/漫画','https://book.douban.com/tag/奇幻',
        'https://book.douban.com/tag/历史','https://book.douban.com/tag/经济学']


async def requests_meantime_dont_wait(url):
    """注意这里没有await关键词"""
    resp = requests.get(url)
    print(resp.status_code)
    

async def package_requests(url):
    """将requests_meantime_dont_wait封装成awaitbale。"""
    print(url)
    await requests_meantime_dont_wait(url)
    print("{url} 得到响应".format(url=url))


async def fast_requsts(urls):
    start = time.time()
    await asyncio.wait([package_requests(url) for url in urls])
    end = time.time()
    print("Complete in {} seconds".format(end - start))


loop = asyncio.get_event_loop()
loop.run_until_complete(fast_requsts(urls))loop.close()
https://book.douban.com/tag/经济学
200
https://book.douban.com/tag/经济学 得到响应
https://book.douban.com/tag/奇幻
200
https://book.douban.com/tag/奇幻 得到响应
https://book.douban.com/tag/历史
200
https://book.douban.com/tag/历史 得到响应
https://book.douban.com/tag/漫画
200
https://book.douban.com/tag/漫画 得到响应
https://book.douban.com/tag/小说
200
https://book.douban.com/tag/小说 得到响应
https://book.douban.com/tag/科幻
200
https://book.douban.com/tag/科幻 得到响应
Complete in 3.8158602714538574 seconds

代码正常运行，可是打印出来的东西不对啊。应该是几个网址在一起，然后是200状态吗在一起才对的。这应该不是异步，后来去掉异步的这些关键词单独运行，运行效率没有啥大区别。

2.2 终于找到正确的套路 继续百度,奥，requests不支持非阻塞。即使使用异步编程，requests库还是按照同步那样访问完aurl，得到响应后才再访问burl。。。。

坑爹啊,继续百度发现aiohttp，用于异步请求的库。还是不懂，陆陆续续，经过数小时的百度，copy，试运行，终于成品出来了。


import asyncio
import requests
import time
import aiohttp

#urls = ['https://book.douban.com/tag/小说','https://book.douban.com/tag/科幻',
        #'https://book.douban.com/tag/漫画','https://book.douban.com/tag/奇幻',
        #'https://book.douban.com/tag/历史','https://book.douban.com/tag/经济学']

urls = ['http://www.jianshu.com/p/b59453dd38cf','http://www.jianshu.com/','http://pbpython.com/pathlib-intro.html']

async def requests_meantime_dont_wait(url):
    print(url)
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            print(resp.status)
            print("{url} 得到响应".format(url=url))


async def fast_requsts(urls):
    start = time.time()
    await asyncio.wait([requests_meantime_dont_wait(url) for url in urls])
    end = time.time()
    print("Complete in {} seconds".format(end - start))


loop = asyncio.get_event_loop()
loop.run_until_complete(fast_requsts(urls))loop.close()

由于我的行径对豆瓣太恶劣了，访问次数过多。出现一些异常，在写文字时随便抽取了三个网址作为测试用的网址。结果很符合预期，实现了异步，先对多个网址发起请求，慢慢的等待结果的到来。


http://www.jianshu.com/p/b59453dd38cf
http://pbpython.com/pathlib-intro.html
http://www.jianshu.com/
200
http://www.jianshu.com/ 得到响应
200
http://www.jianshu.com/p/b59453dd38cf 得到响应
200
http://pbpython.com/pathlib-intro.html 得到响应
Complete in 1.152311086654663 seconds