请求和响应

零星用途 RequestResponse 用于对网站进行爬网的对象。

通常, Request 对象在spider中生成并在系统中传递,直到它们到达下载程序,下载程序执行请求并返回 Response 返回发出请求的spider的对象。

两个 RequestResponse 类具有子类,这些子类添加了基类中不需要的功能。这些在下面的 请求子类响应子类 .

请求对象

class scrapy.http.Request(*args, **kwargs)[源代码]

A Request 对象表示一个HTTP请求,通常由spider生成并由下载程序执行,从而生成一个 Response .

参数
  • url (str) -- 此请求的URL如果该URL无效,则 ValueError 引发异常。

  • callback (collections.abc.Callable) -- 将以此请求的响应(一旦下载)作为其第一个参数来调用的函数。有关详细信息,请参阅 向回调函数传递附加数据 下面。如果请求未指定回调,则蜘蛛 parse() 将使用方法。请注意,如果在处理过程中引发异常,则改为调用errback。

  • method (str) -- 此请求的HTTP方法。默认为 'GET' .

  • meta (dict) -- 的初始值 Request.meta 属性。如果给定,则将浅复制传入此参数的dict。

  • body (bytes or str) -- 请求主体。如果传递了一个字符串,则使用 encoding 通过(默认为 utf-8 )如果 body 如果未给定,则存储空字节对象。不管这个参数的最后一个值是什么,都不会被存储 None

  • headers (dict) -- 此请求的头。dict值可以是字符串(对于单值头)或列表(对于多值头)。如果 None 作为值传递,HTTP头将不会被发送。

  • cookies (dict or list) --

    请求cookies。这些可以用两种形式发送。

    1. 使用DICT::

      request_with_cookies = Request(url="http://www.example.com",
                                     cookies={'currency': 'USD', 'country': 'UY'})
      
    2. 使用听写列表:

      request_with_cookies = Request(url="http://www.example.com",
                                     cookies=[{'name': 'currency',
                                              'value': 'USD',
                                              'domain': 'example.com',
                                              'path': '/currency'}])
      

    后一个表单允许自定义 domainpath cookie的属性。只有在为以后的请求保存cookie时,这才有用。

    当某些站点返回cookies(在响应中)时,这些cookies存储在该域的cookies中,并将在以后的请求中再次发送。这是任何普通网络浏览器的典型行为。

    要创建不发送存储的cookie且不存储接收到的cookie的请求,请设置 dont_merge_cookies 关键 True 在里面 request.meta .

    发送手动定义的cookie并忽略cookie存储的请求示例:

    Request(
        url="http://www.example.com",
        cookies={'currency': 'USD', 'country': 'UY'},
        meta={'dont_merge_cookies': True},
    )
    

    有关详细信息,请参阅 CookiesMiddleware .

  • encoding (str) -- 此请求的编码(默认为 'utf-8' ). 此编码将用于对URL进行百分比编码,并将正文转换为字节(如果以字符串形式给出)。

  • priority (int) -- 此请求的优先级(默认为 0 )调度程序使用优先级定义用于处理请求的顺序。优先级值较高的请求将更早执行。允许负值以表示相对较低的优先级。

  • dont_filter (bool) -- 指示调度程序不应筛选此请求。当您希望多次执行相同的请求时,可以使用此选项忽略重复的筛选器。小心使用,否则会进入爬行循环。默认为 False .

  • errback (collections.abc.Callable) -- 如果在处理请求时引发任何异常,则将调用的函数。这包括404 HTTP错误等失败的页面。它收到一个 Failure 作为第一个参数。有关详细信息,请参阅 使用errbacks捕获请求处理中的异常 下面。。版本更改::2.0 回调错误 参数已指定。

  • flags (list) -- 发送到请求的标志可用于日志记录或类似用途。

  • cb_kwargs (dict) -- 具有任意数据的dict,将作为关键字参数传递到请求的回调。

url

包含此请求的URL的字符串。请记住,此属性包含转义的URL,因此它可以不同于 __init__ 方法。

此属性是只读的。要更改请求的URL,请使用 replace() .

method

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

headers

包含请求头的类似字典的对象。

body

以字节表示的请求正文。

此属性是只读的。要更改请求正文,请使用 replace() .

meta

包含此请求的任意元数据的dict。对于新请求,此dict是空的,通常由不同的零碎组件(扩展、中间产品等)填充。所以这个dict中包含的数据取决于您启用的扩展名。

请求.meta特殊键 获取scrapy识别的特殊元键列表。

