【爬虫小白】aiohttp异步爬取简单使用

了解aiohttp

        aiohttp是一个基于asyncio的异步http网络模块，它既提供了服务端，有提供了客户端。其中我们可以用服务端搭建一个支持异步处理的服务器，用于处理请求并返回响应，类似于Django、Flask等一些Web服务器，而客户端我们就可以用来发起请求，就类似于requests来发起一个http请求然后获得响应，但requests发起的是同步网络请求，而aiohttp则发起的是异步的。

我们先了解一下aiohttp客户端部分使用。

基本使用

基本实例

我们先看一个基本的aiohttp请求案例，【代码】如下：

import aiohttp
import asyncio


async def get(session, url):
    async with session.get(url) as response:
        return await response.text(), response.status

async def main():
    async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(limit=64, verify_ssl=False)) as session:
        html, status = await get(session, 'https://baidu.com')
        print(f"html:{html}....")
        print(f"status:{status}")

if __name__ == '__main__':
    loop =asyncio.get_event_loop()
    loop.run_until_complete(main())

在这里使用aiohttp来爬取百度首页，获得源码和响应状态码并输出，运行结果如下：

html:

   

........
status:200

这里源码比较长，只复制一部分，可以看到已成功获取网页源代码以及响应状态码200，完成了一次HTTP请求，即我们成功使用aiohttp通过异步方式进行了网页爬取，当然这个操作，requests同样可以做到，

在使用aiohttp请求是，需要注意以下几点：

• 首先在导入库的时候，除了必须要引用aiohttp这个库外，还必须要引入asyncio这个库，因此要实现异步爬取需要启动协程，而协程则需要借助于asyncio里面的事件循环来执行，除了事件循环，asyncio里面也提供了很多基础的异步操作。
• 异步爬取的方法的定义和同步请求有所不同，在每一个异步方法前面加async来修饰。
• with  as 语句前面同样需要加async来修饰，在Python中，with as 语句用于声明一个上下文管理器，能够帮我们自动分配和释放资源，而在异步方法中，with as 前面加上 async代表声明一个支持异步的上下文管理器。
• 对于一些返回coroutine的操作，前面需要加await来修饰，如response调用text方法，查询API（官方文档）可以发现其返回的是coroutine对象， 那么前面就要加await；而对于状态码来说，其返回值就是一个数值类型，那么前面就不要加await。所以，这里可以按照实际情况处理，具体可以查官方文档看看其对应的返回值是怎样的类型，然后决定加不加await就可以来（也可以type看下类型）
• 最后，定义完爬取方法后，实际上是main方法调用了get方法，要运行的话，必须要启用事件循环，事件循环就需要使用asyncio库，然后使用run_until_complete方法来运行。

注意：在python3.7以上的版本，我们可以使用asyncio.run(main())来替代最后的启动操作，不需要显示声明事件循环，run方法内部会自动启动一个事件循环。

异步-URL参数设置

GET传入params参数

       对于URL参数的设置，可以借助于params参数，传入一个字典即可

【代码示例】：

import aiohttp
import asyncio

async def main():
    params = {'name': 'name', 'age': 22}
    async  with aiohttp.ClientSession(connector=aiohttp.TCPConnector(verify_ssl=False)) as session:
        async with session.get('https://xxx/xx/xx', params=params) as response:
            print(await response.text())


if __name__ == '__main__':
    loop=asyncio.get_event_loop()
    loop.run_until_complete(main())

其实际请求的URL为 https://xxx/xx/xx?name=name&age=22 

其它请求类型

另外aiohttp还支持其它的请求类型，如：POST、PUT、DELETE等等，这个和requests的使用方式有点类似。

【示例如下】：

1. session.post('https://xx/xx/post',data=b"data")
2. session.put('https://xx/xx/put',data=b"data")
3. session.delete('https://xx/xx/delete')
4. session.head('https://xx/xx/get')
5. session.options('https://xx/xx/get')
6. session.patch('https://xx/xx/patch',data=b"data")

POST数据

对于POST表单提交。

【示范】如下：

import aiohttp
import asyncio
async def main():
    data = {'data': 'xxx'}
    async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(verify_ssl=False)) as session:
        #如果请求头Content-type为application/x-www-form-urlencoded，用下方来实现
        async  with session.post('https://xxx/post', data=data) as response:
        ##如果请求头Content-type为application/application/json，我们只需要把参数修改为：
        # async  with session.post('https://xxx/post', json=data) as response:
            print(await response.text())
if __name__ == '__main__':
    asyncio.get_event_loop().run_until_complete(main())

注意，post请求代码含有两种方式

超时设置

超时设置，我们需要借助aiohttp里面ClientTimeout对象来实现。

【示例】：

import aiohttp
import asyncio

async def main():
    timeout=aiohttp.ClientTimeout(total=1)  #设置一秒超时
    async with aiohttp.ClientSession(timeout=timeout,connector=aiohttp.TCPConnector(verify_ssl=False)) as session:
        async with session.get('http://xxx/xxx') as response:
            print(await response.text())
            
if __name__ == '__main__':
    asyncio.get_event_loop().run_until_complete(main())

如果超时的话，会抛出TimeoutError异常，其类型为asyncio.TimeoutError，我们可以异常捕获即可

另外ClienTimeout对象声明还有其它参数，如，connect、socket_connent等等，详细可以参考官方文档：https://docs.aiohttp.org/en/stable/client_quickstart.html#timeouts

并发限制

由于aiohttp可以支持非常大的并发，比如上万、十万、百万都是能做到的，但这么大的并发量，目标网站是很可能在短时间无法响应，可能瞬间将目标网站挂掉，所以我们需要控制一下并发的量。

我们可以借助于asyncio的Semaphore来控制并发量，【示例】如下：

import aiohttp
import asyncio

CONCURRENCY = 5  # 声明并发数，
URL='https://www.baidu.com'
semaphore=asyncio.Semaphore(CONCURRENCY)  #设置控制异步并发数
session=None
async def scrape_api():
    async with semaphore:
        print('scraping',URL)
        async with session.get(URL) as response:
            await asyncio.sleep(1)
            return await response.text()

async def main():
    global session
    session=aiohttp.ClientSession(connector=aiohttp.TCPConnector(verify_ssl=False))
    acrape_index_tasks=[asyncio.ensure_future(scrape_api()) for _ in range(10000)]
    await asyncio.gather(*acrape_index_tasks)
if __name__ == '__main__':
    asyncio.get_event_loop().run_until_complete(main())

在这里我们声明CONCURRENCY代表爬取的最大并发量为5，同时声明爬取的目标URL为百度。接着我们借助于Semaphore创建一个信号量对象。赋值为semaphore，这样我们就可以用它来控制最大并发量了，我们这里把它直接放置对应的爬取方式里面，使用async with 语句将semaphore作为上下文对象即可。这样，信号量可以控制进入爬取最大协程数量，最大数量就是我们声明的CONCURRENCY的值。

在main方法里面，我们声明了10000个task，传递给gather方法运行，倘若不加以限制，这1000个task会被同时执行，并发量太大，但有信号量的控制之后，同时运行的task的数量最大会被控制在5个，这样就能给aiohttp限制速度了。

点击查看 异步案例使用，