爬虫(一)网络爬虫/相关工具与知识

ゝ一世哀愁。 2022-05-23 05:06 303阅读 0赞

#### 网络爬虫 ####

网络爬虫(web crawler), 以前经常称为网络蜘蛛(spider), 是按照一定的规则自动浏览万维网并获取信息的机器人程序(或叫脚本), 曾经被广泛的应用于互联网搜索引擎. 使用过互联网和浏览器的人都知道, 网页中除了提供用户阅读的文字信息之外, 还包含一些超链接. 网络爬虫系统正是通过网页中的超链接信息不断获得网络上的其他页面. 正因为如此, 网络数据采集的过程就像一个爬虫或者蜘蛛在网络上漫游, 所有才被形象的称之为网络爬虫或者网络蜘蛛.

##### 爬虫的应用领域 #####

在理想的状态下, 所有的ICP(internet Content Provider) 都应该为自己的网络提供API接口来共享它们允许其他程序获取的数据, 在这种情况下爬虫就不是必需品, 国内比较有名的电商平台(如淘宝, 京东等), 社交平台(如QQ/微博/微信等)这些网站都提供了自己的Open Api, 但是这类Open Api通常会对可以抓取的数据频率进行限制. 对于大多数的公司而言, 计时的获取行业相关数据就是企业生存的重要环节之一, 然而大部分企业在行业数据方面的匮乏是其与生俱来的短板, 合理的利用爬虫来获取数据并从中提取出有价值的信息是至关重要的. 当然爬虫还有很多重要的应用灵玉, 以下列举了其中一部分.

1. 搜索引擎
    2. 新闻聚合
    3. 社交应用
    4. 舆情监控
    5. 行业数据

#### 合法性和背景调研 ####

##### 爬虫合法性探讨 #####

1.网络爬虫领域目前还属于拓荒阶段, 虽然互联网世界已经通过自己的游戏规则建立起一定的道德规范(Robots协议, 全称是'网络爬虫排除标准'), 但在法律部分还在建立和完善中, 也就是说, 现在这个领域暂时还是灰色地带.
    2. '法不禁止即为许可', 如果爬虫就像浏览器一样获取的是前端显示的数据(网页上的公开信息), 而不是网站后台的私密敏感信息, 就不太担心法律法规的约束, 因为目前大数据产业链的发展速度远远超过了法律的完善程度.
    3. 在爬取网站的时候, 需要限制自己的爬虫遵守Robots协议, 同时控制网络爬虫程序的抓取数据的速度, 在使用数据的时候, 必须要尊重网站的知识产权(从Web2.0时代开始, 虽然Web上的数据很多都是由用户提供的, 但是网站平台是投入了运营成本的, 当用户在注册和发布呢日用时, 平台通常就已经获取了对数据的所有权, 使用权和分发权). 如果违反了这些规定, 在打官司的时候败诉几率就非常高.

##### Rbots.txt文件 #####

大多数网站都会定义robots.txt文件, 下面以淘宝的robots.txt文件为例, 看看该网站对爬虫有哪些限制

User-agent:  Baiduspider
    Allow:  /article
    Allow:  /oshtml
    Disallow:  /product/
    Disallow:  /
    
    User-Agent:  Googlebot
    Allow:  /article
    Allow:  /oshtml
    Allow:  /product
    Allow:  /spu
    Allow:  /dianpu
    Allow:  /oversea
    Allow:  /list
    Disallow:  /
    
    User-agent:  Bingbot
    Allow:  /article
    Allow:  /oshtml
    Allow:  /product
    Allow:  /spu
    Allow:  /dianpu
    Allow:  /oversea
    Allow:  /list
    Disallow:  /
    
    User-Agent:  360Spider
    Allow:  /article
    Allow:  /oshtml
    Disallow:  /
    
    User-Agent:  Yisouspider
    Allow:  /article
    Allow:  /oshtml
    Disallow:  /
    
    User-Agent:  Sogouspider
    Allow:  /article
    Allow:  /oshtml
    Allow:  /product
    Disallow:  /
    
    User-Agent:  Yahoo!  Slurp
    Allow:  /product
    Allow:  /spu
    Allow:  /dianpu
    Allow:  /oversea
    Allow:  /list
    Disallow:  /
    
    User-Agent:  *
    Disallow:  /

注意上面robots.txt第一段的最后一行, 通过设置’Disallow:/’禁止百度爬虫访问除了’Allow’规定页面外的其他所有页面. 因此当你在百度搜索’淘宝’的时候, 搜索结果下方会出现: ‘由于该网站的rebots.txt文件存在限制指令(限制搜索引擎抓取). 系统无法提供该页面的内容描述.’, 百度作为一个搜索引擎, 至少在表面上遵守了淘宝网的robots.txt协议, 所以用户不能从百度上搜索到淘宝内部的产品信息.  
![这里写图片描述][70]

