python实现并发爬虫

Posted 迎风而来

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python实现并发爬虫相关的知识,希望对你有一定的参考价值。

在进行单个爬虫抓取的时候,我们不可能按照一次抓取一个url的方式进行网页抓取,这样效率低,也浪费了cpu的资源。目前python上面进行并发抓取的实现方式主要有以下几种:进程,线程,协程。进程不在的讨论范围之内,一般来说,进程是用来开启多个spider,比如我们开启了4进程,同时派发4个spider进行网络抓取,每个spider同时抓取4个url。

所以,我们今天讨论的是,在单个爬虫的情况下,尽可能的在同一个时间并发抓取,并且抓取的效率要高。

一.顺序抓取

顺序抓取是最最常见的抓取方式,一般初学爬虫的朋友就是利用这种方式,下面是一个测试代码,顺序抓取8个url,我们可以来测试一下抓取完成需要多少时间:

HEADERS = {\'Accept\': \'text/html,application/xhtml+xml,application/xml;q=0.9\',                 
   \'Accept-Language\': \'zh-CN,zh;q=0.8\',                                                       
   \'Accept-Encoding\': \'gzip, deflate\',}                                                       
URLS = [\'http://www.cnblogs.com/moodlxs/p/3248890.html\',                                      
        \'https://www.zhihu.com/topic/19804387/newest\',                                        
        \'http://blog.csdn.net/yueguanghaidao/article/details/24281751\',                       
        \'https://my.oschina.net/visualgui823/blog/36987\',                                     
        \'http://blog.chinaunix.net/uid-9162199-id-4738168.html\',                              
        \'http://www.tuicool.com/articles/u67Bz26\',                                            
        \'http://rfyiamcool.blog.51cto.com/1030776/1538367/\',                                  
        \'http://itindex.net/detail/26512-flask-tornado-gevent\']                               
                                                                                              
#url为随机获取的一批url                                                                               
                                                                                              
def func():                                                                                   
    """                                                                                       
    顺序抓取                                                                                      
    """                                                                                       
    import requests                                                                           
    import time                                                                               
    urls = URLS                                                                               
    headers = HEADERS                                                                         
    headers[\'user-agent\'] = "Mozilla/5.0+(Windows+NT+6.2;+WOW64)+AppleWebKit/537" \\           
                            ".36+(KHTML,+like+Gecko)+Chrome/45.0.2454.101+Safari/537.36"      
    print(u\'顺序抓取\')                                                                            
    starttime= time.time()                                                                    
    for url in urls:                                                                          
        try:                                                                                  
            r = requests.get(url, allow_redirects=False, timeout=2.0, headers=headers)        
        except:                                                                               
            pass                                                                              
        else:                                                                                 
            print(r.status_code, r.url)                                                       
    endtime=time.time()                                                                       
    print(endtime-starttime)                                                                  
                                                                                              
func()                                                                                        

我们直接采用内建的time.time()来计时,较为粗略,但可以反映大概的情况。下面是顺序抓取的结果计时:

可以从图片中看到,显示的顺序与urls的顺序是一模一样的,总共耗时为7.763269901275635秒,一共8个url,平均抓取一个大概需要0.97秒。总体来看,还可以接受。

二.多线程抓取

线程是python内的一种较为不错的并发方式,我们也给出相应的代码,并且为每个url创建了一个线程,一共8线程并发抓取,下面的代码:

下面是我们运行8线程的测试代码:

HEADERS = {\'Accept\': \'text/html,application/xhtml+xml,application/xml;q=0.9\',                              
   \'Accept-Language\': \'zh-CN,zh;q=0.8\',                                                                    
   \'Accept-Encoding\': \'gzip, deflate\',}                                                                    
URLS = [\'http://www.cnblogs.com/moodlxs/p/3248890.html\',                                                   
        \'https://www.zhihu.com/topic/19804387/newest\',                                                     
        \'http://blog.csdn.net/yueguanghaidao/article/details/24281751\',                                    
        \'https://my.oschina.net/visualgui823/blog/36987\',                                                  
        \'http://blog.chinaunix.net/uid-9162199-id-4738168.html\',                                           
        \'http://www.tuicool.com/articles/u67Bz26\',                                                         
        \'http://rfyiamcool.blog.51cto.com/1030776/1538367/\',                                               
        \'http://itindex.net/detail/26512-flask-tornado-gevent\']                                            
                                                                                                           
def thread():                                                                                              
    from threading import Thread                                                                           
    import requests                                                                                        
    import time                                                                                            
    urls = URLS                                                                                            
    headers = HEADERS                                                                                      
    headers[\'user-agent\'] = "Mozilla/5.0+(Windows+NT+6.2;+WOW64)+AppleWebKit/537.36+" \\                    
                            "(KHTML,+like+Gecko)+Chrome/45.0.2454.101+Safari/537.36"                       
    def get(url):                                                                                          
        try:                                                                                               
            r = requests.get(url, allow_redirects=False, timeout=2.0, headers=headers)                     
        except:                                                                                            
            pass                                                                                           
        else:                                                                                              
            print(r.status_code, r.url)                                                                    
                                                                                                           
    print(u\'多线程抓取\')                                                                                        
    ts = [Thread(target=get, args=(url,)) for url in urls]                                                 
    starttime= time.time()                                                                                 
    for t in ts:                                                                                           
        t.start()                                                                                          
    for t in ts:                                                                                           
        t.join()                                                                                           
    endtime=time.time()                                                                                    
    print(endtime-starttime)                                                                               
thread()                                                                                                   

多线程抓住的时间如下:

可以看到相较于顺序抓取,8线程的抓取效率明显上升了3倍多,全部完成只消耗了2.154秒。可以看到显示的结果已经不是urls的顺序了,说明每个url各自完成的时间都是不一样的。线程就是在一个进程中不断的切换,让每个线程各自运行一会,这对于网络io来说,性能是非常高的。但是线程之间的切换是挺浪费资源的。

三.gevent并发抓取

gevent是一种轻量级的协程,可用它来代替线程,而且,他是在一个线程中运行,机器资源的损耗比线程低很多。如果遇到了网络io阻塞,会马上切换到另一个程序中去运行,不断的轮询,来降低抓取的时间
下面是测试代码:

HEADERS = {\'Accept\': \'text/html,application/xhtml+xml,application/xml;q=0.9\',
   \'Accept-Language\': \'zh-CN,zh;q=0.8\',
   \'Accept-Encoding\': \'gzip, deflate\',}

URLS = [\'http://www.cnblogs.com/moodlxs/p/3248890.html\',
        \'https://www.zhihu.com/topic/19804387/newest\',
        \'http://blog.csdn.net/yueguanghaidao/article/details/24281751\',
        \'https://my.oschina.net/visualgui823/blog/36987\',
        \'http://blog.chinaunix.net/uid-9162199-id-4738168.html\',
        \'http://www.tuicool.com/articles/u67Bz26\',
        \'http://rfyiamcool.blog.51cto.com/1030776/1538367/\',
        \'http://itindex.net/detail/26512-flask-tornado-gevent\']

def main():
    """
    gevent并发抓取
    """
    import requests
    import gevent
    import time

    headers = HEADERS
    headers[\'user-agent\'] = "Mozilla/5.0+(Windows+NT+6.2;+WOW64)+AppleWebKit/537.36+" \\
                            "(KHTML,+like+Gecko)+Chrome/45.0.2454.101+Safari/537.36"
    urls = URLS
    def get(url):
        try:
            r = requests.get(url, allow_redirects=False, timeout=2.0, headers=headers)
        except:
            pass
        else:
            print(r.status_code, r.url)

    print(u\'基于gevent的并发抓取\')
    starttime= time.time()
    g = [gevent.spawn(get, url) for url in urls]
    gevent.joinall(g)
    endtime=time.time()
    print(endtime - starttime)
main()

协程的抓取时间如下:

正常情况下,gevent的并发抓取与多线程的消耗时间差不了多少,但是可能是我网络的原因,或者机器的性能的原因,时间有点长......,请各位小主在自己电脑进行跑一下看运行时间

四.基于tornado的coroutine并发抓取

tornado中的coroutine是python中真正意义上的协程,与python3中的asyncio几乎是完全一样的,而且两者之间的future是可以相互转换的,tornado中有与asyncio相兼容的接口。
下面是利用tornado中的coroutine进行并发抓取的代码:

 

利用coroutine编写并发略显复杂,但这是推荐的写法,如果你使用的是python3,强烈建议你使用coroutine来编写并发抓取。

下面是测试代码:

HEADERS = {\'Accept\': \'text/html,application/xhtml+xml,application/xml;q=0.9\',
   \'Accept-Language\': \'zh-CN,zh;q=0.8\',
   \'Accept-Encoding\': \'gzip, deflate\',}

URLS = [\'http://www.cnblogs.com/moodlxs/p/3248890.html\',
        \'https://www.zhihu.com/topic/19804387/newest\',
        \'http://blog.csdn.net/yueguanghaidao/article/details/24281751\',
        \'https://my.oschina.net/visualgui823/blog/36987\',
        \'http://blog.chinaunix.net/uid-9162199-id-4738168.html\',
        \'http://www.tuicool.com/articles/u67Bz26\',
        \'http://rfyiamcool.blog.51cto.com/1030776/1538367/\',
        \'http://itindex.net/detail/26512-flask-tornado-gevent\']
import time
from tornado.gen import coroutine
from tornado.ioloop import IOLoop
from tornado.httpclient import AsyncHTTPClient, HTTPError
from tornado.httpclient import HTTPRequest

#urls与前面相同
class MyClass(object):

    def __init__(self):
        #AsyncHTTPClient.configure("tornado.curl_httpclient.CurlAsyncHTTPClient")
        self.http = AsyncHTTPClient()

    @coroutine
    def get(self, url):
        #tornado会自动在请求首部带上host首部
        request = HTTPRequest(url=url,
                            method=\'GET\',
                            headers=HEADERS,
                            connect_timeout=2.0,
                            request_timeout=2.0,
                            follow_redirects=False,
                            max_redirects=False,
                            user_agent="Mozilla/5.0+(Windows+NT+6.2;+WOW64)+AppleWebKit/537.36+\\
                            (KHTML,+like+Gecko)+Chrome/45.0.2454.101+Safari/537.36",)
        yield self.http.fetch(request, callback=self.find, raise_error=False)

    def find(self, response):
        if response.error:
            print(response.error)
        print(response.code, response.effective_url, response.request_time)


class Download(object):

    def __init__(self):
        self.a = MyClass()
        self.urls = URLS

    @coroutine
    def d(self):
        print(u\'基于tornado的并发抓取\')
        starttime = time.time()
        yield [self.a.get(url) for url in self.urls]
        endtime=time.time()
        print(endtime-starttime)

if __name__ == \'__main__\':
    dd = Download()
    loop = IOLoop.current()
    loop.run_sync(dd.d)

抓取的时间如下:

可以看到总共花费了128087秒,而这所花费的时间恰恰就是最后一个url抓取所需要的时间,tornado中自带了查看每个请求的相应时间。我们可以从图中看到,最后一个url抓取总共花了1.28087秒,相较于其他时间大大的增加,这也是导致我们消耗时间过长的原因。那可以推断出,前面的并发抓取,也在这个url上花费了较多的时间。

总结:
以上测试其实非常的不严谨,因为我们选取的url的数量太少了,完全不能反映每一种抓取方式的优劣。如果有一万个不同的url同时抓取,那么记下总抓取时间,是可以得出一个较为客观的结果的。
并且,已经有人测试过,多线程抓取的效率是远不如gevent的。所以,如果你使用的是python2,那么我推荐你使用gevent进行并发抓取;如果你使用的是python3,我推荐你使用tornado的http客户端结合coroutine进行并发抓取。从上面的结果来看,tornado的coroutine是高于gevent的轻量级的协程的。但具体结果怎样,我没测试过。

 

以上是关于python实现并发爬虫的主要内容,如果未能解决你的问题,请参考以下文章

python实现并发爬虫

scrapy主动退出爬虫的代码片段(python3)

golang 并发爬虫

Python多线程并发通用模板

Python爬虫实战-基于代理池的高并发爬虫

饮冰三年-人工智能-Python-38 爬虫之并发