这个字典是 shallow copied 当使用 copy()replace() 方法,也可以通过 response.meta 属性。

cb_kwargs

包含此请求的任意元数据的字典。它的内容将作为关键字参数传递给请求的回调。对于新请求,它为空,这意味着默认情况下,回调只获取 Response 对象作为参数。

这个字典是 shallow copied 当使用 copy()replace() 方法,也可以通过 response.cb_kwargs 属性。

在处理请求失败的情况下,此dict可以作为 failure.request.cb_kwargs 在请求的errback中。有关详细信息,请参阅 访问errback函数中的其他数据 .

copy()[源代码]

返回一个新请求,它是此请求的副本。参见: 向回调函数传递附加数据 .

replace([url, method, headers, body, cookies, meta, flags, encoding, priority, dont_filter, callback, errback, cb_kwargs])[源代码]

返回具有相同成员的请求对象,除了那些通过指定的关键字参数赋予新值的成员。这个 Request.cb_kwargsRequest.meta 默认情况下,属性被浅复制(除非新值作为参数提供)。另请参见 向回调函数传递附加数据 .

classmethod from_curl(curl_command, ignore_unknown_options=True, **kwargs)[源代码]

从包含 cURL 命令。它填充HTTP方法、URL、头、cookies和主体。它接受与 Request 类,获取首选项并重写cURL命令中包含的相同参数的值。

默认情况下,将忽略无法识别的选项。若要在查找未知选项时引发错误,请通过传递调用此方法 ignore_unknown_options=False .

警告

使用 from_curl()Request 子类,例如 JSONRequestXmlRpcRequest ,以及 downloader middlewaresspider middlewares 启用,例如 DefaultHeadersMiddlewareUserAgentMiddlewareHttpCompressionMiddleware ,可以修改 Request 对象。

要将cURL命令转换为Scrapy请求,可以使用 curl2scrapy .

向回调函数传递附加数据

请求的回调是一个函数,在下载请求的响应时将调用该函数。将使用下载的 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.7Request.cb_kwargs 成为处理用户信息的首选方式,离开 Request.meta 用于与中间件和扩展等组件通信。

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

请求的errback是一个函数,在处理异常时将调用该函数。

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

下面是一个spider示例,记录所有错误,并在需要时捕获一些特定错误:

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
        "http://www.httphttpbinbin.org/",       # 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'],
    )

请求.meta特殊键

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

那些是:

绑定地址

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

download_timeout

下载程序在超时前等待的时间(以秒计)。参见: DOWNLOAD_TIMEOUT .

download_latency

自请求启动以来,获取响应所花费的时间,即通过网络发送的HTTP消息。只有在下载响应后,此元键才可用。虽然大多数其他的元键用于控制零碎的行为,但这个元键应该是只读的。

download_fail_on_dataloss

是否在错误的响应上失败。见: DOWNLOAD_FAIL_ON_DATALOSS .

max_retry_times

使用meta key设置每个请求的重试次数。初始化时, max_retry_times 元键优先于 RETRY_TIMES 设置。

停止下载响应

抬高 StopDownload 来自a的异常 bytes_received 信号处理程序将停止下载给定的响应。请参见以下示例:

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=FalseStopDownload 例外。

请求子类

这是内置的列表 Request 子类。您还可以将其子类化,以实现您自己的自定义功能。

FormRequest对象

FormRequest类扩展了基 Request 具有处理HTML表单的功能。它使用 lxml.html forms 使用表单数据预填充表单域的步骤 Response 物体。

class scrapy.http.FormRequest(url[, formdata, ...])[源代码]

这个 FormRequest 类将新的关键字参数添加到 __init__ 方法。其余参数与 Request 在这里没有记录。

参数

formdata (dict or collections.abc.Iterable) -- 是包含HTML表单数据的字典(或可为(键、值)元组),这些数据将被URL编码并分配给请求主体。

这个 FormRequest 除了标准之外,对象还支持以下类方法 Request 方法:

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

返回新的 FormRequest 对象,其表单字段值预填充在HTML中 <form> 包含在给定响应中的元素。有关示例,请参见 使用formRequest.from_response()模拟用户登录 .

默认情况下,策略是在任何看起来可单击的窗体控件上自动模拟单击,如 <input type="submit"> . 尽管这非常方便,而且常常是所需的行为,但有时它可能会导致难以调试的问题。例如,当处理使用javascript填充和/或提交的表单时,默认 from_response() 行为可能不是最合适的。要禁用此行为,可以设置 dont_click 参数 True . 此外,如果要更改单击的控件(而不是禁用它),还可以使用 clickdata 参数。