#### 相关工具介绍 ####

在开始讲解爬虫之前，我们稍微对HTTP（超文本传输协议）做一些回顾，因为我们在网页上看到的内容通常是浏览器执行HTML语言得到的结果，而HTTP就是传输HTML数据的协议。HTTP是构建于TCP（传输控制协议）之上应用级协议，它利用了TCP提供的可靠的传输服务实现了Web应用中的数据交换。按照维基百科上的介绍，设计HTTP最初的目的是为了提供一种发布和接收[HTML][]页面的方法，也就是说这个协议是浏览器和Web服务器之间传输的数据的载体。关于这个协议的详细信息以及目前的发展状况，大家可以阅读阮一峰老师的[《HTTP 协议入门》][HTTP]、[《互联网协议入门》][Link 1]系列以及[《图解HTTPS协议》][HTTPS]进行了解，下图是我在2009年9月10日凌晨4点在四川省网络通信技术重点实验室用开源协议分析工具Ethereal（抓包工具WireShark的前身）截取的访问百度首页时的HTTP请求和响应的报文（协议数据），由于Ethereal截取的是经过网络适配器的数据，因此可以清晰的看到从物理链路层到应用层的协议数据。

HTTP请求（请求行+请求头+空行+\[消息体\]）：

![这里写图片描述][70 1]

HTTP响应（响应行+响应头+空行+消息体）：  
![这里写图片描述][70 2]

##### 相关工具 #####

1.  Chrome Developer Tools
    
    开发推荐使用谷歌浏览器, 这是谷歌的开发者工具
2.  POSTMAN(邮差)  
    ![这里写图片描述][70 3]
3.  HTTPie
    
        $ http --header http://www.scu.edu.cn
        HTTP/1.1 200 OK
        Accept-Ranges: bytes
        Cache-Control: private, max-age=600
        Connection: Keep-Alive
        Content-Encoding: gzip
        Content-Language: zh-CN
        Content-Length: 14403
        Content-Type: text/html
        Date: Sun, 27 May 2018 15:38:25 GMT
        ETag: "e6ec-56d3032d70a32-gzip"
        Expires: Sun, 27 May 2018 15:48:25 GMT
        Keep-Alive: timeout=5, max=100
        Last-Modified: Sun, 27 May 2018 13:44:22 GMT
        Server: VWebServer
        Vary: User-Agent,Accept-Encoding
        X-Frame-Options: SAMEORIGIN
4.  BuiltWith(python自带的模块): 识别网站使用的技术
    
        >>>
        >>> import builtwith
        >>> builtwith.parse('http://www.bootcss.com/')
        {'web-servers': ['Nginx'], 'font-scripts': ['Font Awesome'], 'javascript-frameworks': ['Lo-dash', 'Underscore.js', 'Vue.js', 'Zepto', 'jQuery'], 'web-frameworks': ['Twitter Bootstrap']}
        
        >>>
        >>> import ssl
        >>> ssl._create_default_https_context = ssl._create_unverified_context
        >>> builtwith.parse('https://www.jianshu.com/')
        {'web-servers': ['Tengine'], 'web-frameworks': ['Twitter Bootstrap', 'Ruby on Rails'], 'programming-languages': ['Ruby']}
5.  python-whois(python自带的模块): 查询网站的所有者  
    ![这里写图片描述][70 4]
6.  robotparser: 解析robots.txt的工具

>>> from urllib import robotparser
    >>> parser = robotparser.RobotFileParser()
    >>> parser.set_url('https://www.taobao.com/robots.txt')
    >>> parser.read()
    >>> parser.can_fetch('Hellokitty', 'http://www.taobao.com/article')
    False
    >>> parser.can_fetch('Baiduspider', 'http://www.taobao.com/article')
    True
    >>> parser.can_fetch('Baiduspider', 'http://www.taobao.com/product')
    False

#### 一个简单的爬虫 ####

一个基本的爬虫通常分为数据采集(网页下载), 数据处理(网页解析)和数据存储(将有用的信息持久化) 三个部分的内容, 当然更为高级的爬虫在数据采集和处理时会使用并发编程或分布式技术, 其中可能还包括调度器和后台管理程序(监控爬虫的工作状态以及检查数据爬取的结果)  
![这里写图片描述][70 5]

1.  设定抓取目标(种子页面)并获取网页.
2.  当服务器无法访问时, 设置重试次数.
3.  在需要的时候设置用户代理(否则无法访问页面)
4.  对获取的页面进行必要的解码操作
5.  通过正则表达式获取页面中的链接
6.  对链接进行进一步的处理(获取页面并重复上面的操作)
7.  将有用的信息进行持久化(以备后续的处理)

