请求和响应¶

Scrapy 使用 Request 和 Response 对象来爬取网站。

通常，Request 对象在爬虫中生成，并在系统中传递，直到它们到达下载器，下载器执行请求并返回一个 Response 对象，该对象返回到发出请求的爬虫。

无论是 Request 还是 Response 类都有子类，这些子类增加了基类中不需要的功能。这些功能在 Request 子类和 Response 子类中有详细描述。

请求对象¶

class scrapy.http.Request(*args: Any, **kwargs: Any)[source]¶

表示一个HTTP请求，通常由Spider生成并由Downloader执行，从而生成一个Response。

Parameters:

url (str) –
此请求的URL

如果URL无效，将引发ValueError异常。
callback (collections.abc.Callable) –
该函数将以此请求的响应（一旦下载完成）作为其第一个参数被调用。

除了函数外，还支持以下值：
- None（默认值），表示必须使用爬虫的 parse() 方法。
- NO_CALLBACK()
更多信息，请参阅向回调函数传递额外数据。

注意

如果在处理过程中抛出异常，则会调用 errback。
method (str) – 此请求的HTTP方法。默认为 'GET'。
meta (dict) – Request.meta 属性的初始值。如果提供了此参数，传入的字典将被浅复制。
body (bytes 或 str) – 请求体。如果传递的是字符串，则使用传递的 encoding（默认为 utf-8）将其编码为字节。如果未提供 body，则存储一个空的字节对象。无论此参数的类型如何，最终存储的值都将是一个字节对象（永远不会是字符串或 None）。
headers (dict) –
此请求的头部信息。字典的值可以是字符串（用于单值头部）或列表（用于多值头部）。如果传递None作为值，则不会发送HTTP头部。

注意

通过Cookie头部设置的cookie不会被CookiesMiddleware考虑。如果你需要为请求设置cookie，请使用Request.cookies参数。这是一个已知的当前限制，正在解决中。
cookies (dict 或 list) –
请求的cookies。这些可以以两种形式发送。
1. 使用字典：
```
request_with_cookies = Request(
    url="http://www.example.com",
    cookies={"currency": "USD", "country": "UY"},
)
```
1. 使用字典列表：
```
request_with_cookies = Request(
    url="https://www.example.com",
    cookies=[
        {
            "name": "currency",
            "value": "USD",
            "domain": "example.com",
            "path": "/currency",
            "secure": True,
        },
    ],
)
```
后一种形式允许自定义cookie的domain和path属性。这仅在cookie被保存以供后续请求时有用。

当某些站点返回cookie（在响应中）时，这些cookie会存储在该域的cookie中，并在未来的请求中再次发送。这是任何常规Web浏览器的典型行为。

请注意，在request.meta中将dont_merge_cookies键设置为True会导致自定义cookie被忽略。

有关更多信息，请参阅CookiesMiddleware。

注意

通过Cookie头设置的cookie不会被CookiesMiddleware考虑。如果您需要为请求设置cookie，请使用Request.cookies参数。这是一个已知的当前限制，正在解决中。

新版本2.6.0中新增：Cookie值为bool、float或int时，会被转换为str。
encoding (str) – 此请求的编码（默认为 'utf-8'）。此编码将用于对URL进行百分比编码，并将正文转换为字节（如果以字符串形式给出）。
priority (int) – 此请求的优先级（默认为 0）。调度程序使用优先级来定义处理请求的顺序。具有较高优先级值的请求将更早执行。允许使用负值来表示相对较低的优先级。
dont_filter (bool) – 表示此请求不应被调度器过滤。当您想要多次执行相同的请求时，可以使用此选项来忽略重复过滤器。请谨慎使用，否则可能会陷入爬取循环。默认为 False。
errback (collections.abc.Callable) –
如果在处理请求时引发任何异常，将调用此函数。这包括因404 HTTP错误等而失败的页面。它接收一个Failure作为第一个参数。有关更多信息，请参阅下面的使用errbacks捕获请求处理中的异常。

在版本2.0中更改：当指定errback参数时，不再需要callback参数。
flags (list) – 发送到请求的标志，可以用于日志记录或类似目的。
cb_kwargs (dict) – 一个包含任意数据的字典，这些数据将作为关键字参数传递给请求的回调函数。

url¶

一个包含此请求URL的字符串。请记住，此属性包含转义后的URL，因此它可能与传递给__init__方法的URL不同。

此属性为只读。要更改请求的URL，请使用 replace()。

method¶: 表示请求中的HTTP方法的字符串。这保证是大写的。示例："GET", "POST", "PUT", 等

headers¶: 一个类似字典的对象，包含请求头信息。

body¶

请求体以字节形式表示。

此属性为只读。要更改请求的主体，请使用 replace()。

meta = {}¶: 请求的任意元数据字典。

您可以根据需要扩展请求元数据。

请求元数据也可以通过响应的 meta 属性访问。

