数据之路 - Python爬虫 - Scrapy框架

约定不等于承诺〃 2023-06-02 10:59 45阅读 0赞

转载：[https://scrapy.readthedocs.io/en/latest/index.html][https_scrapy.readthedocs.io_en_latest_index.html]

# 一、Scrapy框架介绍 #

Scrapy是一个基于Twisted的异步处理框架，是纯Python实现的爬虫框架，其架构清晰，榄块之间的榈合程度低，可扩展性极强，可以灵活完成各种需求。

*  Engine：引擎,处理整个系统的数据流处理、触发事务,是整个框架的核心。
 *  Item：项目,它定义了爬取结果的数据结构,爬取的数据会被赋值成该Item对象。
 *  Scheduler：调度器,接受引擎发过来的请求并将其加入队列中, 在引擎再次请求的时候将请求提供给引擎。
 *  Downloader：下载器,下载网页内容,并将网页内容返回给蜘蛛。
 *  Spiders：蜘蛛,其内定义了爬取的逻辑和网页的解析规则,它主要负责解析响应并生成提取结果和新的请求。
 *  Item Pipeline：项目管道,负责处理由蜘蛛从网页中抽取的项目,它的主要任务是清洗、验证和存储数据。
 *  Downloader Middlewares：下载器中间件,位于引擎和下载器之间的钩子框架,主要处理引擎与下载器之间的请求及响应。
 *  Spider Middlewares：蜘蛛中间件,位于引擎和蜘蛛之间的钩子框架,主要处理蜘蛛输入的响应和输出的结果及新的请求。

![1489220-20190629214307782-1418567979.png][]

**Scrapy中的数据流由引擎控制，数据流的过程如下：**

1.  Engine首先打开一个网站，找到处理该网站的Spider，并向该Spider请求第一个要爬取的URL。
2.  Engine从Spider中获取到第一个要爬取的URL，并通过Scheduler以Request 的形式调度。
3.  Engine向Scheduler请求下一个要爬取的URL。
4.  Scheduler返回下一个要爬取的URL给Engine, Engine将URL通过DownloaderMiddJewares转发给Downloader下载。
5.  一旦页面下载完毕，Downloader生成该页面的Response，并将其通过DownloaderMiddlewares发送给Engine。
6.  Engine从下载器中接收到l Response，并将其通过SpiderMiddlewares发送给Spider处理。
7.  Spider处理Response，并返回爬取到的Item及新的Request给Engine。
8.  Engine将Spider返回的Item给ItemPipeline，将新的Request给Scheduler。
9.  重复第 2 步到第 8 步，直到Scheduler中没有更多的Request, Engine关闭该网站，爬取结束。

**Scrapy运作流程：**

*  引擎：Hi！Spider, 你要处理哪一个网站？
 *  Spider：老大要我处理xxxx.com。
 *  引擎：你把第一个需要处理的URL给我吧。
 *  Spider：给你，第一个URL是xxxxxxx.com。
 *  引擎：Hi！调度器，我这有request请求你帮我排序入队一下。
 *  调度器：好的，正在处理你等一下。
 *  引擎：Hi！调度器，把你处理好的request请求给我。
 *  调度器：给你，这是我处理好的request
 *  引擎：Hi！下载器，你按照老大的下载中间件的设置帮我下载一下这个request请求
 *  下载器：好的！给你，这是下载好的东西。（如果失败：sorry，这个request下载失败了。然后引擎告诉调度器，这个request下载失败了，你记录一下，我们待会儿再下载）
 *  引擎：Hi！Spider，这是下载好的东西，并且已经按照老大的下载中间件处理过了，你自己处理一下（注意！这儿responses默认是交给def parse()这个函数处理的）
 *  Spider：（处理完毕数据之后对于需要跟进的URL），Hi！引擎，我这里有两个结果，这个是我需要跟进的URL，还有这个是我获取到的Item数据。
 *  引擎：Hi ！管道 我这儿有个item你帮我处理一下！调度器！这是需要跟进URL你帮我处理下。然后从第四步开始循环，直到获取完老大需要全部信息。
 *  管道\`\`调度器：好的，现在就做！
 *  注意！只有当调度器中不存在任何request了，整个程序才会停止，（也就是说，对于下载失败的URL，Scrapy也会重新下载。）

**Scrapy爬虫共需要4步：**

*  新建项目 (scrapy startproject xxx)：新建一个新的爬虫项目
 *  明确目标 （编写items.py）：明确你想要抓取的目标
 *  制作爬虫 （spiders/xxspider.py）：制作爬虫开始爬取网页
 *  存储内容 （pipelines.py）：设计管道存储爬取内容

# 二、Scrapy入门案例 #

## 1.创建项目 ##

执行命令：
    scrapy startproject mySpider
    
    创建目录：
    mySpider/
        mySpider/               # 项目目录
            __init__.py
            items.py            # Item对象文件：用于统一结构化结果数据
            pipelines.py        # 管线文件：用于输出数据
            settings.py         # 配置文件：用于配置Scrapy
            middlewares.py      # 中间件文件：用于定制Scrapy框架
            spiders/            # Spider文件：用于解析数据
                __init__.py
                ...
        scrapy.cfg              # 项目配置文件：主要是换settings

## 2.明确目标 ##

Item 是保存爬取到的数据的容器；其使用方法和python字典类似。

打开mySpider目录下的items.py，Item 定义结构化数据字段，用来保存爬取到的数据，创建一个ItcastItem 类，和构建item模型

import scrapy
    
    class ItcastItem(scrapy.Item):
        name = scrapy.Field()
        level = scrapy.Field()
        info = scrapy.Field()

## 3.定义Spider ##

### \- 爬数据 ###

在`mySpider/spider`目录下创建一个名为`itcast`的爬虫，并指定爬取域的范围：*`scrapy genspider itcast "itcast.cn"`*

import scrapy
    
    class ItcastSpider(scrapy.Spider):
        name = "itcast"
        allowed_domains = ["itcast.cn"]
        start_urls = (
            'http://www.itcast.cn/',
        )
    
        def parse(self, response):
            pass

### \- 取数据 ###

**Selector有四个基本的方法：**

*  xpath() \# 传入xpath表达式，返回该表达式所对应的所有节点的selector list列表 。    
 *  css() \# 传入CSS表达式，返回该表达式所对应的所有节点的selector list列表。
 *  extract() \# 序列化该节点为unicode字符串并返回list。
 *  re() \# 根据传入的正则表达式对数据进行提取，返回unicode字符串list列表。

from mySpider.items import ItcastItem
    
    def parse(self, response):
        #open("teacher.html","wb").write(response.body).close()
    
        # 存放老师信息的集合
        items = []
    
        for each in response.xpath("//div[@class='li_txt']"):
            # 将我们得到的数据封装到一个 `ItcastItem` 对象
            item = ItcastItem()
            #extract()方法返回的都是unicode字符串
            name = each.xpath("h3/text()").extract()
            title = each.xpath("h4/text()").extract()
            info = each.xpath("p/text()").extract()
    
            #xpath返回的是包含一个元素的列表
            item['name'] = name[0]
            item['title'] = title[0]
            item['info'] = info[0]
    
            items.append(item)
    
        # 直接返回最后数据
        return items

### \- 存数据 ###

scrapy保存信息的最简单的方法主要有四种，-o 输出指定格式的文件，命令如下：

# json格式，默认为Unicode编码
    scrapy crawl itcast -o teachers.json
    
    # json lines格式，默认为Unicode编码
    scrapy crawl itcast -o teachers.jsonl
    
    # csv 逗号表达式，可用Excel打开
    scrapy crawl itcast -o teachers.csv
    
    # xml格式
    scrapy crawl itcast -o teachers.xml

# 三、Scrapy模块介绍 #

## 1.Items ##

Item 对象是种简单的容器，保存了爬取到得数据。其提供了类似于词典(dictionary-like)的API以及用于声明可用字段的简单语法。Item声明如下：

import scrapy
    
    class Product(scrapy.Item):
        name = scrapy.Field()
        price = scrapy.Field()
        stock = scrapy.Field()
        last_updated = scrapy.Field(serializer=str)

## 2.Selectors ##

进入项目的根目录，执行下列命令来启动shell: scrapy shell "http://www.itcast.cn/channel/teacher.shtml"

Selector有四个基本的方法，最常用的还是xpath:

>  *  xpath(): 传入xpath表达式，返回该表达式所对应的所有节点的selector list列表
>  *  extract(): 序列化该节点为Unicode字符串并返回list
>  *  css(): 传入CSS表达式，返回该表达式所对应的所有节点的selector list列表，语法同 BeautifulSoup4
>  *  re(): 根据传入的正则表达式对数据进行提取，返回Unicode字符串list列表

## 3.Item Pipeline ##

当Item在Spider中被收集之后，它将会被传递到Item Pipeline，这些Item Pipeline组件按定义的顺序处理Item。

每个Item Pipeline都是实现了简单方法的Python类，比如决定此Item是丢弃而存储。以下是item pipeline的一些典型应用：

*  验证爬取的数据(检查item包含某些字段，比如说name字段)
 *  查重(并丢弃)
 *  将爬取结果保存到文件或者数据库中

### 编写item pipeline ###

编写item pipeline很简单，item pipiline组件是一个独立的Python类，其中process\_item()方法必须实现:

import something
    
    class SomethingPipeline(object):
        def __init__(self):    
            # 可选实现，做参数初始化等
            # doing something
    
        def process_item(self, item, spider):
            # item (Item 对象) – 被爬取的item
            # spider (Spider 对象) – 爬取该item的spider
            # 这个方法必须实现，每个item pipeline组件都需要调用该方法，
            # 这个方法必须返回一个 Item 对象，被丢弃的item将不会被之后的pipeline组件所处理。
            return item
    
        def open_spider(self, spider):
            # spider (Spider 对象) – 被开启的spider
            # 可选实现，当spider被开启时，这个方法被调用。
    
        def close_spider(self, spider):
            # spider (Spider 对象) – 被关闭的spider
            # 可选实现，当spider被关闭时，这个方法被调用

### item写入JSON文件 ###

以下pipeline将所有(从所有'spider'中)爬取到的item，存储到一个独立地items.json 文件，每行包含一个序列化为'JSON'格式的'item':

import json
    
    class ItcastJsonPipeline(object):
    
        def __init__(self):
            self.file = open('teacher.json', 'wb')
    
        def process_item(self, item, spider):
            content = json.dumps(dict(item), ensure_ascii=False) + "\n"
            self.file.write(content)
            return item
    
        def close_spider(self, spider):
            self.file.close()

### 启用一个Item Pipeline组件 ###

为了启用Item Pipeline组件，必须将它的类添加到 settings.py文件ITEM\_PIPELINES 配置，就像下面这个例子:

# Configure item pipelines
    # See http://scrapy.readthedocs.org/en/latest/topics/item-pipeline.html
    ITEM_PIPELINES = {
        #'mySpider.pipelines.SomePipeline': 300,
        "mySpider.pipelines.ItcastJsonPipeline":300
    }

分配给每个类的整型值，确定了他们运行的顺序，item按数字从低到高的顺序，通过pipeline，通常将这些数字定义在0-1000范围内（0-1000随意设置，数值越低，组件的优先级越高）

## 4.Spider ##

Spider类定义了如何爬取某个(或某些)网站。包括了爬取的动作以及如何从网页的内容中提取结构化数据(爬取item)。

`class scrapy.Spider`是最基本的类，所有编写的爬虫必须继承这个类。

主要用到的函数及调用顺序为：

*  `__init__()` : 初始化爬虫名字和start\_urls列表
 *  `start_requests() 调用make_requests_from url()`:生成Requests对象交给Scrapy下载并返回response
 *  `parse()` : 解析response，并返回Item或Requests（需指定回调函数）。Item传给Item pipline持久化 ， 而Requests交由Scrapy下载，并由指定的回调函数处理（默认parse())，一直进行循环，直到处理完所有的数据为止。

#所有爬虫的基类，用户定义的爬虫必须从这个类继承
    class Spider(object_ref):
    
        #定义spider名字的字符串(string)。spider的名字定义了Scrapy如何定位(并初始化)spider，所以其必须是唯一的。
        #name是spider最重要的属性，而且是必须的。
        #一般做法是以该网站(domain)(加或不加 后缀 )来命名spider。 例如，如果spider爬取 mywebsite.com ，该spider通常会被命名为 mywebsite
        name = None
    
        #初始化，提取爬虫名字，start_ruls
        def __init__(self, name=None, **kwargs):
            if name is not None:
                self.name = name
            # 如果爬虫没有名字，中断后续操作则报错
            elif not getattr(self, 'name', None):
                raise ValueError("%s must have a name" % type(self).__name__)
    
            # python 对象或类型通过内置成员__dict__来存储成员信息
            self.__dict__.update(kwargs)
    
            #URL列表。当没有指定的URL时，spider将从该列表中开始进行爬取。 因此，第一个被获取到的页面的URL将是该列表之一。 后续的URL将会从获取到的数据中提取。
            if not hasattr(self, 'start_urls'):
                self.start_urls = []
    
        # 打印Scrapy执行后的log信息
        def log(self, message, level=log.DEBUG, **kw):
            log.msg(message, spider=self, level=level, **kw)
    
        # 判断对象object的属性是否存在，不存在做断言处理
        def set_crawler(self, crawler):
            assert not hasattr(self, '_crawler'), "Spider already bounded to %s" % crawler
            self._crawler = crawler
    
        @property
        def crawler(self):
            assert hasattr(self, '_crawler'), "Spider not bounded to any crawler"
            return self._crawler
    
        @property
        def settings(self):
            return self.crawler.settings
    
        #该方法将读取start_urls内的地址，并为每一个地址生成一个Request对象，交给Scrapy下载并返回Response
        #该方法仅调用一次
        def start_requests(self):
            for url in self.start_urls:
                yield self.make_requests_from_url(url)
    
        #start_requests()中调用，实际生成Request的函数。
        #Request对象默认的回调函数为parse()，提交的方式为get
        def make_requests_from_url(self, url):
            return Request(url, dont_filter=True)
    
        #默认的Request对象回调函数，处理返回的response。
        #生成Item或者Request对象。用户必须实现这个类
        def parse(self, response):
            raise NotImplementedError
    
        @classmethod
        def handles_request(cls, request):
            return url_is_from_spider(request.url, cls)
    
        def __str__(self):
            return "<%s %r at 0x%0x>" % (type(self).__name__, self.name, id(self))
    
        __repr__ = __str__

#### 主要属性和方法 ####

*  **name**

> 定义spider名字的字符串。例如，如果spider爬取 mywebsite.com ，该spider通常会被命名为 mywebsite

*  **allowed\_domains**

> 包含了spider允许爬取的域名(domain)的列表，可选。

*  **start\_urls**

> 初始URL元祖/列表。当没有制定特定的URL时，spider将从该列表中开始进行爬取。

*  **start\_requests(self)**

> 该方法必须返回一个可迭代对象(iterable)。该对象包含了spider用于爬取（默认实现是使用 start\_urls 的url）的第一个Request。
> 
> 当spider启动爬取并且未指定start\_urls时，该方法被调用。

*  **parse(self, response)**

> 当请求url返回网页没有指定回调函数时，默认的Request对象回调函数。用来处理网页返回的response，以及生成Item或者Request对象。

*  **log(self, message\[, level, component\])**

> 使用 scrapy.log.msg() 方法记录(log)message。

## 4.Crawl Spider ##

它是Spider的派生类，Spider类的设计原则是只爬取start\_url列表中的网页，而CrawlSpider类定义了一些规则(rule)来提供跟进link的方便的机制，从爬取的网页中获取link并继续爬取的工作更适合。

class CrawlSpider(Spider):
        rules = ()
        def __init__(self, *a, **kw):
            super(CrawlSpider, self).__init__(*a, **kw)
            self._compile_rules()
    
        #首先调用parse()来处理start_urls中返回的response对象
        #parse()则将这些response对象传递给了_parse_response()函数处理，并设置回调函数为parse_start_url()
        #设置了跟进标志位True
        #parse将返回item和跟进了的Request对象    
        def parse(self, response):
            return self._parse_response(response, self.parse_start_url, cb_kwargs={}, follow=True)
    
        #处理start_url中返回的response，需要重写
        def parse_start_url(self, response):
            return []
    
        def process_results(self, response, results):
            return results
    
        #从response中抽取符合任一用户定义'规则'的链接，并构造成Resquest对象返回
        def _requests_to_follow(self, response):
            if not isinstance(response, HtmlResponse):
                return
            seen = set()
            #抽取之内的所有链接，只要通过任意一个'规则'，即表示合法
            for n, rule in enumerate(self._rules):
                links = [l for l in rule.link_extractor.extract_links(response) if l not in seen]
                #使用用户指定的process_links处理每个连接
                if links and rule.process_links:
                    links = rule.process_links(links)
                #将链接加入seen集合，为每个链接生成Request对象，并设置回调函数为_repsonse_downloaded()
                for link in links:
                    seen.add(link)
                    #构造Request对象，并将Rule规则中定义的回调函数作为这个Request对象的回调函数
                    r = Request(url=link.url, callback=self._response_downloaded)
                    r.meta.update(rule=n, link_text=link.text)
                    #对每个Request调用process_request()函数。该函数默认为indentify，即不做任何处理，直接返回该Request.
                    yield rule.process_request(r)
    
        #处理通过rule提取出的连接，并返回item以及request
        def _response_downloaded(self, response):
            rule = self._rules[response.meta['rule']]
            return self._parse_response(response, rule.callback, rule.cb_kwargs, rule.follow)
    
        #解析response对象，会用callback解析处理他，并返回request或Item对象
        def _parse_response(self, response, callback, cb_kwargs, follow=True):
            #首先判断是否设置了回调函数。（该回调函数可能是rule中的解析函数，也可能是 parse_start_url函数）
            #如果设置了回调函数（parse_start_url()），那么首先用parse_start_url()处理response对象，
            #然后再交给process_results处理。返回cb_res的一个列表
            if callback:
                #如果是parse调用的，则会解析成Request对象
                #如果是rule callback，则会解析成Item
                cb_res = callback(response, **cb_kwargs) or ()
                cb_res = self.process_results(response, cb_res)
                for requests_or_item in iterate_spider_output(cb_res):
                    yield requests_or_item
    
            #如果需要跟进，那么使用定义的Rule规则提取并返回这些Request对象
            if follow and self._follow_links:
                #返回每个Request对象
                for request_or_item in self._requests_to_follow(response):
                    yield request_or_item
    
        def _compile_rules(self):
            def get_method(method):
                if callable(method):
                    return method
                elif isinstance(method, basestring):
                    return getattr(self, method, None)
    
            self._rules = [copy.copy(r) for r in self.rules]
            for rule in self._rules:
                rule.callback = get_method(rule.callback)
                rule.process_links = get_method(rule.process_links)
                rule.process_request = get_method(rule.process_request)
    
        def set_crawler(self, crawler):
            super(CrawlSpider, self).set_crawler(crawler)
            self._follow_links = crawler.settings.getbool('CRAWLSPIDER_FOLLOW_LINKS', True)

***CrawlSpider继承于Spider类，除了继承过来的属性外（name、allow\_domains），还提供了新的属性和方法:***

**- rules: 是Rule对象的集合，用于匹配目标网站并排除干扰。如果多个rule匹配了相同的链接，则根据规则在本集合中被定义的顺序，第一个会被使用。**

>     class scrapy.spiders.Rule(
>             link_extractor, 
>             callback = None, 
>             cb_kwargs = None, 
>             follow = None, 
>             process_links = None, 
>             process_request = None
>     )

*  **LinkExtractors**

> 其中的link\_extractor既可以自己定义，也可以使用已有LinkExtractor类，主要参数为：
> 
> Link Extractors 的目的很简单: 提取链接｡
> 
> 每个LinkExtractor有唯一的公共方法是 extract\_links()，它接收一个 Response 对象，并返回一个 scrapy.link.Link 对象。
> 
> Link Extractors要实例化一次，并且 extract\_links 方法会根据不同的 response 调用多次提取链接｡
> 
> --------------------
> 
>  
> 
>     class scrapy.linkextractors.LinkExtractor(
>     
>         allow = (),                 # 满足括号中“正则表达式”的值会被提取，如果为空，则全部匹配。
>         deny = (),                  # 与这个正则表达式(或正则表达式列表)不匹配的URL一定不提取。
>         allow_domains = (),         # 会被提取的链接的domains。
>         deny_domains = (),          # 一定不会被提取链接的domains。
>         deny_extensions = None,     # 
>         restrict_xpaths = (),       # 使用xpath表达式，和allow共同作用过滤链接。
>         tags = ('a','area'),
>         attrs = ('href'),
>         canonicalize = True,
>         unique = True,
>         process_value = None
>     )

*  **`callback`**：

> 从link\_extractor中每获取到链接时，参数所指定的值作为回调函数，该回调函数接受一个response作为其第一个参数。注意：当编写爬虫规则时，避免使用parse作为回调函数。由于CrawlSpider使用parse方法来实现其逻辑，如果覆盖了 parse方法，crawl spider将会运行失败。

*  **`follow`**：

> 是一个布尔(boolean)值，指定了根据该规则从response提取的链接是否需要跟进。 如果callback为None，follow 默认设置为True ，否则默认为False。

*  **`process_links`**：

> 指定该spider中哪个的函数将会被调用，从link\_extractor中获取到链接列表时将会调用该函数。该方法主要用来过滤。

*  **`process_request`**：

>  
> 
> 指定该spider中哪个的函数将会被调用， 该规则提取到每个request时都会调用该函数。 (用来过滤request)

- parse_start_url: 用于爬取起始响应，必须要返回Item，Request中的一个。

## **5.**Request / Response ##

### Request ###

# 部分代码
    class Request(object_ref):
    
        def __init__(self, url, callback=None, method='GET', headers=None, body=None, 
                     cookies=None, meta=None, encoding='utf-8', priority=0,
                     dont_filter=False, errback=None):
    
            self._encoding = encoding  # this one has to be set first
            self.method = str(method).upper()
            self._set_url(url)
            self._set_body(body)
            assert isinstance(priority, int), "Request priority not an integer: %r" % priority
            self.priority = priority
    
            assert callback or not errback, "Cannot use errback without a callback"
            self.callback = callback
            self.errback = errback
    
            self.cookies = cookies or {}
            self.headers = Headers(headers or {}, encoding=encoding)
            self.dont_filter = dont_filter
    
            self._meta = dict(meta) if meta else None
    
        @property
        def meta(self):
            if self._meta is None:
                self._meta = {}
            return self._meta

常用参数：

url: 就是需要请求，并进行下一步处理的url
    
    callback: 指定该请求返回的Response，由那个函数来处理。
    
    method: 请求一般不需要指定，默认GET方法，可设置为"GET", "POST", "PUT"等，且保证字符串大写
    
    headers: 请求时，包含的头文件。一般不需要。内容一般如下：
            # 自己写过爬虫的肯定知道
            Host: media.readthedocs.org
            User-Agent: Mozilla/5.0 (Windows NT 6.2; WOW64; rv:33.0) Gecko/20100101 Firefox/33.0
            Accept: text/css,*/*;q=0.1
            Accept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3
            Accept-Encoding: gzip, deflate
            Referer: http://scrapy-chs.readthedocs.org/zh_CN/0.24/
            Cookie: _ga=GA1.2.1612165614.1415584110;
            Connection: keep-alive
            If-Modified-Since: Mon, 25 Aug 2014 21:59:35 GMT
            Cache-Control: max-age=0
    
    meta: 比较常用，在不同的请求之间传递数据使用的。字典dict型
    
            request_with_cookies = Request(
                url="http://www.example.com",
                cookies={
        'currency': 'USD', 'country': 'UY'},
                meta={
        'dont_merge_cookies': True}
            )
    
    encoding: 使用默认的 'utf-8' 就行。
    
    dont_filter: 表明该请求不由调度器过滤。这是当你想使用多次执行相同的请求,忽略重复的过滤器。默认为False。
    
    errback: 指定错误处理函数

### Response ###

# 部分代码
    class Response(object_ref):
        def __init__(self, url, status=200, headers=None, body='', flags=None, request=None):
            self.headers = Headers(headers or {})
            self.status = int(status)
            self._set_body(body)
            self._set_url(url)
            self.request = request
            self.flags = [] if flags is None else list(flags)
    
        @property
        def meta(self):
            try:
                return self.request.meta
            except AttributeError:
                raise AttributeError("Response.meta not available, this response " \
                    "is not tied to any request")

参数：

status: 响应码
    _set_body(body)： 响应体
    _set_url(url)：响应url
    self.request = request

### 发送请求： ###

可以使用 yield scrapy.FormRequest(url, formdata, callback)方法发送POST请求。  
如果希望程序执行一开始就发送POST请求，可以重写Spider类的start\_requests(self) 方法，并且不再调用start\_urls里的url。

class mySpider(scrapy.Spider):
        # start_urls = ["http://www.example.com/"]
    
        def start_requests(self):
            url = 'http://www.renren.com/PLogin.do'
    
            # FormRequest 是Scrapy发送POST请求的方法
            yield scrapy.FormRequest(
                url = url,
                formdata = {
        "email" : "mr_mao_hacker@163.com", "password" : "axxxxxxxe"},
                callback = self.parse_page
            )
        def parse_page(self, response):
            # do something

### 模拟登陆： ###

import scrapy
    
    class LoginSpider(scrapy.Spider):
        name = 'example.com'
        start_urls = ['http://www.example.com/users/login.php']
    
        def parse(self, response):
            return scrapy.FormRequest.from_response(
                response,
                formdata={
        'username': 'john', 'password': 'secret'},
                callback=self.after_login
            )
    
        def after_login(self, response):
            # check login succeed before going on
            if "authentication failed" in response.body:
                self.log("Login failed", level=log.ERROR)
                return
    
            # continue scraping with authenticated session...

## 5.Downloader Middleware ##

### 通常防止爬虫被反的策略： ###

*  动态设置User-Agent（随机切换User-Agent，模拟不同用户的浏览器信息）
 *  禁用Cookies（也就是不启用cookies middleware，不向Server发送cookies，有些网站通过cookie的使用发现爬虫行为），可以通过`COOKIES_ENABLED` 控制 CookiesMiddleware 开启或关闭
 *  设置延迟下载（防止访问过于频繁，设置为 2秒 或更高）
 *  Google Cache 和 Baidu Cache：如果可能的话，使用谷歌/百度等搜索引擎服务器页面缓存获取页面数据。
 *  使用IP地址池：VPN和代理IP，现在大部分网站都是根据IP来ban的。
 *  使用 [Crawlera][]（专用于爬虫的代理组件），正确配置和设置下载中间件后，项目所有的request都是通过crawlera发出。

>     DOWNLOADER_MIDDLEWARES = {
>           'scrapy_crawlera.CrawleraMiddleware': 600
>       }
>     
>       CRAWLERA_ENABLED = True
>       CRAWLERA_USER = '注册/购买的UserKey'
>       CRAWLERA_PASS = '注册/购买的Password'

### 设置下载中间件（Downloader Middlewares） ###

下载中间件是处于引擎(crawler.engine)和下载器(crawler.engine.download())之间的一层组件，可以有多个下载中间件被加载运行。

*  当引擎传递请求给下载器的过程中，下载中间件可以对请求进行处理 （例如增加http header信息，增加proxy信息等）；
 *  在下载器完成http请求，传递响应给引擎的过程中， 下载中间件可以对响应进行处理（例如进行gzip的解压等）

要激活下载器中间件组件，将其加入到 DOWNLOADER\_MIDDLEWARES 设置中。 该设置是一个字典(dict)，键为中间件类的路径，值为其中间件的顺序(order)。

### process\_request(self, request, spider) ###

*  当每个request通过下载中间件时，该方法被调用。
 *  process\_request() 必须返回以下其中之一：一个 None 、一个 Response 对象、一个 Request 对象或 raise IgnoreRequest:

>  *   如果其返回 None ，Scrapy将继续处理该request，执行其他的中间件的相应方法，直到合适的下载器处理函数(download handler)被调用， 该request被执行(其response被下载)。
>  *  如果其返回 Response 对象，Scrapy将不会调用 任何 其他的 process\_request() 或 process\_exception() 方法，或相应地下载函数； 其将返回该response。 已安装的中间件的 process\_response() 方法则会在每个response返回时被调用。
> 
>  *  如果其返回 Request 对象，Scrapy则停止调用 process\_request方法并重新调度返回的request。当新返回的request被执行后， 相应地中间件链将会根据下载的response被调用。
> 
>  *  如果其raise一个 IgnoreRequest 异常，则安装的下载中间件的 process\_exception() 方法会被调用。如果没有任何一个方法处理该异常， 则request的errback(Request.errback)方法会被调用。如果没有代码处理抛出的异常， 则该异常被忽略且不记录(不同于其他异常那样)。

*  参数:

>  *  `request (Request 对象)` – 处理的request
>  *  `spider (Spider 对象)` – 该request对应的spider

### process\_response(self, request, response, spider) ###

当下载器完成http请求，传递响应给引擎的时候调用

*  process\_request() 必须返回以下其中之一: 返回一个 Response 对象、 返回一个 Request 对象或raise一个 IgnoreRequest 异常。

>  *  如果其返回一个 Response (可以与传入的response相同，也可以是全新的对象)， 该response会被在链中的其他中间件的 process\_response() 方法处理。
>  *  如果其返回一个 Request 对象，则中间件链停止， 返回的request会被重新调度下载。处理类似于 process\_request() 返回request所做的那样。
>  *  如果其抛出一个 IgnoreRequest 异常，则调用request的errback(Request.errback)。 如果没有代码处理抛出的异常，则该异常被忽略且不记录(不同于其他异常那样)。

*  参数:

>  *  `request (Request 对象)`   – response所对应的request
>  *  `response (Response 对象)` – 被处理的response
>  *  `spider (Spider 对象)`     – response所对应的spider

## 6.Settings ##

*  **`BOT_NAME`**

> 默认: 'scrapybot'，当您使用 startproject 命令创建项目时其也被自动赋值。

*  **`CONCURRENT_ITEMS`**

> 默认: 100，Item Processor(即 Item Pipeline) 同时处理(每个response的)item的最大值。

*  **`CONCURRENT_REQUESTS`**

> 默认: 16，Scrapy downloader 并发请求(concurrent requests)的最大值。

*  **`DEFAULT_REQUEST_HEADERS`**

>     Scrapy HTTP Request使用的默认header。
>     {
>     　　'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
>     　　'Accept-Language': 'en',
>     }

*  **`DEPTH_LIMIT`**

>  默认: 0，爬取网站最大允许的深度(depth)值。如果为0，则没有限制。

*  **`DOWNLOAD_DELAY`**

>  默认: 0，下载器在下载同一个网站下一个页面前需要等待的时间。该选项可以用来限制爬取速度， 减轻服务器压力。同时也支持小数:
> 
> `DOWNLOAD_DELAY = 0.25 # 250 ms of delay，`默认情况下，Scrapy在两个请求间不等待一个固定的值， 而是使用0.5到1.5之间的一个随机值 \* DOWNLOAD\_DELAY 的结果作为等待间隔。

*  **`DOWNLOAD_TIMEOUT`**

>  默认: 180，下载器超时时间(单位: 秒)。

*  **`ITEM_PIPELINES`**

>  默认: \{\}，保存项目中启用的pipeline及其顺序的字典。该字典默认为空，值(value)任意，不过值(value)习惯设置在0-1000范围内，值越小优先级越高。
> 
>     ITEM_PIPELINES = {
>     'mySpider.pipelines.SomethingPipeline': 300,
>     'mySpider.pipelines.ItcastJsonPipeline': 800,
>     }

*  **`LOG_ENABLED`**

> 默认: True，是否启用logging。

*  **`LOG_ENCODING`**

>  默认: 'utf-8'，logging使用的编码。

*  **`LOG_LEVEL`**

>  默认: 'DEBUG'，log的最低级别。可选的级别有: CRITICAL、 ERROR、WARNING、INFO、DEBUG 。

*  ##### **`USER_AGENT`** #####

>  默认: "Scrapy/VERSION (+[http://scrapy.org][http_scrapy.org])"，爬取的默认User-Agent，除非被覆盖。

*  ##### **`PROXIES`： 代理设置** #####

>     PROXIES = [
>       {'ip_port': '111.11.228.75:80', 'password': ''},
>       {'ip_port': '120.198.243.22:80', 'password': ''},
>       {'ip_port': '111.8.60.9:8123', 'password': ''},
>       {'ip_port': '101.71.27.120:80', 'password': ''},
>       {'ip_port': '122.96.59.104:80', 'password': ''},
>       {'ip_port': '122.224.249.122:8088', 'password':''},
>     ]

*  ##### **`COOKIES_ENABLED = False`** #####

> 禁用Cookies

## ##

转载于:https://www.cnblogs.com/Iceredtea/p/11108161.html

[https_scrapy.readthedocs.io_en_latest_index.html]: https://scrapy.readthedocs.io/en/latest/index.html
[1489220-20190629214307782-1418567979.png]: /images/20230601/1f8e7ccfd5ce473681488b8a7aa1e406.png
[Crawlera]: https://scrapinghub.com/crawlera
[http_scrapy.org]: http://scrapy.org/