zoukankan      html  css  js  c++  java

  • 网络爬虫之scrapy框架详解,scrapy框架设置代理

    网络爬虫之scrapy框架详解

     

    twisted介绍

    Twisted是用Python实现的基于事件驱动的网络引擎框架，scrapy正是依赖于twisted，

    它是基于事件循环的异步非阻塞网络框架，可以实现爬虫的并发。

    twisted是什么以及和requests的区别：

    1. request是一个python实现的可以伪造浏览器发送Http请求的模块，它封装了socket发送请求
    2. twisted是基于时间循环的异步非阻塞的网络框架，它也封装了socket发送请求，但是他可以单线程的完成并发请求。

    twisted的特点是：

    • 非阻塞：不等待
    • 异步：回调
    • 事件循环：一直循环去检查状态

    scrapy的pipeline文件和items文件

    这两个文件有什么作用

    先看看我们上篇的示例：

    　　在这个示例中，虽然我们已经通过chouti.py一个文件中的parse方法实现了爬去抽屉网的新闻并将之保存在文件中的功能，

    但是我们会发现有两个问题：

    1、在循环爬去每一页的时候，每次都需要重新打开然后再关闭文件，如果数据量庞大的话，这对性能有很大的影响。

    2、我们将解析和数据持久化都放在了同一个文件的同一个方法中，没有做到分工明确

    如果要解决这两个问题，则需要用到scrapy自动为我们生成的pipeline文件和items文件

    这两个文件怎么用

    如果我们要使用这两个文件从而解决问题，则需要有四部操作：

    a.编写pipeline文件中的类，格式如下：

    1
    2
    3
    class XXXPipeline(object):
        def process_item(self, item, spider):
            return item

    b.编写items文件中的类，格式如下：

    1
    2
    3
    class XXXItem(scrapy.Item):
        href = scrapy.Field()
        title = scrapy.Field()

    c.配置settings文件

    1
    2
    3
    4
    ITEM_PIPELINES = {
       'xxx.pipelines.XXXPipeline': 300,
       # 'xxx.pipelines.XXXPipeline2': 600,  # 后面的数字为优先级，数字越大，优先级月底
    }

    d.在parse方法中yield一个Item对象

    1
    2
    3
    4
    5
    from xxx.items import XXXItem
     
    def parse(self, response):
        ...
        yield XXXItem(text=text,href=href)

    执行流程为：

    当我们在执行爬虫中的parse方法的时候，scrapy一旦解析到有yield XXXitem的语句，就会到配置文件中找

    ITEM_PIPELINES的配置项，进而找到XXXPipeline类，然后执行其中的方法，我们就可以在方法中做很多操作

    当然，pipeline中不止process_item一个方法。

    Pipeline中的方法详解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    class FilePipeline(object):
     
        def __init__(self,path):
            self.f = None
            self.path = path
     
        @classmethod
        def from_crawler(cls, crawler):
            """
            初始化时候，用于创建pipeline对象
            :param crawler:
            :return:
            """
                    # 从配置文件中获取配置好的文件存放目录
            path = crawler.settings.get('HREF_FILE_PATH')
            return cls(path)
     
        def open_spider(self,spider):
            """
            爬虫开始执行时，调用
            :param spider:
            :return:
            """
            self.f = open(self.path,'a+')
     
        def process_item(self, item, spider):
            # 在这里做持久化
            self.f.write(item['href']+' ')
            return item     # 交给下一个pipeline的process_item方法
            # raise DropItem()# 如果写上这一句，后续的 pipeline的process_item方法不再执行
     
        def close_spider(self,spider):
            """
            爬虫关闭时，被调用
            :param spider:
            :return:
            """
            self.f.close()

    去重

    scrapy内部实现的去重

    从上一篇的例子我们可以看出，其实scrapy内部在循环爬去页码的时候，已经帮我们做了去重功能的，

    因为我们在首页可以看到1,2,3,4,5,6,7,8,9,10页的页码以及连接，当爬虫爬到第二页的时候，

    还是可以看到这10个页面及连接，然后它并没有再重新把第一页爬一遍。

    它内部实现去重的原理是，将已爬去的网址存入一个set集合里，每次爬取新页面的时候就先看一下是否在集合里面

    如果在，就不再爬去，如果不在就爬取，然后再添加入到set里。当然，这个集合存放的不是原网址，

    而是将链接通过request_fingerprint()方法将它变成一个类似于md5的值，这样可以节省存储空间

    自定义去重

    虽然scrapy已经帮我们实现了去重，但是有时候不足以满足我们的需求，这样就需要我们自定义去重了

    自定义去重分两步

    1、编写DupeFilter类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    from scrapy.dupefilter import BaseDupeFilter
    from scrapy.utils.request import request_fingerprint
     
    class XXXDupeFilter(BaseDupeFilter):
     
        def __init__(self):
            '''初始化一个集合，用来存放爬去过的网址'''
            self.visited_fd = set()
     
        @classmethod
        def from_settings(cls, settings):
            '''
            如果我们自定义了DupeFilter类并且重写了父类的该方法，
            scrapy会首先执行该方法，获取DupeFilter对象，
            如果没有定义，则会执行init方法来获取对象
            '''
            return cls()
     
        def request_seen(self, request):
            '''在此方法中做操作，判断以及添加网址到set里'''
            # 将request里的url转换下，然后判断是否在set里
            fd = request_fingerprint(request=request)
            # 循环set集合，如果已经在集合里，则返回True，爬虫将不会继续爬取该网址
            if fd in self.visited_fd:
                return True
            self.visited_fd.add(fd)
     
        def open(self):  # can return deferred
            '''开始前执行此方法'''
            print('开始')
     
        def close(self, reason):  # can return a deferred
            '''结束后执行此方法'''
            print('结束')
     
        def log(self, request, spider):  # log that a request has been filtered
            '''在此方法中可以做日志操作'''
            print('日志')

    2.配置settings文件

    1
    2
    3
    # 修改默认的去重规则
    # DUPEFILTER_CLASS = 'scrapy.dupefilter.RFPDupeFilter'
    DUPEFILTER_CLASS = 'xxx.dupefilters.XXXDupeFilter'

    深度

    深度就是爬虫所要爬取的层级

    限制深度只需要配置一下即可

    1
    2
    # 限制深度
    DEPTH_LIMIT = 3

    cookie

    获取上一次请求之后获得的cookie

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    from scrapy.http.cookies import CookieJar
     
    class ChoutiSpider(scrapy.Spider):
        name = 'chouti'
        allowed_domains = ['chouti.com']
        start_urls = ['https://dig.chouti.com/']
        cookie_dict = {}
        def parse(self, response):
     
            # 去响应头中获取cookie，cookie保存在cookie_jar对象
            cookie_jar = CookieJar()
            cookie_jar.extract_cookies(response, response.request)
     
            # 去对象中将cookie解析到字典
            for k, v in cookie_jar._cookies.items():
                for i, j in v.items():
                    for m, n in j.items():
                        self.cookie_dict[m] = n.value

    再次请求的时候携带cookie

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    yield Request(
               url='https://dig.chouti.com/login',
               method='POST',
               body="phone=861300000000&password=12345678&oneMonth=1",#
               cookies=self.cookie_dict,
               headers={
                   'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
               },
               callback=self.check_login
           )

    　　

    是不是感觉很麻烦？

    那么，呵呵，其实，嘿嘿，

    你只需要在Request对象的参数中加入 meta={'cookiejar': True} 即可！

    网络爬虫之scrapy框架设置代理

     

    前戏

    os.environ()简介

    os.environ()可以获取到当前进程的环境变量，注意，是当前进程。

    如果我们在一个程序中设置了环境变量，另一个程序是无法获取设置的那个变量的。

    环境变量是以一个字典的形式存在的，可以用字典的方法来取值或者设置值。

    os.environ() key字段详解

    windows：

    1
    2
    3
    4
    5
    6
    os.environ['HOMEPATH']:当前用户主目录。
    os.environ['TEMP']:临时目录路径。
    os.environ[PATHEXT']:可执行文件。
    os.environ['SYSTEMROOT']:系统主目录。
    os.environ['LOGONSERVER']:机器名。
    os.environ['PROMPT']:设置提示符。

    linux：

    1
    2
    3
    4
    5
    os.environ['USER']:当前使用用户。
    os.environ['LC_COLLATE']:路径扩展的结果排序时的字母顺序。
    os.environ['SHELL']:使用shell的类型。
    os.environ['LAN']:使用的语言。
    os.environ['SSH_AUTH_SOCK']:ssh的执行路径。

    内置的方式

    原理

    scrapy框架内部已经实现了设置代理的方法，它的原理是从环境变量中取出设置的代理，然后再使用，

    所以我们只需要在程序执行前将代理以键值对的方式设置到环境变量中即可。

    代码

    第一种方式：直接添加键值对的方式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    class ChoutiSpider(scrapy.Spider):
        name = 'chouti'
        allowed_domains = ['chouti.com']
        start_urls = ['https://dig.chouti.com/']
        cookie_dict = {}
     
        def start_requests(self):
            import os
            os.environ['HTTPS_PROXY'] = "http://username:password@192.168.11.11:9999/"
            os.environ['HTTP_PROXY'] = '19.11.2.32',
            for url in self.start_urls:
                yield Request(url=url,callback=self.parse)

    第二种方式：设置meta参数的方式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    class ChoutiSpider(scrapy.Spider):
        name = 'chouti'
        allowed_domains = ['chouti.com']
        start_urls = ['https://dig.chouti.com/']
        cookie_dict = {}
     
        def start_requests(self):
            for url in self.start_urls:
                yield Request(url=url,callback=self.parse,meta={'proxy':'"http://username:password@192.168.11.11:9999/"'})

    自定义方式

    原理

    我们可以根据内部实现的添加代理的类（中间件）的实现方法，来对它进行升级，比如内部的方式一次只能使用一个代理，

    我们可以弄一个列表，装很多代理地址，然后随机选取一个代理，这样可以防止请求过多被封ip

    代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    class ChoutiSpider(scrapy.Spider):
        name = 'chouti'
        allowed_domains = ['chouti.com']
        start_urls = ['https://dig.chouti.com/']
        cookie_dict = {}
     
        def start_requests(self):
            for url in self.start_urls:
                yield Request(url=url,callback=self.parse,meta={'proxy':'"http://username:password@192.168.11.11:9999/"'})
     
                import base64
                import random
                from six.moves.urllib.parse import unquote
                try:
                    from urllib2 import _parse_proxy
                except ImportError:
                    from urllib.request import _parse_proxy
                from six.moves.urllib.parse import urlunparse
                from scrapy.utils.python import to_bytes
     
                class XXProxyMiddleware(object):
     
                    def _basic_auth_header(self, username, password):
                        user_pass = to_bytes(
                            '%s:%s' % (unquote(username), unquote(password)),
                            encoding='latin-1')
                        return base64.b64encode(user_pass).strip()
     
                    def process_request(self, request, spider):
                        PROXIES = [
                            "http://username:password@192.168.11.11:9999/",
                            "http://username:password@192.168.11.12:9999/",
                            "http://username:password@192.168.11.13:9999/",
                            "http://username:password@192.168.11.14:9999/",
                            "http://username:password@192.168.11.15:9999/",
                            "http://username:password@192.168.11.16:9999/",
                        ]
                        url = random.choice(PROXIES)
     
                        orig_type = ""
                        proxy_type, user, password, hostport = _parse_proxy(url)
                        proxy_url = urlunparse((proxy_type or orig_type, hostport, '', '', '', ''))
     
                        if user:
                            creds = self._basic_auth_header(user, password)
                        else:
                            creds = None
                        request.meta['proxy'] = proxy_url
                        if creds:
                            request.headers['Proxy-Authorization'] = b'Basic ' + creds

    写完类之后需要在settings文件里配置一下：

    1
    2
    3
    DOWNLOADER_MIDDLEWARES = {
       'spider.xxx.XXXProxyMiddleware': 543,
    }

    　　
  • 相关阅读:
    python之函数一
    python之字典
    分支与master切换 | MyEclipse git怎么提交代码
    gitignore的使用详细图解
    1.1（学习笔记）Servlet简介及一个简单的实例
    10.4（java学习笔记）CLOB，BLOB基本操作
    10.3（Java学习笔记）JDBC时间操作
    10.2（java学习笔记）JDBC事务简述
    10.1（java学习笔记）JDBC基本操作（连接，执行SQL语句，获取结果集）
    9.1（java学习笔记）正则表达式
  • 原文地址：https://www.cnblogs.com/xyhh/p/10860873.html
Copyright © 2011-2022 走看看