要将数据从一个爬虫回调传递到另一个爬虫回调，请考虑使用 cb_kwargs。然而，在某些情况下，请求元数据可能是正确的选择，例如在所有后续请求中维护一些调试数据（例如源URL）。

请求元数据的一个常见用途是为Scrapy组件（扩展、中间件等）定义特定于请求的参数。例如，如果你将dont_retry设置为True，RetryMiddleware将永远不会重试该请求，即使它失败了。请参阅Request.meta特殊键。

您也可以在自定义的Scrapy组件中使用请求元数据，例如，以保持与您的组件相关的请求状态信息。例如， RetryMiddleware 使用 retry_times 元数据键来跟踪请求到目前为止已经重试了多少次。

将先前请求的所有元数据复制到蜘蛛回调中的新后续请求中是一种不良做法，因为请求元数据可能包括由Scrapy组件设置的元数据，这些元数据并不打算被复制到其他请求中。例如，将retry_times元数据键复制到后续请求中可能会减少这些后续请求允许的重试次数。

只有当新请求旨在替换旧请求时，才应将所有请求元数据从一个请求复制到另一个请求，这通常是在从下载器中间件方法返回请求时的情况。

还要注意，copy() 和 replace() 请求方法浅拷贝请求元数据。

cb_kwargs¶

一个包含此请求的任意元数据的字典。其内容将作为关键字参数传递给请求的回调函数。对于新的请求，它是空的，这意味着默认情况下回调函数只会收到一个Response对象作为参数。

这个字典在使用copy()或replace()方法克隆请求时是浅拷贝的，并且也可以在你的爬虫中通过response.cb_kwargs属性访问。

如果请求处理失败，可以在请求的errback中访问此字典，如failure.request.cb_kwargs。更多信息，请参见在errback函数中访问额外数据。

attributes: tuple[str, ...] = ('url', 'callback', 'method', 'headers', 'body', 'cookies', 'meta', 'encoding', 'priority', 'dont_filter', 'errback', 'flags', 'cb_kwargs')¶

一个包含所有公共属性的名称的str对象的元组，这些属性也是__init__方法的关键字参数。

目前由Request.replace()、Request.to_dict()和 request_from_dict()使用。

copy()[源代码]¶: 返回一个新的请求，该请求是此请求的副本。另请参阅：向回调函数传递额外数据。

replace([url, method, headers, body, cookies, meta, flags, encoding, priority, dont_filter, callback, errback, cb_kwargs])[源代码]¶: 返回一个具有相同成员的Request对象，除了那些通过指定的关键字参数赋予新值的成员。Request.cb_kwargs 和 Request.meta 属性默认是浅拷贝的（除非作为参数提供了新值）。另请参阅向回调函数传递额外数据。

classmethod from_curl(curl_command: str, ignore_unknown_options: bool = True, **kwargs: Any) → Self[source]¶

从包含cURL命令的字符串创建一个Request对象。它会填充HTTP方法、URL、头部、cookies和主体。它接受与Request类相同的参数，优先并覆盖cURL命令中包含的相同参数的值。

默认情况下，未识别的选项会被忽略。要在发现未知选项时引发错误，请通过传递ignore_unknown_options=False来调用此方法。

注意

使用from_curl()从Request子类，如JsonRequest，或XmlRpcRequest，以及启用下载器中间件和爬虫中间件，如DefaultHeadersMiddleware，UserAgentMiddleware，或HttpCompressionMiddleware，可能会修改Request对象。

要将cURL命令转换为Scrapy请求，您可以使用curl2scrapy。

to_dict(*, spider: Spider | None = None) → dict[str, Any][源代码]¶

返回一个包含请求数据的字典。

使用 request_from_dict() 将其转换回 Request 对象。

如果提供了一个spider，此方法将尝试找出用作回调和错误回调的spider方法的名称，并将它们包含在输出字典中，如果找不到这些方法，则会引发异常。

向回调函数传递额外数据¶

请求的回调是一个函数，当该请求的响应被下载时将被调用。回调函数将以下载的Response对象作为其第一个参数被调用。

示例：

def parse_page1(self, response):
    return scrapy.Request(
        "http://www.example.com/some_page.html", callback=self.parse_page2
    )


def parse_page2(self, response):
    # this would log http://www.example.com/some_page.html
    self.logger.info("Visited %s", response.url)

在某些情况下，您可能希望向这些回调函数传递参数，以便您可以在第二个回调中稍后接收这些参数。以下示例展示了如何通过使用 Request.cb_kwargs 属性来实现这一点：

def parse(self, response):
    request = scrapy.Request(
        "http://www.example.com/index.html",
        callback=self.parse_page2,
        cb_kwargs=dict(main_url=response.url),
    )
    request.cb_kwargs["foo"] = "bar"  # add more arguments for the callback
    yield request


def parse_page2(self, response, main_url, foo):
    yield dict(
        main_url=main_url,
        other_url=response.url,
        foo=foo,
    )

注意