警告

对于选项值中有前导空格或尾随空格的select元素,使用此方法将不起作用,因为 bug in lxml ,应在LXML 3.8及更高版本中修复。

参数
  • response (Response object) -- 包含用于预填充表单字段的HTML表单的响应

  • formname (str) -- 如果给定,将使用名称属性设置为该值的表单。

  • formid (str) -- 如果给定,将使用ID属性设置为该值的表单。

  • formxpath (str) -- 如果给定,将使用与xpath匹配的第一个表单。

  • formcss (str) -- 如果给定,将使用与CSS选择器匹配的第一个表单。

  • formnumber (int) -- 当响应包含多个表单时要使用的表单数。第一个(也是默认值)是 0 .

  • formdata (dict) -- 要在表单数据中重写的字段。如果响应中已存在字段 <form> 元素,其值将被此参数中传递的值重写。如果此参数中传递的值是 None ,即使响应中存在该字段,该字段也不会包含在请求中。 <form> 元素。

  • clickdata (dict) -- 用于查找单击的控件的属性。如果没有给出,将提交表单数据,模拟单击第一个可单击元素。除了HTML属性之外,控件还可以通过其相对于表单内其他可提交输入的基于零的索引进行标识,方法是 nr 属性。

  • dont_click (bool) -- 如果为真,则表单数据将在不单击任何元素的情况下提交。

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

请求使用示例

使用FormRequest通过HTTP Post发送数据

如果您想在spider中模拟HTML表单发布并发送几个键值字段,可以返回 FormRequest 像这样的物体:

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

使用formRequest.from_response()模拟用户登录