###### 设置包装类进行重试次数 ######

class Retry(object):
    
        def __init__(self, *, retry_times=3, wait_secs=5, errors=(Exception,)):
            self.retry_times = retry_times
            self.wait_secs = wait_secs
            self.errors = errors
    
        def __call__(self, fn):
    
            def wrapper(*args, **kwargs):
    
                try:
                    return fn(*args, **kwargs)
                except self.errors as e:
                    logging.error(e)
                    sleep((random() + 1) * self.wait_secs)
    
            return wrapper
    
    
    class Spider(object):
    
        def __init__(self):
            self.status = SpiderStatus.IDEL
    
        @Retry()
        def fetch(self, current_url, *, user_agent=None, proxies=None, charsets=('utf-8',)):
            thread_name = current_thread().name
            print(f'[{thread_name}:{current_url}]')
            headers = {
       'user-agent':user_agent} if user_agent else {}
            resp = requests.get(current_url, headers=headers, proxies=proxies)
            return decode_page(resp.content, charsets=charsets) if resp.status_code == 200 else None

###### 3 设置代理,隐藏真实身份 ######

# 实例1：
       def get_html(url):
           # 这里我们给url请求，伪装了一个请求头，表示我是一个浏览器(也可以伪装成移动端)
           resp = requests.get(url,headers={
           'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 10_3 like Mac OS X) AppleWebKit/602.1.50 (KHTML, like Gecko) CriOS/56.0.2924.75 Mobile/14E5239e Safari/602.1'})
           return resp
     #实例2：
     def get_html(url):
         # 这里我们的url请求，伪装成百度的爬虫
         resp = requests.get(url,headers={
         'user-agent': 'Baiduspider'})
         return resp
    
     #实例3：
     def main():
         这里我使用了代理的IP，隐藏了自己的真实ip
         headers = {
       'user-agent': 'Baiduspider'}
         # 隐藏自己的身份IP
         proxies = {
             # 代理IP 'http': '36.22.76.233:35390',
             'http': '61.135.217.7:80'
         }
         base_url = 'https://www.zhihu.com'
         seed_url = urljoin(base_url, 'explore')
    
         resp = requests.get(seed_url, headers=headers, proxies=proxies)