Request.cb_kwargs 是在版本 1.7 中引入的。在此之前，建议使用 Request.meta 来在回调之间传递信息。在 1.7 之后，Request.cb_kwargs 成为处理用户信息的首选方式，而 Request.meta 则用于与中间件和扩展等组件进行通信。

使用errbacks捕获请求处理中的异常¶

请求的errback是一个函数，当处理请求时发生异常时将被调用。

它接收一个Failure作为第一个参数，并可以用于跟踪连接建立超时、DNS错误等。

这是一个示例蜘蛛，记录所有错误并在需要时捕获一些特定错误：

import scrapy

from scrapy.spidermiddlewares.httperror import HttpError
from twisted.internet.error import DNSLookupError
from twisted.internet.error import TimeoutError, TCPTimedOutError


class ErrbackSpider(scrapy.Spider):
    name = "errback_example"
    start_urls = [
        "http://www.httpbin.org/",  # HTTP 200 expected
        "http://www.httpbin.org/status/404",  # Not found error
        "http://www.httpbin.org/status/500",  # server issue
        "http://www.httpbin.org:12345/",  # non-responding host, timeout expected
        "https://example.invalid/",  # DNS error expected
    ]

    def start_requests(self):
        for u in self.start_urls:
            yield scrapy.Request(
                u,
                callback=self.parse_httpbin,
                errback=self.errback_httpbin,
                dont_filter=True,
            )

    def parse_httpbin(self, response):
        self.logger.info("Got successful response from {}".format(response.url))
        # do something useful here...

    def errback_httpbin(self, failure):
        # log all failures
        self.logger.error(repr(failure))

        # in case you want to do something special for some errors,
        # you may need the failure's type:

        if failure.check(HttpError):
            # these exceptions come from HttpError spider middleware
            # you can get the non-200 response
            response = failure.value.response
            self.logger.error("HttpError on %s", response.url)

        elif failure.check(DNSLookupError):
            # this is the original request
            request = failure.request
            self.logger.error("DNSLookupError on %s", request.url)

        elif failure.check(TimeoutError, TCPTimedOutError):
            request = failure.request
            self.logger.error("TimeoutError on %s", request.url)

在errback函数中访问额外数据¶

如果请求处理失败，您可能对访问回调函数的参数感兴趣，以便您可以根据errback中的参数进一步处理。以下示例展示了如何使用Failure.request.cb_kwargs来实现这一点：

def parse(self, response):
    request = scrapy.Request(
        "http://www.example.com/index.html",
        callback=self.parse_page2,
        errback=self.errback_page2,
        cb_kwargs=dict(main_url=response.url),
    )
    yield request


def parse_page2(self, response, main_url):
    pass


def errback_page2(self, failure):
    yield dict(
        main_url=failure.request.cb_kwargs["main_url"],
    )

请求指纹¶

在抓取过程中有一些方面，比如过滤掉重复的请求 (参见 DUPEFILTER_CLASS) 或缓存响应 (参见 HTTPCACHE_POLICY)，你需要能够从一个 Request 对象生成一个简短、唯一的标识符：请求指纹。

通常你不需要担心请求指纹，默认的请求指纹器适用于大多数项目。

然而，没有一种通用的方法可以从请求生成唯一标识符，因为不同的情况需要以不同的方式比较请求。例如，有时您可能需要不区分大小写地比较URL，包括URL片段，排除某些URL查询参数，包括部分或所有标头等。

要更改如何为您的请求构建请求指纹，请使用 REQUEST_FINGERPRINTER_CLASS 设置。

请求指纹器类¶

新版本2.7中新增。

默认值：scrapy.utils.request.RequestFingerprinter

一个请求指纹类或其导入路径。

class scrapy.utils.request.RequestFingerprinter(crawler: Crawler | None = None)[source]¶

默认指纹识别器。

它考虑了request.url的规范版本 (w3lib.url.canonicalize_url())以及request.method和request.body的值。然后生成一个SHA1哈希值。

另请参阅

REQUEST_FINGERPRINTER_IMPLEMENTATION.

编写你自己的请求指纹器¶

请求指纹器是一个必须实现以下方法的类：

fingerprint(self, request)¶

返回一个bytes对象，该对象唯一标识request。

另请参阅请求指纹限制。

Parameters:: request (scrapy.http.Request) – 要生成指纹的请求

此外，它还可以实现以下方法：

classmethod from_crawler(cls, crawler)

如果存在，此方法被调用以从Crawler对象创建一个请求指纹器实例。它必须返回一个新的请求指纹器实例。

crawler 提供了对所有Scrapy核心组件的访问，如设置和信号；它是请求指纹识别器访问这些组件并将其功能集成到Scrapy中的一种方式。

Parameters:: 爬虫 (Crawler 对象) – 使用此请求指纹生成器的爬虫

默认请求指纹生成器的fingerprint()方法，即scrapy.utils.request.RequestFingerprinter，使用scrapy.utils.request.fingerprint()及其默认参数。对于一些常见的用例，您也可以在fingerprint()方法实现中使用scrapy.utils.request.fingerprint()：