网站通常通过 <input 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/jsonAccept 报头到 application/json, text/javascript, */*; q=0.01

参数
  • data (object) -- 是需要对JSON编码并分配给主体的任何JSON可序列化对象。如果 Request.body 提供了参数。此参数将被忽略。如果 Request.body 未提供参数,并且提供了数据参数 Request.method 将被设置为 'POST' 自动地。

  • dumps_kwargs (dict) -- 将传递给基础的参数 json.dumps() 方法,用于将数据序列化为JSON格式。

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, **kwargs)[源代码]

A Response 对象表示一个HTTP响应,它通常被下载(由下载程序)并送入spider进行处理。

参数

2.1.0 新版功能: 这个 ip_address 参数。

url

包含响应的URL的字符串。

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

status

表示响应的HTTP状态的整数。例子: 200404 .

headers

包含响应头的类似字典的对象。可以使用访问值 get() 返回具有指定名称的第一个头值,或 getlist() 返回具有指定名称的所有头值。例如,此调用将为您提供标题中的所有cookie::

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

作为正文响应字节。

如果你想把身体作为一个字符串,使用 TextResponse.text (仅在 TextResponse 和子类)。

此属性是只读的。要更改响应主体,请使用 replace() .

request

这个 Request 生成此响应的对象。在响应和请求通过所有 Downloader Middlewares . 特别是,这意味着:

  • HTTP重定向将导致将原始请求(重定向前的URL)分配给重定向响应(重定向后的最终URL)。

  • response.request.url并不总是等于response.url

  • 此属性仅在spider代码和 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

A twisted.internet.ssl.Certificate 表示服务器的SSL证书的。

仅为填充 https 响应, None 否则。

ip_address

2.1.0 新版功能.

从哪个服务器发出响应的IP地址。

该属性目前只由http1.1下载处理程序填充,即 http(s) 响应。对于其他处理程序, ip_address 总是 None .

copy()[源代码]

返回此响应的副本的新响应。

replace([url, status, headers, body, request, flags, cls])[源代码]

返回具有相同成员的响应对象,除了那些通过指定的关键字参数赋予新值的成员。属性 Response.meta 默认情况下是复制的。

urljoin(url)[源代码]

通过组合响应的 url 有一个可能的相对URL。

这是包装纸 urljoin() ,这仅仅是进行此呼叫的别名:

urllib.parse.urljoin(response.url, url)
follow(url, callback=None, method='GET', headers=None, body=None, cookies=None, meta=None, encoding='utf-8', priority=0, dont_filter=False, errback=None, cb_kwargs=None, flags=None)[源代码]

返回A Request 要跟踪链接的实例 url . 它接受与 Request.__init__ 方法,但 url 可以是相对URL或 scrapy.link.Link 对象,而不仅仅是绝对URL。

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

2.0 新版功能: 这个 旗帜 参数。

follow_all(urls, callback=None, method='GET', headers=None, body=None, cookies=None, meta=None, encoding='utf-8', priority=0, dont_filter=False, errback=None, cb_kwargs=None, flags=None)[源代码]

2.0 新版功能.

返回iterable of Request 跟踪所有链接的实例 urls . 它接受与 Request.__init__ 方法,但元素 urls 可以是相对URL或 Link 对象,而不仅仅是绝对URL。

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

响应子类

下面是可用的内置响应子类的列表。您还可以对响应类进行子类化,以实现您自己的功能。

文本响应对象

class scrapy.http.TextResponse(url[, encoding[, ...]])[源代码]

TextResponse 对象将编码功能添加到基 Response 类,它只用于二进制数据,如图像、声音或任何媒体文件。

TextResponse 对象支持新的 __init__ 方法参数,以及基 Response 物体。其余功能与 Response 类,此处未记录。

参数

encoding (str) -- 包含用于此响应的编码的字符串。如果创建一个 TextResponse 对象,它将转换为使用此编码编码的字节。如果 编码None (默认),将在响应头和正文中查找编码。

TextResponse 除了标准之外,对象还支持以下属性 Response 一:

text

响应体,作为字符串。

一样 response.body.decode(response.encoding) ,但结果在第一次调用后缓存,因此您可以访问 response.text 多次无额外开销。

注解

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

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

带有此响应编码的字符串。按顺序尝试以下机制来解决编码问题:

  1. 传入的编码 __init__ 方法 encoding 参数

  2. 在内容类型HTTP标头中声明的编码。如果此编码无效(即未知),则忽略它并尝试下一个解析机制。

  3. 响应正文中声明的编码。TextResponse类不为此提供任何特殊功能。然而, HtmlResponseXmlResponse 上课。

  4. 通过查看响应主体推断出的编码。这是更脆弱的方法,也是最后一个尝试的方法。

selector

A Selector 使用响应作为目标的实例。选择器在第一次访问时被惰性地实例化。

TextResponse 对象除了支持标准之外还支持以下方法 Response 一:

xpath(query)[源代码]

捷径 TextResponse.selector.xpath(query) ::

response.xpath('//p')
css(query)[源代码]

捷径 TextResponse.selector.css(query) ::

response.css('p')
follow(url, callback=None, method='GET', headers=None, body=None, cookies=None, meta=None, encoding=None, priority=0, dont_filter=False, errback=None, cb_kwargs=None, flags=None)[源代码]

返回A Request 要跟踪链接的实例 url . 它接受与 Request.__init__ 方法,但 url 不仅可以是绝对URL,而且可以是

  • 相对URL

  • Link 对象,例如 链接提取器

  • Selector 对象 <link><a> 元素,例如 response.css('a.my_link')[0]

  • 属性 Selector (不是选择器列表),例如。 response.css('a::attr(href)')[0]response.xpath('//img/@src')[0]

创建请求的快捷方式 用于示例。

follow_all(urls=None, callback=None, method='GET', headers=None, body=None, cookies=None, meta=None, encoding=None, priority=0, dont_filter=False, errback=None, cb_kwargs=None, flags=None, css=None, xpath=None)[源代码]

产生 Request 跟踪所有链接的实例 urls . 它接受与 Request__init__ 方法,除了 urls 元素不需要是绝对URL,它可以是以下任何一个:

  • 相对URL

  • Link 对象,例如 链接提取器

  • Selector 对象 <link><a> 元素,例如 response.css('a.my_link')[0]

  • 属性 Selector (不是选择器列表),例如。 response.css('a::attr(href)')[0]response.xpath('//img/@src')[0]

此外, cssxpath 参数可用于在中执行链接提取 follow_all 方法(只有一个 urlscssxpath 接受)。

注意,当经过 SelectorList 作为 urls 参数或使用 cssxpath 参数时,此方法不会为无法从中获取链接的选择器生成请求(例如,没有 href 属性)

json()[源代码]

2.2 新版功能.

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

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

HTMLResponse对象

class scrapy.http.HtmlResponse(url[, ...])[源代码]

这个 HtmlResponse 类是的子类 TextResponse 它通过查看HTML添加了编码自动发现支持 meta http-equiv 属性。见 TextResponse.encoding .

XmlResponse对象

class scrapy.http.XmlResponse(url[, ...])[源代码]

这个 XmlResponse 类是的子类 TextResponse 它通过查看XML声明行添加了编码自动发现支持。见 TextResponse.encoding .