> 常见的伪装 ‘user-agent’：  
> 1.Android  
> \* Mozilla/5.0 (Linux; Android 4.1.1; Nexus 7 Build/JRO03D) AppleWebKit/535.19 (KHTML, like Gecko) Chrome/18.0.1025.166 Safari/535.19  
> \* Mozilla/5.0 (Linux; U; Android 4.0.4; en-gb; GT-I9300 Build/IMM76D) \* \* \* AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30  
> \* Mozilla/5.0 (Linux; U; Android 2.2; en-gb; GT-P1000 Build/FROYO) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1  
> 2.Firefox  
> \* Mozilla/5.0 (Windows NT 6.2; WOW64; rv:21.0) Gecko/20100101 Firefox/21.0  
> \* Mozilla/5.0 (Android; Mobile; rv:14.0) Gecko/14.0 Firefox/14.0  
> 3.Google Chrome  
> \* Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/27.0.1453.94 Safari/537.36  
> \* Mozilla/5.0 (Linux; Android 4.0.4; Galaxy Nexus Build/IMM76B) AppleWebKit/535.19 (KHTML, like Gecko) Chrome/18.0.1025.133 Mobile Safari/535.19  
> 4.iOS  
> \* Mozilla/5.0 (iPad; CPU OS 5\_0 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9A334 Safari/7534.48.3  
> \* Mozilla/5.0 (iPod; U; CPU like Mac OS X; en) AppleWebKit/420.1 (KHTML, like Gecko) Version/3.0 Mobile/3A101a Safari/419.3

###### 4 - 6解码/正则匹配内容/bs4抓取数据/持久化存储 ######

from urllib.error import URLError
    from urllib.request import urlopen
    
    import re
    import pymysql
    import ssl
    
    from pymysql import Error
    
    
    # 通过指定的字符集对页面进行解码(不是每个网站都将字符集设置为utf-8)
    def decode_page(page_bytes, charsets=('utf-8',)):
        page_html = None
        for charset in charsets:
            try:
                page_html = page_bytes.decode(charset)
                break
            except UnicodeDecodeError:
                pass
                # logging.error('Decode:', error)
        return page_html
    
    
    # 获取页面的HTML代码(通过递归实现指定次数的重试操作)
    def get_page_html(seed_url, *, retry_times=3, charsets=('utf-8',)):
        page_html = None
        try:
            page_html = decode_page(urlopen(seed_url).read(), charsets)
        except URLError:
            # logging.error('URL:', error)
            if retry_times > 0:
                return get_page_html(seed_url, retry_times=retry_times - 1,
                                     charsets=charsets)
        return page_html
    
    
    # 从页面中提取需要的部分(通常是链接也可以通过正则表达式进行指定)
    def get_matched_parts(page_html, pattern_str, pattern_ignore_case=re.I):
        pattern_regex = re.compile(pattern_str, pattern_ignore_case)
        return pattern_regex.findall(page_html) if page_html else []
    
    
    # 开始执行爬虫程序并对指定的数据进行持久化操作
    def start_crawl(seed_url, match_pattern, *, max_depth=-1):
        conn = pymysql.connect(host='localhost', port=3306,
                               database='crawler', user='root',
                               password='123456', charset='utf8')
        try:
            with conn.cursor() as cursor:
                url_list = [seed_url]
                # 通过下面的字典避免重复抓取并控制抓取深度
                visited_url_list = {seed_url: 0}
                while url_list:
                    current_url = url_list.pop(0)
                    depth = visited_url_list[current_url]
                    if depth != max_depth:
                        page_html = get_page_html(current_url, charsets=('utf-8', 'gbk', 'gb2312'))
                        links_list = get_matched_parts(page_html, match_pattern)
                        param_list = []
                        for link in links_list:
                            if link not in visited_url_list:
                                visited_url_list[link] = depth + 1
                                page_html = get_page_html(link, charsets=('utf-8', 'gbk', 'gb2312'))
                                headings = get_matched_parts(page_html, r'<h1>(.*)<span')
                                if headings:
                                    param_list.append((headings[0], link))
                        cursor.executemany('insert into tb_result values (default, %s, %s)',
                                           param_list)
                        conn.commit()
        except Error:
            pass
            # logging.error('SQL:', error)
        finally:
            conn.close()
    
    
    def main():
        ssl._create_default_https_context = ssl._create_unverified_context
        start_crawl('http://sports.sohu.com/nba_a.shtml',
                    r'<a[^>]+test=a\s[^>]*href=["\'](.*?)["\']',
                    max_depth=2)
    
    
    if __name__ == '__main__':
        main()

注意事项:  
1. 处理相对链接. 有的时候我们从页面中获取的链接不是一个完整的绝对链接而是一个相对链接. 在这种情况下需要将其与URL前缀进行拼接(urllib,parse中的urljoin函数可以完成此项操作).  
2. 设置dialing服务. 有些网站会限制访问的区域(例如美国的Netfix屏蔽了很多国家的访问), 有些爬虫需要隐藏自己的身份, 在这种情况下可以设置代理服务器(urllib.request中的ProxyHandler就是用来进行此项操作)  
3. 限制下载速度. 如果我们的爬虫获取页面的速度过快, 可能就会面临被封禁或者产生’损害动产’的风险(这个可能会导致吃官司且败诉), 可以在两次下载之间添加延时从而对爬虫进行限速.  
4. 避免爬虫陷阱. 有些网站会动态生成页面内容, 这回导致产生无限多的页面(例如在线万年历等), 可以通过记录到达当前页面经过了多少个链接(链接深度) 来解决该问题, 当达到实现设定的最大深度时爬虫就不再想队列中添加该网页中的链接了.  
5. SSL相关问题, 在使用urlopen打开一个HTPPS连接时会验证一次SSL整数, 如果不作出处理会产生错误提示”SSL:CERTIFICATE\_VERIFY\_FAILED”, 可以通过以下两种方式进行解决:

*  使用未经验证的上下文
    
        import ssl
        
        request = urllib.request.Request(url='...', headers={...}) 
        context = ssl._create_unverified_context()
        web_page = urllib.request.urlopen(request, context=context
 *  设置全局的取消证书验证
    
        import ssl
        ssl._create_default_https_context = ssl._create_unverified_context

[70]: /images/20220523/5d8c5b8a553d4a6490fa67d3e9a6ed7d.png
[HTML]: https://zh.wikipedia.org/wiki/HTML
[HTTP]: http://www.ruanyifeng.com/blog/2016/08/http.html
[Link 1]: http://www.ruanyifeng.com/blog/2012/05/internet_protocol_suite_part_i.html
[HTTPS]: http://www.ruanyifeng.com/blog/2014/09/illustration-ssl.html
[70 1]: /images/20220523/441192b6fd384efb9d80d329b60a4508.png
[70 2]: /images/20220523/c010ea8e49524fd181a4b1f9ff4cffd4.png
[70 3]: /images/20220523/f7dc5dd9124c4476aa09575a16ab3f08.png
[70 4]: /images/20220523/729de3f0b2e945dab828893512d122bf.png
[70 5]: /images/20220523/ff7aac8a90a743bf8a883eaf239126a9.png