scrapy.utils.request.fingerprint(request: Request, *, include_headers: Iterable[bytes | str] | None = None, keep_fragments: bool = False) → bytes[源代码]¶

返回请求的指纹。

请求指纹是一个哈希值，它唯一标识请求所指向的资源。例如，以下两个URL： http://www.example.com/query?id=111&cat=222, http://www.example.com/query?cat=222&id=111。

尽管这两个是不同的URL，但它们指向相同的资源并且是等价的（即它们应该返回相同的响应）。

另一个例子是用于存储会话ID的cookies。假设以下页面仅对经过身份验证的用户可访问： http://www.example.com/members/offers.html。

许多网站使用cookie来存储会话ID，这为HTTP请求添加了一个随机组件，因此在计算指纹时应忽略它。

因此，在计算指纹时，默认情况下会忽略请求头。如果你想包含特定的头信息，可以使用include_headers参数，它是一个包含要包含的请求头的列表。

此外，服务器在处理请求时通常会忽略URL中的片段，因此在计算指纹时默认也会忽略它们。如果你想包含它们，请将keep_fragments参数设置为True （例如在使用无头浏览器处理请求时）。

例如，要考虑到名为 X-ID 的请求头的值：

# my_project/settings.py
REQUEST_FINGERPRINTER_CLASS = "my_project.utils.RequestFingerprinter"

# my_project/utils.py
from scrapy.utils.request import fingerprint


class RequestFingerprinter:
    def fingerprint(self, request):
        return fingerprint(request, include_headers=["X-ID"])

你也可以从头开始编写自己的指纹识别逻辑。

然而，如果你不使用 scrapy.utils.request.fingerprint()，请确保你使用 WeakKeyDictionary 来缓存请求指纹：

缓存通过确保每个请求只计算一次指纹来节省CPU，而不是每个需要请求指纹的Scrapy组件都计算一次。
使用WeakKeyDictionary可以节省内存，确保请求对象不会仅仅因为你在缓存字典中有对它们的引用而永远留在内存中。

例如，仅考虑请求的URL，而不进行任何先前的URL规范化或考虑请求方法或请求体：

from hashlib import sha1
from weakref import WeakKeyDictionary

from scrapy.utils.python import to_bytes


class RequestFingerprinter:
    cache = WeakKeyDictionary()

    def fingerprint(self, request):
        if request not in self.cache:
            fp = sha1()
            fp.update(to_bytes(request.url))
            self.cache[request] = fp.digest()
        return self.cache[request]

如果你需要能够从你的爬虫回调中覆盖任意请求的请求指纹，你可以实现一个请求指纹器，当可用时从request.meta读取指纹，然后回退到scrapy.utils.request.fingerprint()。例如：

from scrapy.utils.request import fingerprint


class RequestFingerprinter:
    def fingerprint(self, request):
        if "fingerprint" in request.meta:
            return request.meta["fingerprint"]
        return fingerprint(request)

如果您需要在不使用已弃用的'2.6'值的REQUEST_FINGERPRINTER_IMPLEMENTATION设置的情况下，重现与Scrapy 2.6相同的指纹算法，请使用以下请求指纹器：

from hashlib import sha1
from weakref import WeakKeyDictionary

from scrapy.utils.python import to_bytes
from w3lib.url import canonicalize_url


class RequestFingerprinter:
    cache = WeakKeyDictionary()

    def fingerprint(self, request):
        if request not in self.cache:
            fp = sha1()
            fp.update(to_bytes(request.method))
            fp.update(to_bytes(canonicalize_url(request.url)))
            fp.update(request.body or b"")
            self.cache[request] = fp.digest()
        return self.cache[request]

请求指纹限制¶

使用请求指纹的Scrapy组件可能会对您的请求指纹生成器生成的指纹格式施加额外的限制。

以下内置的Scrapy组件有这些限制：

scrapy.extensions.httpcache.FilesystemCacheStorage (HTTPCACHE_STORAGE 的默认值)

请求指纹必须至少为1字节长。

文件系统的路径和文件名长度限制也适用于 HTTPCACHE_DIR。在HTTPCACHE_DIR内部，会创建以下目录结构：
- Spider.name
  - 请求指纹的第一个字节，以十六进制表示
    - 指纹为十六进制
      - 文件名最多16个字符长
例如，如果请求指纹由20个字节组成（默认）， HTTPCACHE_DIR 是 '/home/user/project/.scrapy/httpcache'，并且你的爬虫名称是 'my_spider'，你的文件系统必须支持如下文件路径：
```
/home/user/project/.scrapy/httpcache/my_spider/01/0123456789abcdef0123456789abcdef01234567/response_headers
```
scrapy.extensions.httpcache.DbmCacheStorage

底层的DBM实现必须支持键的长度为请求指纹字节数的两倍，再加上5。例如，如果请求指纹由20个字节组成（默认值），则必须支持45个字符长的键。

Request.meta 特殊键¶

Request.meta 属性可以包含任意数据，但有一些特殊的键被Scrapy及其内置扩展所识别。

这些是：

绑定地址¶

用于执行请求的传出IP地址的IP。

下载超时¶

下载器在超时前等待的时间（以秒为单位）。另请参阅：DOWNLOAD_TIMEOUT。

下载延迟¶

获取响应所花费的时间，自请求开始以来，即HTTP消息通过网络发送。此元键仅在响应已下载时可用。虽然大多数其他元键用于控制Scrapy行为，但此元键应为只读。

数据丢失时下载失败¶

是否在响应损坏时失败。参见： DOWNLOAD_FAIL_ON_DATALOSS.

最大重试次数¶

元键用于设置每个请求的重试次数。初始化时，max_retry_times 元键的优先级高于RETRY_TIMES 设置。

停止下载响应¶

从处理bytes_received或headers_received信号的处理器中抛出StopDownload异常将停止给定响应的下载。请参见以下示例：

import scrapy


class StopSpider(scrapy.Spider):
    name = "stop"
    start_urls = ["https://docs.scrapy.org/en/latest/"]

    @classmethod
    def from_crawler(cls, crawler):
        spider = super().from_crawler(crawler)
        crawler.signals.connect(
            spider.on_bytes_received, signal=scrapy.signals.bytes_received
        )
        return spider

    def parse(self, response):
        # 'last_chars' show that the full response was not downloaded
        yield {"len": len(response.text), "last_chars": response.text[-40:]}

    def on_bytes_received(self, data, request, spider):
        raise scrapy.exceptions.StopDownload(fail=False)

生成以下输出：

2020-05-19 17:26:12 [scrapy.core.engine] INFO: Spider opened
2020-05-19 17:26:12 [scrapy.extensions.logstats] INFO: Crawled 0 pages (at 0 pages/min), scraped 0 items (at 0 items/min)
2020-05-19 17:26:13 [scrapy.core.downloader.handlers.http11] DEBUG: Download stopped for <GET https://docs.scrapy.org/en/latest/> from signal handler StopSpider.on_bytes_received
2020-05-19 17:26:13 [scrapy.core.engine] DEBUG: Crawled (200) <GET https://docs.scrapy.org/en/latest/> (referer: None) ['download_stopped']
2020-05-19 17:26:13 [scrapy.core.scraper] DEBUG: Scraped from <200 https://docs.scrapy.org/en/latest/>
{'len': 279, 'last_chars': 'dth, initial-scale=1.0">\n  \n  <title>Scr'}
2020-05-19 17:26:13 [scrapy.core.engine] INFO: Closing spider (finished)

默认情况下，生成的响应由其相应的错误回调处理。要改为调用它们的回调，如本例所示，将fail=False传递给StopDownload异常。

请求子类¶

以下是内置的Request子类的列表。你也可以继承它来实现你自己的自定义功能。

FormRequest 对象¶

FormRequest 类扩展了基础的 Request，增加了处理 HTML 表单的功能。它使用 lxml.html forms 来预填充表单字段，这些字段的数据来自 Response 对象。

class scrapy.http.request.form.FormRequest¶

class scrapy.http.FormRequest¶

class scrapy.FormRequest(url[, formdata, ...])¶

FormRequest 类向 __init__ 方法添加了一个新的关键字参数。其余参数与 Request 类相同，此处不再赘述。

Parameters:: formdata (dict 或 collections.abc.Iterable) – 是一个字典（或 (key, value) 元组的可迭代对象），包含将进行 URL 编码并分配给请求体的 HTML 表单数据。

FormRequest 对象除了支持标准的 Request 方法外，还支持以下类方法：

classmethod FormRequest.from_response(response[, formname=None, formid=None, formnumber=0, formdata=None, formxpath=None, formcss=None, clickdata=None, dont_click=False, ...])¶

返回一个新的FormRequest对象，其表单字段值已预先填充为给定响应中包含的HTML

元素中的值。有关示例，请参见。

策略是默认自动模拟点击任何看起来可点击的表单控件，例如 type="submit">。尽管这非常方便，并且通常是期望的行为，但有时可能会导致难以调试的问题。例如，当处理使用javascript填充和/或提交的表单时，默认的from_response()行为可能不是最合适的。要禁用此行为，您可以将dont_click参数设置为True。此外，如果您想更改点击的控件（而不是禁用它），您也可以使用clickdata参数。

注意

由于lxml中的一个错误，在选项值中有前导或尾随空白的select元素上使用此方法将无法工作，该错误应在lxml 3.8及以上版本中修复。

Parameters:

response (Response 对象) – 包含HTML表单的响应，该表单将用于预填充表单字段
formname (str) – 如果提供，将使用具有此值的name属性的表单。
formid (str) – 如果提供了，将使用id属性设置为该值的表单。
formxpath (str) – 如果提供，将使用第一个匹配xpath的表单。
formcss (str) – 如果提供，将使用与CSS选择器匹配的第一个表单。
formnumber (int) – 当响应包含多个表单时，使用的表单编号。第一个表单（也是默认的）是 0。
formdata (dict) – 要覆盖的表单数据字段。如果字段已经存在于响应的
元素中，其值将被此参数中传递的值覆盖。如果此参数中传递的值为 None，则该字段将不会包含在请求中，即使它存在于响应的元素中。
clickdata (dict) – 用于查找点击控件的属性。如果未提供，表单数据将提交，模拟点击第一个可点击元素。除了html属性外，控件还可以通过nr属性相对于表单内其他可提交输入的从零开始的索引来识别。
dont_click (bool) – 如果为True，表单数据将在不点击任何元素的情况下提交。

此类的其他参数直接传递给 FormRequest __init__ 方法。

请求使用示例¶

使用FormRequest通过HTTP POST发送数据¶

如果你想在你的爬虫中模拟一个HTML表单POST并发送几个键值字段，你可以从你的爬虫中返回一个FormRequest对象，如下所示：

return [
    FormRequest(
        url="http://www.example.com/post/action",
        formdata={"name": "John Doe", "age": "27"},
        callback=self.after_post,
    )
]

使用 FormRequest.from_response() 模拟用户登录¶

网站通常通过type="hidden">元素提供预填充的表单字段，例如与会话相关的数据或认证令牌（用于登录页面）。在抓取时，您会希望这些字段自动预填充，并且只覆盖其中的几个字段，例如用户名和密码。您可以使用FormRequest.from_response()方法来完成这项工作。以下是一个使用它的示例爬虫：

import scrapy


def authentication_failed(response):
    # TODO: Check the contents of the response and return True if it failed
    # or False if it succeeded.
    pass


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):
        if authentication_failed(response):
            self.logger.error("Login failed")
            return

        # continue scraping with authenticated session...

JsonRequest¶

JsonRequest 类扩展了基础 Request 类，增加了处理 JSON 请求的功能。

class scrapy.http.JsonRequest(url[, ... data, dumps_kwargs])[源代码]¶

JsonRequest 类向 __init__ 方法添加了两个新的关键字参数。其余参数与 Request 类相同，此处不再赘述。

使用 JsonRequest 会将 Content-Type 头设置为 application/json 并将 Accept 头设置为 application/json, text/javascript, */*; q=0.01

Parameters:

data (object) – 是需要进行JSON编码并分配给body的任何可JSON序列化的对象。如果提供了Request.body参数，则此参数将被忽略。如果未提供Request.body参数且提供了data参数，Request.method将自动设置为'POST'。
dumps_kwargs (dict) – 将传递给底层的 json.dumps() 方法的参数，该方法用于将数据序列化为 JSON 格式。

attributes: tuple[str, ...] = ('url', 'callback', 'method', 'headers', 'body', 'cookies', 'meta', 'encoding', 'priority', 'dont_filter', 'errback', 'flags', 'cb_kwargs', 'dumps_kwargs')¶

一个包含所有公共属性的名称的str对象的元组，这些属性也是__init__方法的关键字参数。

目前由Request.replace()、Request.to_dict()和 request_from_dict()使用。

JsonRequest 使用示例¶

发送一个带有JSON负载的JSON POST请求：

data = {
    "name1": "value1",
    "name2": "value2",
}
yield JsonRequest(url="http://www.example.com/post/action", data=data)

响应对象¶

class scrapy.http.Response(*args: Any, **kwargs: Any)[源代码]¶

一个表示HTTP响应的对象，通常由下载器下载并传递给蜘蛛进行处理。

Parameters:

url (str) – 此响应的URL
status (int) – 响应的HTTP状态。默认为 200。
headers (dict) – 此响应的头部信息。字典的值可以是字符串（用于单值头部）或列表（用于多值头部）。
body (bytes) – 响应体。要访问解码后的文本作为字符串，请使用 response.text 从支持编码的 Response 子类, 例如 TextResponse。
flags (list) – 是一个包含初始值的列表，用于 Response.flags 属性。如果提供，列表将被浅拷贝。
request (scrapy.Request) – Response.request 属性的初始值。这表示生成了此响应的 Request。
证书 (twisted.internet.ssl.Certificate) – 一个表示服务器SSL证书的对象。
ip_address (ipaddress.IPv4Address 或 ipaddress.IPv6Address) – 响应来源的服务器的IP地址。
protocol (str) – 用于下载响应的协议。例如：“HTTP/1.0”、“HTTP/1.1”、“h2”

版本2.0.0新增：certificate 参数。

版本2.1.0新增： ip_address 参数。

版本2.5.0新增： protocol 参数。

url¶

包含响应URL的字符串。

此属性是只读的。要更改响应的URL，请使用 replace()。

status¶: 一个表示响应HTTP状态的整数。示例：200, 404。

headers¶

一个类似字典的对象，包含响应头。可以使用get()来返回指定名称的第一个头值，或使用getlist()来返回指定名称的所有头值。例如，这个调用将给你所有的头中的cookies：

response.headers.getlist('Set-Cookie')

body¶

响应体以字节形式返回。

如果你想将正文作为字符串获取，请使用 TextResponse.text（仅在 TextResponse 及其子类中可用）。

此属性为只读。要更改Response的主体，请使用 replace()。

request¶

生成此响应的Request对象。此属性在Scrapy引擎中分配，在响应和请求通过所有下载器中间件之后。特别是，这意味着：

HTTP重定向将从重定向前的请求创建一个新的请求。它具有大部分相同的元数据和原始请求属性，并被分配给重定向的响应，而不是原始请求的传播。
Response.request.url 并不总是等于 Response.url
此属性仅在蜘蛛代码中可用，并且在 Spider Middlewares 中可用，但在下载器中间件中不可用（尽管您可以通过其他方式在那里获取请求）以及 response_downloaded 信号的处理程序中。

meta¶

这是Request.meta属性的快捷方式，属于 Response.request对象（即self.request.meta）。

与Response.request属性不同，Response.meta属性会在重定向和重试过程中传播，因此你将获得从你的爬虫发送的原始Request.meta。

另请参阅

Request.meta 属性

cb_kwargs¶

版本2.0新增。

一个指向Request.cb_kwargs属性的快捷方式，该属性属于 Response.request对象（即self.request.cb_kwargs）。

与Response.request属性不同， Response.cb_kwargs属性会在重定向和重试过程中传播，因此你将获得从你的爬虫发送的原始Request.cb_kwargs。

另请参阅

Request.cb_kwargs 属性

flags¶: 一个包含此响应标志的列表。标志是用于标记响应的标签。例如：'cached', 'redirected’等。它们显示在响应的字符串表示（__str__方法）上，引擎使用该方法进行日志记录。

certificate¶

新版本2.0.0新增。

一个表示服务器SSL证书的twisted.internet.ssl.Certificate对象。

仅对https响应填充，否则为None。

ip_address¶

版本2.1.0新增。

响应来源的服务器的IP地址。

此属性目前仅由HTTP 1.1下载处理程序填充，即针对http(s)响应。对于其他处理程序，ip_address始终为None。

protocol¶

新版本2.5.0中新增。

用于下载响应的协议。例如：“HTTP/1.0”，“HTTP/1.1”

此属性目前仅由HTTP下载处理程序填充，即针对http(s)响应。对于其他处理程序，protocol始终为None。

attributes: tuple[str, ...] = ('url', 'status', 'headers', 'body', 'flags', 'request', 'certificate', 'ip_address', 'protocol')¶

一个包含所有公共属性的名称的str对象的元组，这些属性也是__init__方法的关键字参数。

目前由Response.replace()使用。

copy()[源代码]¶: 返回一个新的响应，该响应是此响应的副本。

replace([url, status, headers, body, request, flags, cls])[source]¶: 返回一个具有相同成员的Response对象，除了那些通过指定的关键字参数赋予新值的成员。默认情况下，属性Response.meta会被复制。

urljoin(url)[source]¶

通过将响应的url与可能的相对URL结合，构建一个绝对URL。

这是对urljoin()的一个封装，它仅仅是为了简化这个调用的别名：

urllib.parse.urljoin(response.url, url)

返回一个Request实例以跟随链接url。它接受与Request.__init__方法相同的参数，但url可以是相对URL或scrapy.link.Link对象，而不仅仅是绝对URL。

TextResponse 提供了一个 follow() 方法，除了支持绝对/相对URL和Link对象外，还支持选择器。

版本2.0新增：flags 参数。

版本2.0新增。

返回一个可迭代的Request实例，以跟踪urls中的所有链接。它接受与Request.__init__方法相同的参数，但urls中的元素可以是相对URL或Link对象，而不仅仅是绝对URL。

TextResponse 提供了一个 follow_all() 方法，除了支持绝对/相对URL和链接对象外，还支持选择器。

响应子类¶

以下是可用的内置响应子类列表。您也可以继承响应类来实现您自己的功能。

TextResponse 对象¶

class scrapy.http.TextResponse(url[, encoding[, ...]])[source]¶

TextResponse 对象为基础类 Response 添加了编码功能，后者仅用于处理二进制数据，例如图像、声音或任何媒体文件。

TextResponse 对象支持一个新的 __init__ 方法参数，除了基础的 Response 对象。其余功能与 Response 类相同，此处不再赘述。

Parameters:: encoding (str) – 是一个字符串，包含用于此响应的编码。如果你使用字符串作为主体创建一个 TextResponse 对象，它将被转换为使用此编码编码的字节。如果 encoding 是 None（默认值），则将在响应头和主体中查找编码。

TextResponse 对象除了支持标准的 Response 属性外，还支持以下属性：

text¶

响应体，作为字符串。

与response.body.decode(response.encoding)相同，但结果在第一次调用后被缓存，因此您可以多次访问response.text而无需额外的开销。

注意

str(response.body) 不是将响应体转换为字符串的正确方法：

>>> str(b"body")
"b'body'"

encoding¶

一个包含此响应编码的字符串。编码通过按顺序尝试以下机制来解决：

在__init__方法中传递的encoding参数
在Content-Type HTTP头中声明的编码。如果此编码无效（即未知），则忽略它并尝试下一个解析机制。
响应体中声明的编码。TextResponse类没有为此提供任何特殊功能。然而，HtmlResponse 和 XmlResponse 类提供了。
通过查看响应体推断出的编码。这是更脆弱的方法，但也是最后尝试的方法。

selector¶: 一个使用响应作为目标的Selector实例。选择器在首次访问时延迟实例化。

attributes: tuple[str, ...] = ('url', 'status', 'headers', 'body', 'flags', 'request', 'certificate', 'ip_address', 'protocol', 'encoding')¶

一个包含所有公共属性的名称的str对象的元组，这些属性也是__init__方法的关键字参数。

目前由Response.replace()使用。

TextResponse 对象除了支持标准的 Response 方法外，还支持以下方法：

jmespath(query)[source]¶

一个快捷方式到 TextResponse.selector.jmespath(query):

response.jmespath('object.[*]')

xpath(query)[source]¶

一个快捷方式到 TextResponse.selector.xpath(query):

response.xpath('//p')

css(query)[source]¶

一个快捷方式到 TextResponse.selector.css(query):

response.css('p')

返回一个Request实例以跟随链接url。它接受与Request.__init__方法相同的参数，但url不仅可以是一个绝对URL，还可以是

一个相对URL
一个 Link 对象，例如 Link Extractors 的结果
一个用于或元素的 Selector 对象，例如 response.css('a.my_link')[0]
一个属性 Selector（不是 SelectorList），例如 response.css('a::attr(href)')[0] 或 response.xpath('//img/@src')[0]

请参阅创建请求的快捷方式以获取使用示例。

一个生成器，用于生成Request实例以跟踪urls中的所有链接。它接受与Request的__init__方法相同的参数，除了每个urls元素不需要是绝对URL，它可以是以下任意一种：

一个相对URL
一个 Link 对象，例如 Link Extractors 的结果
一个用于或元素的 Selector 对象，例如 response.css('a.my_link')[0]
一个属性 Selector（不是 SelectorList），例如 response.css('a::attr(href)')[0] 或 response.xpath('//img/@src')[0]

此外，css 和 xpath 参数被接受以在 follow_all 方法中执行链接提取（仅接受 urls、css 和 xpath 中的一个）。

请注意，当将SelectorList作为urls参数的参数传递或使用css或xpath参数时，此方法不会为无法获取链接的选择器生成请求（例如，没有href属性的锚标签）

json()[source]¶

新版本2.2新增。

将JSON文档反序列化为Python对象。

从反序列化的JSON文档返回一个Python对象。结果在第一次调用后被缓存。

urljoin(url)[source]¶: 通过将响应的基础URL与可能的相对URL结合，构建一个绝对URL。基础URL应从标签中提取，如果没有这样的标签，则直接使用响应的url。

HtmlResponse 对象¶

class scrapy.http.HtmlResponse(url[, ...])[source]¶: HtmlResponse 类是 TextResponse 的子类，它通过查看 HTML 的 meta http-equiv 属性来添加编码自动发现支持。请参阅 TextResponse.encoding。

XmlResponse 对象¶

class scrapy.http.XmlResponse(url[, ...])[source]¶: XmlResponse 类是 TextResponse 的子类，它通过查看 XML 声明行增加了编码自动发现支持。请参阅 TextResponse.encoding。

JsonResponse 对象¶

class scrapy.http.JsonResponse(url[, ...])[source]¶: JsonResponse 类是 TextResponse 的一个子类，当响应在其 Content-Type 头中具有 JSON MIME 类型时使用。

请求和响应¶

请求对象¶

与请求相关的其他函数¶

向回调函数传递额外数据¶

使用errbacks捕获请求处理中的异常¶

在errback函数中访问额外数据¶

请求指纹¶

请求指纹器类¶

编写你自己的请求指纹器¶

请求指纹限制¶

Request.meta 特殊键¶

绑定地址¶

下载超时¶

下载延迟¶

数据丢失时下载失败¶

最大重试次数¶

停止下载响应¶

请求子类¶

FormRequest 对象¶

请求使用示例¶

使用FormRequest通过HTTP POST发送数据¶

使用 FormRequest.from_response() 模拟用户登录¶

JsonRequest¶

JsonRequest 使用示例¶

响应对象¶

响应子类¶

TextResponse 对象¶

HtmlResponse 对象¶

XmlResponse 对象¶

JsonResponse 对象¶