Scrapy – 快速指南

Scrapy – 概述

Scrapy 是一个用 Python 编写的快速、开源的网络爬虫框架，用于在基于 XPath 的选择器的帮助下从网页中提取数据。

Scrapy 于 2008 年 6 月 26 日首次发布，并在 BSD 下获得许可，并于 2015 年 6 月发布了里程碑 1.0。

为什么要使用 Scrapy？

• 更容易构建和扩展大型爬行项目。

• 它有一个称为选择器的内置机制，用于从网站中提取数据。

• 它异步处理请求并且速度很快。

• 它使用自动节流机制自动调整爬行速度。

• 确保开发人员的可访问性。

Scrapy 的特点

• Scrapy 是一个开源且免费使用的网络爬虫框架。

• Scrapy 以 JSON、CSV 和 XML 等格式生成提要导出。

• Scrapy 内置支持通过 XPath 或 CSS 表达式从源中选择和提取数据。

• 基于爬虫的 Scrapy，允许自动从网页中提取数据。

优点

• Scrapy 易于扩展、快速且功能强大。

• 它是一个跨平台的应用程序框架（Windows、Linux、Mac OS 和 BSD）。

• Scrapy 请求是异步调度和处理的。

• Scrapy 带有称为Scrapyd 的内置服务，它允许使用 JSON 网络服务上传项目和控制蜘蛛。

• 可以废弃任何网站，尽管该网站没有用于访问原始数据的 API。

缺点

• Scrapy 仅适用于 Python 2.7。+

• 不同操作系统的安装是不同的。

Scrapy – 环境

在本章中，我们将讨论如何安装和设置 Scrapy。Scrapy 必须与 Python 一起安装。

可以使用pip安装 Scrapy 。要安装，请运行以下命令 –

pip install Scrapy

视窗

注意– Windows 操作系统不支持 Python 3。

步骤 1 – 从Python安装 Python 2.7

通过将以下路径添加到 PATH 来设置环境变量 –

C:\Python27\;C:\Python27\Scripts\; 

您可以使用以下命令检查 Python 版本 –

python --version

第 2 步– 安装 OpenSSL。

在您的环境变量中添加 C:\OpenSSL-Win32\bin。

注– 除 Windows 外，所有操作系统都预装了 OpenSSL。

第 3 步– 安装Visual C++ 2008 可再发行组件。

步骤 4 – 安装pywin32。

第 5 步–为早于 2.7.9 的 Python 版本安装pip。

您可以使用以下命令检查 pip 版本 –

pip --version

第 6 步– 要安装 scrapy，请运行以下命令 –

pip install Scrapy

蟒蛇

如果您的机器上安装了anaconda或miniconda，请运行以下命令使用 conda 安装 Scrapy –

conda install -c scrapinghub scrapy 

Scrapinghub公司支持 Linux、Windows 和 OS X 的官方 conda 包。

注意– 如果您在通过 pip 安装时遇到问题，建议使用上述命令安装 Scrapy。

Ubuntu 9.10 或以上

最新版本的 Python 预装在 Ubuntu 操作系统上。使用 Scrapinghub 提供的 Ubuntu 包 aptgettable。使用软件包 –

步骤 1 – 您需要将用于将 Scrapy 包签名到 APT 密钥环的 GPG 密钥导入 –

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 627220E7

步骤 2 – 接下来，使用以下命令创建 /etc/apt/sources.list.d/scrapy.list 文件 –

echo 'deb http://archive.scrapy.org/ubuntu scrapy main' | sudo tee 
/etc/apt/sources.list.d/scrapy.list

步骤 3 – 更新包列表并安装scrapy –

sudo apt-get update && sudo apt-get install scrapy

Archlinux

您可以使用以下命令从 AUR Scrapy 包安装 Scrapy –

yaourt -S scrapy

Mac OS X

使用以下命令安装 Xcode 命令行工具 –

xcode-select --install 

不要使用系统 Python，而是安装一个与系统其余部分不冲突的新更新版本。

步骤 1 – 安装自制软件。

步骤 2 – 设置环境 PATH 变量以指定应在系统包之前使用自制程序包 –

echo "export PATH = /usr/local/bin:/usr/local/sbin:$PATH" >> ~/.bashrc

第 3 步– 为确保更改完成，请使用以下命令重新加载.bashrc –

source ~/.bashrc 

第 4 步– 接下来，使用以下命令安装 Python –

brew install python

步骤 5 – 使用以下命令安装 Scrapy –

pip install Scrapy

Scrapy – 命令行工具

描述

Scrapy 命令行工具用于控制 Scrapy，通常称为“Scrapy 工具”。它包括用于具有一组参数和选项的各种对象的命令。

配置设置

Scrapy 将在scrapy.cfg文件中找到配置设置。以下是几个地点 –

• 系统中的C:\scrapy（项目文件夹）\scrapy.cfg

• ~/.config/scrapy.cfg ($XDG_CONFIG_HOME) 和 ~/.scrapy.cfg ($HOME) 用于全局设置

• 您可以在项目的根目录中找到 scrapy.cfg。

Scrapy 也可以使用以下环境变量进行配置 –

• SCRAPY_SETTINGS_MODULE
• SCRAPY_PROJECT
• SCRAPY_PYTHON_SHELL

默认结构 Scrapy 项目

以下结构显示了 Scrapy 项目的默认文件结构。

scrapy.cfg                - Deploy the configuration file
project_name/             - Name of the project
   _init_.py
   items.py               - It is project's items file
   pipelines.py           - It is project's pipelines file
   settings.py            - It is project's settings file
   spiders                - It is the spiders directory
      _init_.py
      spider_name.py
      . . .

该scrapy.cfg文件是一个项目的根目录，其中包括与项目设置的项目名称。例如 –

[settings] 
default = [name of the project].settings  

[deploy] 
#url = http://localhost:6800/ 
project = [name of the project] 

使用 Scrapy 工具

Scrapy 工具提供了一些用法和可用命令，如下所示 –

Scrapy X.Y  - no active project 
Usage: 
   scrapy  [options] [arguments] 
Available commands: 
   crawl      It puts spider (handle the URL) to work for crawling data 
   fetch      It fetches the response from the given URL

创建项目

您可以使用以下命令在 Scrapy 中创建项目 –

scrapy startproject project_name

这将创建名为project_name目录的项目。接下来，使用以下命令转到新创建的项目 –

cd  project_name

控制项目

您可以使用 Scrapy 工具控制和管理项目，还可以使用以下命令创建新的蜘蛛 –

scrapy genspider mydomain mydomain.com

crawl等命令必须在Scrapy项目内部使用。在接下来的部分中，您将了解哪些命令必须在 Scrapy 项目中运行。

Scrapy 包含一些内置命令，可用于您的项目。要查看可用命令列表，请使用以下命令 –

scrapy -h

当您运行以下命令时，Scrapy 将显示列出的可用命令列表 –

• fetch – 它使用 Scrapy 下载器获取 URL。

• runspider – 它用于在不创建项目的情况下运行自包含的蜘蛛。

• settings – 它指定项目设置值。

• shell – 它是给定 URL 的交互式抓取模块。

• startproject – 它创建一个新的 Scrapy 项目。

• version – 它显示 Scrapy 版本。

• view – 它使用 Scrapy 下载器获取 URL 并在浏览器中显示内容。

您可以列出一些与项目相关的命令 –

• crawl – 它用于使用蜘蛛抓取数据。

• check – 它检查爬行命令返回的项目。

• list – 它显示项目中存在的可用蜘蛛列表。

• 编辑– 您可以使用编辑器编辑蜘蛛。

• parse – 它用蜘蛛解析给定的 URL。

• bench – 用于运行快速基准测试（基准测试告诉 Scrapy 每分钟可以抓取多少页面）。

自定义项目命令

您可以在 Scrapy 项目中使用COMMANDS_MODULE设置构建自定义项目命令。它在设置中包含一个默认的空字符串。您可以添加以下自定义命令 –

COMMANDS_MODULE = 'mycmd.commands'

可以使用 setup.py 文件中的 scrapy.commands 部分添加 Scrapy 命令，如下所示 –

from setuptools import setup, find_packages  

setup(name = 'scrapy-module_demo', 
   entry_points = { 
      'scrapy.commands': [ 
         'cmd_demo = my_module.commands:CmdDemo', 
      ], 
   }, 
)

上面的代码在setup.py文件中添加了cmd_demo命令。

Scrapy – 蜘蛛

描述

Spider 是一个类，负责定义如何通过网站跟踪链接并从页面中提取信息。

Scrapy 的默认蜘蛛如下 –

scrapy.Spider

它是所有其他蜘蛛都必须继承的蜘蛛。它有以下类 –

class scrapy.spiders.Spider

下表显示了 scrapy.Spider 类的字段 –

蜘蛛参数

Spider 参数用于指定起始 URL，并使用带有-a选项的crawl 命令传递，如下所示 –

scrapy crawl first_scrapy -a group = accessories

以下代码演示了蜘蛛如何接收参数 –

import scrapy 

class FirstSpider(scrapy.Spider): 
   name = "first" 
   
   def __init__(self, group = None, *args, **kwargs): 
      super(FirstSpider, self).__init__(*args, **kwargs) 
      self.start_urls = ["http://www.example.com/group/%s" % group]

通用蜘蛛

您可以使用通用蜘蛛从其子类化您的蜘蛛。他们的目标是根据某些规则跟踪网站上的所有链接，以从所有页面中提取数据。

对于以下蜘蛛中使用的示例，假设我们有一个包含以下字段的项目 –

import scrapy 
from scrapy.item import Item, Field 
  
class First_scrapyItem(scrapy.Item): 
   product_title = Field() 
   product_link = Field() 
   product_description = Field() 

爬行蜘蛛

CrawlSpider 定义了一组规则来跟踪链接并废弃多个页面。它有以下类 –

class scrapy.spiders.CrawlSpider

以下是 CrawlSpider 类的属性 –

规则

它是一个规则对象列表，用于定义爬虫如何跟踪链接。

下表显示了 CrawlSpider 类的规则 –

parse_start_url（响应）

它通过允许解析初始响应来返回项目或请求对象。

注意– 确保在编写规则时重命名 parse 函数而不是 parse ，因为 CrawlSpider 使用 parse 函数来实现其逻辑。

让我们看看下面的例子，蜘蛛开始抓取 demoexample.com 的主页，收集所有页面、链接，并使用parse_items方法解析–

import scrapy
from scrapy.spiders import CrawlSpider, Rule
from scrapy.linkextractors import LinkExtractor

class DemoSpider(CrawlSpider):
   name = "demo"
   allowed_domains = ["www.demoexample.com"]
   start_urls = ["http://www.demoexample.com"]
      
   rules = ( 
      Rule(LinkExtractor(allow =(), restrict_xpaths = ("//div[@class = 'next']",)),
         callback = "parse_item", follow = True),
   )
   
   def parse_item(self, response):
      item = DemoItem()
      item["product_title"] = response.xpath("a/text()").extract()
      item["product_link"] = response.xpath("a/@href").extract()
      item["product_description"] = response.xpath("div[@class = 'desc']/text()").extract()
      return items

XMLFeedSpider

它是从 XML 提要中抓取并遍历节点的蜘蛛的基类。它有以下类 –

class scrapy.spiders.XMLFeedSpider

下表显示了用于设置迭代器和标签名称的类属性 –

CSVFeedSpider

它遍历它的每一行，接收一个 CSV 文件作为响应，并调用parse_row()方法。它有以下类 –

class scrapy.spiders.CSVFeedSpider

下表显示了可以设置的关于 CSV 文件的选项 –

CSVFeedSpider 示例

from scrapy.spiders import CSVFeedSpider
from demoproject.items import DemoItem  

class DemoSpider(CSVFeedSpider): 
   name = "demo" 
   allowed_domains = ["www.demoexample.com"] 
   start_urls = ["http://www.demoexample.com/feed.csv"] 
   delimiter = ";" 
   quotechar = "'" 
   headers = ["product_title", "product_link", "product_description"]  
   
   def parse_row(self, response, row): 
      self.logger.info("This is row: %r", row)  
      item = DemoItem() 
      item["product_title"] = row["product_title"] 
      item["product_link"] = row["product_link"] 
      item["product_description"] = row["product_description"] 
      return item

网站地图蜘蛛

SitemapSpider 在站点地图的帮助下通过从 robots.txt 中定位 URL 来抓取网站。它有以下类 –

class scrapy.spiders.SitemapSpider

下表显示了 SitemapSpider 的字段 –

站点地图Spider 示例

以下 SitemapSpider 处理所有 URL –

from scrapy.spiders import SitemapSpider  

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/sitemap.xml"]  
   
   def parse(self, response): 
      # You can scrap items here

以下 SitemapSpider 使用回调处理一些 URL –

from scrapy.spiders import SitemapSpider  

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/sitemap.xml"] 
   
   rules = [ 
      ("/item/", "parse_item"), 
      ("/group/", "parse_group"), 
   ]  
   
   def parse_item(self, response): 
      # you can scrap item here  
   
   def parse_group(self, response): 
      # you can scrap group here 

以下代码显示了 robots.txt 中的站点地图，其 URL 为/sitemap_company –

from scrapy.spiders import SitemapSpider

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/robots.txt"] 
   rules = [ 
      ("/company/", "parse_company"), 
   ] 
   sitemap_follow = ["/sitemap_company"]  
   
   def parse_company(self, response): 
      # you can scrap company here 

您甚至可以将 SitemapSpider 与其他 URL 结合，如以下命令所示。

from scrapy.spiders import SitemapSpider  

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/robots.txt"] 
   rules = [ 
      ("/company/", "parse_company"), 
   ]  
   
   other_urls = ["http://www.demoexample.com/contact-us"] 
   def start_requests(self): 
      requests = list(super(DemoSpider, self).start_requests()) 
      requests += [scrapy.Request(x, self.parse_other) for x in self.other_urls] 
      return requests 

   def parse_company(self, response): 
      # you can scrap company here... 

   def parse_other(self, response): 
      # you can scrap other here... 

Scrapy – 选择器

描述

当您抓取网页时，您需要使用称为选择器的机制来提取 HTML 源的某个部分，该机制通过使用 XPath 或 CSS 表达式来实现。选择器建立在lxml库之上，该库处理 Python 语言中的 XML 和 HTML。

使用以下代码片段来定义选择器的不同概念 –

<html>
   <head>
      <title>My Website</title>
   </head>
   
   <body>
      <span>Hello world!!!</span>
      <div class = 'links'>
         <a href = 'one.html'>Link 1<img src = 'image1.jpg'/></a>
         <a href = 'two.html'>Link 2<img src = 'image2.jpg'/></a>
         <a href = 'three.html'>Link 3<img src = 'image3.jpg'/></a>
      </div>
   </body>
</html>

构造选择器

您可以通过传递文本或TextResponse对象来构造选择器类实例。根据提供的输入类型，选择器选择以下规则 –

from scrapy.selector import Selector 
from scrapy.http import HtmlResponse

使用上面的代码，您可以从文本中构造为 –

Selector(text = body).xpath('//span/text()').extract() 

它将结果显示为 –

[u'Hello world!!!'] 

您可以从响应中构建为 –

response = HtmlResponse(url = 'http://mysite.com', body = body) 
Selector(response = response).xpath('//span/text()').extract()

它将结果显示为 –

[u'Hello world!!!']

使用选择器

使用上面的简单代码片段，您可以构建用于选择标题标签中定义的文本的 XPath，如下所示 –

>>response.selector.xpath('//title/text()')

现在，您可以使用.extract()方法提取文本数据，如下所示 –

>>response.xpath('//title/text()').extract()

它将产生的结果为 –

[u'My Website']

您可以显示所有元素的名称，如下所示 –

>>response.xpath('//div[@class = "links"]/a/text()').extract() 

它将元素显示为 –

Link 1
Link 2
Link 3

如果要提取第一个元素，请使用方法.extract_first()，如下所示 –

>>response.xpath('//div[@class = "links"]/a/text()').extract_first()

它将元素显示为 –

Link 1

嵌套选择器

使用上面的代码，您可以使用.xpath()方法嵌套选择器以显示页面链接和图像源，如下所示 –

links = response.xpath('//a[contains(@href, "image")]') 

for index, link in enumerate(links): 
   args = (index, link.xpath('@href').extract(), link.xpath('img/@src').extract()) 
   print 'The link %d pointing to url %s and image %s' % args 

它将结果显示为 –

Link 1 pointing to url [u'one.html'] and image [u'image1.jpg']
Link 2 pointing to url [u'two.html'] and image [u'image2.jpg']
Link 3 pointing to url [u'three.html'] and image [u'image3.jpg']

使用正则表达式的选择器

Scrapy 允许使用使用.re()方法的正则表达式提取数据。从上面的 HTML 代码中，我们将提取如下所示的图像名称 –

>>response.xpath('//a[contains(@href, "image")]/text()').re(r'Name:\s*(.*)')

上面的行将图像名称显示为 –

[u'Link 1', 
u'Link 2', 
u'Link 3'] 

使用相对 XPath

当您使用以/开头的 XPath 时，嵌套选择器和 XPath 与文档的绝对路径相关，而不是选择器的相对路径。

如果要提取<p>元素，则首先获取所有 div 元素 –

>>mydiv = response.xpath('//div')

接下来，您可以通过在 XPath 前面加上一个点作为.//p来提取里面的所有‘p’元素，如下所示 –

>>for p in mydiv.xpath('.//p').extract() 

使用 EXSLT 扩展

EXSLT 是一个社区，它发布 XSLT（可扩展样式表语言转换）的扩展，将 XML 文档转换为 XHTML 文档。您可以在 XPath 表达式中使用 EXSLT 扩展和注册的命名空间，如下表所示 –

您可以查看上一节中使用正则表达式提取数据的简单代码格式。

有一些 XPath 技巧，它们在将 XPath 与 Scrapy 选择器一起使用时很有用。有关更多信息，请单击此链接。

Scrapy – 物品

描述

Scrapy 过程可用于使用蜘蛛从网页等来源提取数据。Scrapy 使用Item类生成输出，其对象用于收集抓取的数据。

申报项目

您可以使用类定义语法以及如下所示的字段对象来声明项目 –

import scrapy 
class MyProducts(scrapy.Item): 
   productName = Field() 
   productLink = Field() 
   imageURL = Field() 
   price = Field() 
   size = Field() 

项目字段

项目字段用于显示每个字段的元数据。由于字段对象的值没有限制，可访问的元数据键不包含任何元数据的引用列表。字段对象用于指定所有字段元数据，您可以根据项目中的要求指定任何其他字段键。可以使用 Item.fields 属性访问字段对象。

处理项目

当您使用这些项目时，可以定义一些常见的功能。有关更多信息，请单击此链接。

扩展项目

可以通过声明原始项目的子类来扩展项目。例如 –

class MyProductDetails(Product): 
   original_rate = scrapy.Field(serializer = str) 
   discount_rate = scrapy.Field()

您可以使用现有字段元数据通过添加更多值或更改现有值来扩展字段元数据，如下面的代码所示 –

class MyProductPackage(Product): 
   name = scrapy.Field(Product.fields['name'], serializer = serializer_demo)

项目对象

可以使用以下类指定项目对象，该类从给定参数提供新的初始化项目 –

class scrapy.item.Item([arg])

Item 提供构造函数的副本，并提供由字段中的项提供的额外属性。

字段对象

可以使用以下类指定字段对象，其中 Field 类不发出额外的过程或属性 –

class scrapy.item.Field([arg])

Scrapy – 物品加载器

描述

项目加载器提供了一种方便的方式来填充从网站上抓取的项目。

声明项目加载器

Item Loaders 的声明就像 Items。

例如 –

from scrapy.loader import ItemLoader 
from scrapy.loader.processors import TakeFirst, MapCompose, Join  

class DemoLoader(ItemLoader):  
   default_output_processor = TakeFirst()  
   title_in = MapCompose(unicode.title) 
   title_out = Join()  
   size_in = MapCompose(unicode.strip)  
   # you can continue scraping here

在上面的代码中，您可以看到输入处理器使用_in后缀声明，输出处理器使用_out后缀声明。

的ItemLoader.default_input_processor和ItemLoader.default_output_processor属性用于声明默认输入/输出处理器。

使用项目加载器来填充项目

要使用 Item Loader，首先使用类似 dict 的对象进行实例化，或者在项目使用ItemLoader.default_item_class属性中指定的 Item 类的情况下不进行实例化。

• 您可以使用选择器将值收集到项目加载器中。

• 您可以在同一项目字段中添加更多值，其中项目加载器将使用适当的处理程序来添加这些值。

以下代码演示了如何使用项目加载器填充项目 –

from scrapy.loader import ItemLoader 
from demoproject.items import Demo  

def parse(self, response): 
   l = ItemLoader(item = Product(), response = response)
   l.add_xpath("title", "//div[@class = 'product_title']")
   l.add_xpath("title", "//div[@class = 'product_name']")
   l.add_xpath("desc", "//div[@class = 'desc']")
   l.add_css("size", "div#size]")
   l.add_value("last_updated", "yesterday")
   return l.load_item()

如上所示，使用add_xpath()方法从两个不同的 XPath中提取标题字段–

1. //div[@class = "product_title"] 

2. //div[@class = "product_name"]

此后，类似的请求用于desc字段。大小数据是使用提取add_css（）方法和LAST_UPDATED填充有值“昨天”使用add_value（）方法。

收集所有数据后，调用ItemLoader.load_item()方法，该方法返回填充了使用add_xpath()、add_css()和add_value()方法提取的数据的项目。

输入和输出处理器

Item Loader 的每个字段都包含一个输入处理器和一个输出处理器。

• 提取数据时，输入处理器对其进行处理，并将其结果存储在 ItemLoader 中。

• 接下来，收集数据后，调用 ItemLoader.load_item() 方法获取填充的 Item 对象。

• 最后，您可以将输出处理器的结果分配给项目。

以下代码演示了如何为特定字段调用输入和输出处理器 –

l = ItemLoader(Product(), some_selector)
l.add_xpath("title", xpath1) # [1]
l.add_xpath("title", xpath2) # [2]
l.add_css("title", css)      # [3]
l.add_value("title", "demo") # [4]
return l.load_item()         # [5]

第 1 行– 从 xpath1 中提取标题数据并通过输入处理器，其结果被收集并存储在 ItemLoader 中。

第 2 行– 类似地，标题从 xpath2 中提取并通过相同的输入处理器，其结果被添加到为 [1] 收集的数据中。

第 3 行– 从 css 选择器中提取标题并通过相同的输入处理器，并将结果添加到为 [1] 和 [2] 收集的数据中。

第 4 行– 接下来，分配值“演示”并通过输入处理器传递。

第 5 行– 最后，从所有字段内部收集数据并传递给输出处理器，并将最终值分配给项目。

声明输入和输出处理器

输入和输出处理器在 ItemLoader 定义中声明。除此之外，它们还可以在项目字段元数据中指定。

例如 –

import scrapy 
from scrapy.loader.processors import Join, MapCompose, TakeFirst 
from w3lib.html import remove_tags  

def filter_size(value): 
   if value.isdigit(): 
      return value  

class Item(scrapy.Item): 
   name = scrapy.Field( 
      input_processor = MapCompose(remove_tags), 
      output_processor = Join(), 
   )
   size = scrapy.Field( 
      input_processor = MapCompose(remove_tags, filter_price), 
      output_processor = TakeFirst(), 
   ) 

>>> from scrapy.loader import ItemLoader 
>>> il = ItemLoader(item = Product()) 
>>> il.add_value('title', [u'Hello', u'<strong>world</strong>']) 
>>> il.add_value('size', [u'<span>100 kg</span>']) 
>>> il.load_item()

它显示输出为 –

{'title': u'Hello world', 'size': u'100 kg'}

项目加载器上下文

项目加载器上下文是输入和输出处理器之间共享的任意键值的字典。

例如，假设您有一个函数parse_length –

def parse_length(text, loader_context): 
   unit = loader_context.get('unit', 'cm') 
   
   # You can write parsing code of length here  
   return parsed_length

通过接收 loader_context 参数，它告诉 Item Loader 它可以接收 Item Loader 上下文。有几种方法可以更改项目加载器上下文的值 –

• 修改当前活动的项目加载器上下文 –

loader = ItemLoader (product)
loader.context ["unit"] = "mm"

• 在项目加载器实例化 –

loader = ItemLoader(product, unit = "mm")

• 关于使用 Item Loader 上下文实例化的输入/输出处理器的 Item Loader 声明 –

class ProductLoader(ItemLoader):
   length_out = MapCompose(parse_length, unit = "mm")

ItemLoader 对象

它是一个对象，它返回一个新的项目加载器来填充给定的项目。它有以下类 –

class scrapy.loader.ItemLoader([item, selector, response, ]**kwargs)

下表显示了 ItemLoader 对象的参数 –

下表显示了 ItemLoader 对象的方法 –

>>> from scrapy.loader.processors import TakeFirst
>>> loader.get_value(u'title: demoweb', TakeFirst(), 
unicode.upper, re = 'title: (.+)')
'DEMOWEB`

loader.add_value('title', u'DVD')
loader.add_value('colors', [u'black', u'white'])
loader.add_value('length', u'80')
loader.add_value('price', u'2500')

loader.replace_value('title', u'DVD')
loader.replace_value('colors', [u'black', 
u'white'])
loader.replace_value('length', u'80')
loader.replace_value('price', u'2500')

# HTML code: <div class = "item-name">DVD</div>
loader.get_xpath("//div[@class = 
'item-name']")

# HTML code: <div id = "length">the length is 
45cm</div>
loader.get_xpath("//div[@id = 'length']", TakeFirst(), 
re = "the length is (.*)")

# HTML code: <div class = "item-name">DVD</div>
loader.add_xpath('name', '//div
[@class = "item-name"]')

# HTML code: <div id = "length">the length is 
45cm</div>
loader.add_xpath('length', '//div[@id = "length"]',
 re = 'the length is (.*)')

# HTML code: <div class = "item-name">DVD</div>
loader.replace_xpath('name', '
//div[@class = "item-name"]')

# HTML code: <div id = "length">the length is
 45cm</div>
loader.replace_xpath('length', '
//div[@id = "length"]', re = 'the length is (.*)')

loader.get_css("div.item-name")
loader.get_css("div#length", TakeFirst(), 
re = "the length is (.*)")

loader.add_css('name', 'div.item-name')
loader.add_css('length', 'div#length', 
re = 'the length is (.*)')

loader.replace_css('name', 'div.item-name')
loader.replace_css('length', 'div#length',
 re = 'the length is (.*)')

def parse(self, response):
l = ItemLoader(item = Product(), 
response = response)
l.add_xpath('title', '//
div[@class = "product_title"]')
loader.load_item()

loader = ItemLoader(item = Item())
loader.add_xpath('social', '
a[@class = "social"]/@href')
loader.add_xpath('email', '
a[@class = "email"]/@href')

loader = ItemLoader(item = Item())
loader.add_css('social', 'a[@class = "social"]/@href')
loader.add_css('email', 'a[@class = "email"]/@href')	

下表显示了 ItemLoader 对象的属性 –

嵌套加载器

它用于在解析文档子部分的值时创建嵌套加载器。如果不创建嵌套加载器，则需要为要提取的每个值指定完整的 XPath 或 CSS。

例如，假设数据是从标题页中提取的 –

<header>
   <a class = "social" href = "http://facebook.com/whatever">facebook</a>
   <a class = "social" href = "http://twitter.com/whatever">twitter</a>
   <a class = "email" href = "mailto:[email protected]">send mail</a>
</header>

接下来，您可以通过向标题添加相关值来创建带有标题选择器的嵌套加载器 –

loader = ItemLoader(item = Item())
header_loader = loader.nested_xpath('//header')
header_loader.add_xpath('social', 'a[@class = "social"]/@href')
header_loader.add_xpath('email', 'a[@class = "email"]/@href')
loader.load_item()

重用和扩展项目加载器

项目加载器旨在减轻维护，当您的项目获得更多蜘蛛时，维护成为一个基本问题。

例如，假设一个站点的产品名称用三个短划线括起来（例如–DVD—）。如果您不希望在最终产品名称中使用默认的 Product Item Loader，您可以通过重用默认的 Product Item Loader 来删除这些破折号，如下面的代码所示 –

from scrapy.loader.processors import MapCompose 
from demoproject.ItemLoaders import DemoLoader  

def strip_dashes(x): 
   return x.strip('-')  

class SiteSpecificLoader(DemoLoader): 
   title_in = MapCompose(strip_dashes, DemoLoader.title_in)

可用的内置处理器

以下是一些常用的内置处理器 –

类scrapy.loader.processors.Identity

它返回原始值而不更改它。例如 –

>>> from scrapy.loader.processors import Identity
>>> proc = Identity()
>>> proc(['a', 'b', 'c'])
['a', 'b', 'c']

类scrapy.loader.processors.TakeFirst

它从接收到的值列表中返回第一个非空/非空的值。例如 –

>>> from scrapy.loader.processors import TakeFirst
>>> proc = TakeFirst()
>>> proc(['', 'a', 'b', 'c'])
'a'

类scrapy.loader.processors.Join(separator = u’ ‘)

它返回附加到分隔符的值。默认分隔符是 u’ ‘，它等效于函数u’ ‘.join。例如 –

>>> from scrapy.loader.processors import Join
>>> proc = Join()
>>> proc(['a', 'b', 'c'])
u'a b c'
>>> proc = Join('<br>')
>>> proc(['a', 'b', 'c'])
u'a<br>b<br>c'

class scrapy.loader.processors.Compose(*functions, **default_loader_context)

它由处理器定义，其中每个输入值都传递给第一个函数，该函数的结果传递给第二个函数，依此类推，直到 ast 函数返回最终值作为输出。

例如 –

>>> from scrapy.loader.processors import Compose
>>> proc = Compose(lambda v: v[0], str.upper)
>>> proc(['python', 'scrapy'])
'PYTHON'

class scrapy.loader.processors.MapCompose(*functions, **default_loader_context)

它是一个处理器，其中迭代输入值并将第一个函数应用于每个元素。接下来，将这些函数调用的结果连接起来以构建新的可迭代对象，然后将其应用于第二个函数，依此类推，直到最后一个函数。

例如 –

>>> def filter_scrapy(x): 
   return None if x == 'scrapy' else x  

>>> from scrapy.loader.processors import MapCompose 
>>> proc = MapCompose(filter_scrapy, unicode.upper) 
>>> proc([u'hi', u'everyone', u'im', u'pythonscrapy']) 
[u'HI, u'IM', u'PYTHONSCRAPY'] 

类scrapy.loader.processors.SelectJmes(json_path)

此类使用提供的 json 路径查询值并返回输出。

例如 –

>>> from scrapy.loader.processors import SelectJmes, Compose, MapCompose
>>> proc = SelectJmes("hello")
>>> proc({'hello': 'scrapy'})
'scrapy'
>>> proc({'hello': {'scrapy': 'world'}})
{'scrapy': 'world'}

以下是通过导入 json 查询值的代码 –

>>> import json
>>> proc_single_json_str = Compose(json.loads, SelectJmes("hello"))
>>> proc_single_json_str('{"hello": "scrapy"}')
u'scrapy'
>>> proc_json_list = Compose(json.loads, MapCompose(SelectJmes('hello')))
>>> proc_json_list('[{"hello":"scrapy"}, {"world":"env"}]')
[u'scrapy']

Scrapy – 壳

描述

Scrapy shell 可用于清除具有无错误代码的数据，而无需使用蜘蛛。Scrapy shell 的主要目的是测试提取的代码、XPath 或 CSS 表达式。它还有助于指定您从中抓取数据的网页。

配置外壳

可以通过安装IPython（用于交互式计算）控制台来配置 shell ，这是一个强大的交互式 shell，提供自动完成、彩色输出等。

如果您在 Unix 平台上工作，那么最好安装 IPython。如果 IPython 无法访问，您也可以使用bpython。

您可以通过设置名为 SCRAPY_PYTHON_SHELL 的环境变量或通过如下定义 scrapy.cfg 文件来配置 shell –

[settings]
shell = bpython

启动外壳

可以使用以下命令启动 Scrapy shell –

scrapy shell <url>

该URL指定的URL，该数据需要被刮掉。

使用外壳

shell 提供了一些额外的快捷方式和 Scrapy 对象，如下表所述 –

可用的快捷方式

Shell 在项目中提供了以下可用的快捷方式 –

可用的 Scrapy 对象

Shell 在项目中提供了以下可用的 Scrapy 对象 –

Shell 会话示例

让我们尝试抓取 scrapy.org 站点，然后按照描述开始从 reddit.com 抓取数据。

在继续之前，首先我们将启动 shell，如以下命令所示 –

scrapy shell 'http://scrapy.org' --nolog

Scrapy 将在使用上述 URL 时显示可用对象 –

[s] Available Scrapy objects:
[s]   crawler    <scrapy.crawler.Crawler object at 0x1e16b50>
[s]   item       {}
[s]   request    <GET http://scrapy.org >
[s]   response   <200 http://scrapy.org >
[s]   settings   <scrapy.settings.Settings object at 0x2bfd650>
[s]   spider     <Spider 'default' at 0x20c6f50>
[s] Useful shortcuts:
[s]   shelp()           Provides available objects and shortcuts with help option
[s]   fetch(req_or_url) Collects the response from the request or URL and associated 
objects will get update
[s]   view(response)    View the response for the given request

接下来，从对象的工作开始，如下所示 –

>> response.xpath('//title/text()').extract_first() 
u'Scrapy | A Fast and Powerful Scraping and Web Crawling Framework'  
>> fetch("http://reddit.com") 
[s] Available Scrapy objects: 
[s]   crawler     
[s]   item       {} 
[s]   request     
[s]   response   <200 https://www.reddit.com/> 
[s]   settings    
[s]   spider      
[s] Useful shortcuts: 
[s]   shelp()           Shell help (print this help) 
[s]   fetch(req_or_url) Fetch request (or URL) and update local objects 
[s]   view(response)    View response in a browser  
>> response.xpath('//title/text()').extract() 
[u'reddit: the front page of the internet']  
>> request = request.replace(method="POST")  
>> fetch(request) 
[s] Available Scrapy objects: 
[s]   crawler     
... 

从 Spider 中调用 Shell 来检查响应

您可以检查从蜘蛛程序处理的响应，仅当您希望获得该响应时。

例如 –

import scrapy 

class SpiderDemo(scrapy.Spider): 
   name = "spiderdemo" 
   start_urls = [ 
      "http://mysite.com", 
      "http://mysite1.org", 
      "http://mysite2.net", 
   ]  
   
   def parse(self, response): 
      # You can inspect one specific response 
      if ".net" in response.url: 
         from scrapy.shell import inspect_response 
         inspect_response(response, self)

如上面的代码所示，您可以使用以下函数从蜘蛛中调用 shell 来检查响应 –

scrapy.shell.inspect_response

现在运行蜘蛛，你会得到以下屏幕 –

2016-02-08 18:15:20-0400 [scrapy] DEBUG: Crawled (200)  (referer: None) 
2016-02-08 18:15:20-0400 [scrapy] DEBUG: Crawled (200)  (referer: None) 
2016-02-08 18:15:20-0400 [scrapy] DEBUG: Crawled (200)  (referer: None) 
[s] Available Scrapy objects: 
[s]   crawler     
...  
>> response.url 
'http://mysite2.org' 

您可以使用以下代码检查提取的代码是否正常工作 –

>> response.xpath('//div[@class = "val"]')

它将输出显示为

[]

上面的行只显示了一个空白输出。现在您可以调用 shell 来检查响应，如下所示 –

>> view(response)

它将响应显示为

True

Scrapy – 项目管道

描述

项目管道是一种处理报废项目的方法。当一个项目被发送到项目管道时，它会被蜘蛛抓取并使用多个组件进行处理，这些组件是顺序执行的。

每当收到物品时，它会决定以下任一操作 –

• 继续处理该项目。
• 从管道中删除它。
• 停止处理该项目。

项目管道通常用于以下目的 –

• 将抓取的项目存储在数据库中。
• 如果收到的项目是重复的，那么它将丢弃重复的项目。
• 它将检查项目是否具有目标字段。
• 清除 HTML 数据。

句法

您可以使用以下方法编写项目管道 –

process_item(self, item, spider) 

上述方法包含以下参数 –

• 项目（项目对象或字典）- 它指定刮取的项目。
• spider (spider object) – 抓取物品的蜘蛛。

您可以使用下表中给出的其他方法 –

例子

以下是不同概念中使用的项目管道示例。

丢弃没有标签的物品

在下面的代码中，管道平衡那些不包括增值税（excludes_vat 属性）的项目的（价格）属性并忽略那些没有价格标签的项目 –

from Scrapy.exceptions import DropItem  
class PricePipeline(object): 
   vat = 2.25 

   def process_item(self, item, spider): 
      if item['price']: 
         if item['excludes_vat']: 
            item['price'] = item['price'] * self.vat 
            return item 
         else: 
            raise DropItem("Missing price in %s" % item) 

将项目写入 JSON 文件

以下代码将从所有爬虫中抓取的所有项目存储到单个items.jl文件中，该文件以 JSON 格式的序列化形式每行包含一个项目。该JsonWriterPipeline类代码用来展示如何编写项目管道-

import json  

class JsonWriterPipeline(object): 
   def __init__(self): 
      self.file = open('items.jl', 'wb') 

   def process_item(self, item, spider): 
      line = json.dumps(dict(item)) + "\n" 
      self.file.write(line) 
      return item

将项目写入 MongoDB

您可以在 Scrapy 设置中指定 MongoDB 地址和数据库名称，MongoDB 集合可以以项目类命名。以下代码描述了如何使用from_crawler()方法正确收集资源 –

import pymongo  

class MongoPipeline(object):  
   collection_name = 'Scrapy_list' 

   def __init__(self, mongo_uri, mongo_db): 
      self.mongo_uri = mongo_uri 
      self.mongo_db = mongo_db 

   @classmethod 
   def from_crawler(cls, crawler): 
      return cls( 
         mongo_uri = crawler.settings.get('MONGO_URI'), 
         mongo_db = crawler.settings.get('MONGO_DB', 'lists') 
      ) 
  
   def open_spider(self, spider): 
      self.client = pymongo.MongoClient(self.mongo_uri) 
      self.db = self.client[self.mongo_db] 

   def close_spider(self, spider): 
      self.client.close() 

   def process_item(self, item, spider): 
      self.db[self.collection_name].insert(dict(item)) 
      return item

复制过滤器

过滤器将检查重复的项目，并删除已处理的项目。在下面的代码中，我们为我们的项目使用了一个唯一的 id，但蜘蛛返回了许多具有相同 id 的项目 –

from scrapy.exceptions import DropItem  

class DuplicatesPipeline(object):  
   def __init__(self): 
      self.ids_seen = set() 

   def process_item(self, item, spider): 
      if item['id'] in self.ids_seen: 
         raise DropItem("Repeated items found: %s" % item) 
      else: 
         self.ids_seen.add(item['id']) 
         return item

激活项目管道

您可以通过将其类添加到ITEM_PIPELINES设置来激活 Item Pipeline 组件，如以下代码所示。您可以按照类运行的顺序将整数值分配给它们（顺序可以是较低值的类），并且值将在 0-1000 范围内。

ITEM_PIPELINES = {
   'myproject.pipelines.PricePipeline': 100,
   'myproject.pipelines.JsonWriterPipeline': 600,
}

Scrapy – 饲料出口

描述

Feed 导出是一种存储从站点抓取的数据的方法，即生成“导出文件”。

序列化格式

使用多种序列化格式和存储后端，Feed Exports 使用项目导出器并生成带有抓取项目的提要。

下表显示了支持的格式 –

使用FEED_EXPORTERS设置，还可以扩展支持的格式 –

存储后端

存储后端定义使用 URI 存储提要的位置。

下表显示了支持的存储后端 –

存储 URI 参数

以下是存储 URL 的参数，在创建提要时会被替换 –

• %(time)s：这个参数被一个时间戳替换。
• %(name)s：这个参数被蜘蛛名替换。

设置

下表显示了可以配置 Feed 导出的设置 –

Scrapy – 请求和响应

描述

Scrapy 可以使用Request和Response对象抓取网站。请求对象通过系统，使用蜘蛛来执行请求并在返回响应对象时返回请求。

请求对象

请求对象是生成响应的 HTTP 请求。它有以下类 –

class scrapy.http.Request(url[, callback, method = 'GET', headers, body, cookies, meta,
   encoding = 'utf-8', priority = 0, dont_filter = False, errback])

下表显示了请求对象的参数 –

将附加数据传递给回调函数

当响应作为第一个参数被下载时，请求的回调函数被调用。

例如 –

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

def parse_page2(self, response): 
   self.logger.info("%s page visited", response.url) 

如果要将参数传递给可调用函数并在第二个回调中接收这些参数，则可以使用Request.meta属性，如下例所示 –

def parse_page1(self, response): 
   item = DemoItem() 
   item['foremost_link'] = response.url 
   request = scrapy.Request("http://www.something.com/some_page.html", 
      callback = self.parse_page2) 
   request.meta['item'] = item 
   return request  

def parse_page2(self, response): 
   item = response.meta['item'] 
   item['other_link'] = response.url 
   return item

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

errback 是一个可调用的函数，当处理请求时出现异常时会被调用。

以下示例演示了这一点 –

import scrapy  

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

class DemoSpider(scrapy.Spider): 
   name = "demo" 
   start_urls = [ 
      "http://www.httpbin.org/",              # HTTP 200 expected 
      "http://www.httpbin.org/status/404",    # Webpage not found  
      "http://www.httpbin.org/status/500",    # Internal server error 
      "http://www.httpbin.org:12345/",        # 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('Recieved response from {}'.format(response.url)) 
      # ...  
   
   def errback_httpbin(self, failure): 
      # logs failures 
      self.logger.error(repr(failure))  
      
      if failure.check(HttpError): 
         response = failure.value.response 
         self.logger.error("HttpError occurred on %s", response.url)  
      
      elif failure.check(DNSLookupError): 
         request = failure.request 
         self.logger.error("DNSLookupError occurred on %s", request.url) 

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

Request.meta 特殊键

request.meta 特殊键是由 Scrapy 识别的特殊元键列表。

下表显示了 Request.meta 的一些键 –

请求子类

您可以通过子类化请求类来实现您自己的自定义功能。内置请求子类如下 –

表单请求对象

FormRequest 类通过扩展基本请求来处理 HTML 表单。它有以下类 –

class scrapy.http.FormRequest(url[,formdata, callback, method = 'GET', headers, body, 
   cookies, meta, encoding = 'utf-8', priority = 0, dont_filter = False, errback])

以下是参数 –

formdata – 它是一个字典，具有分配给请求正文的 HTML 表单数据。

注意– 其余参数与请求类相同，并在请求对象部分进行了解释。

除了请求方法之外，FormRequest对象还支持以下类方法 –

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

下表显示了上述类的参数 –

例子

以下是一些请求使用示例 –

使用 FormRequest 通过 HTTP POST 发送数据

以下代码演示了如何在蜘蛛中复制 HTML 表单 POST 时返回FormRequest对象 –

return [FormRequest(url = "http://www.something.com/post/action", 
   formdata = {'firstname': 'John', 'lastname': 'dave'}, 
   callback = self.after_post)]

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

通常，网站使用元素来提供预填充的表单字段。

该FormRequest.form_response（）当你想这些字段是刮的同时自动填充方法可以使用。

以下示例演示了这一点。

import scrapy  
class DemoSpider(scrapy.Spider): 
   name = 'demo' 
   start_urls = ['http://www.something.com/users/login.php']  
   def parse(self, response): 
      return scrapy.FormRequest.from_response( 
         response, 
         formdata = {'username': 'admin', 'password': 'confidential'}, 
         callback = self.after_login 
      )  
   
   def after_login(self, response): 
      if "authentication failed" in response.body: 
         self.logger.error("Login failed") 
         return  
      # You can continue scraping here

响应对象

它是一个对象，指示提供给蜘蛛程序进行处理的 HTTP 响应。它有以下类 –

class scrapy.http.Response(url[, status = 200, headers, body, flags])

下表显示了响应对象的参数 –

响应子类

您可以通过继承响应类来实现您自己的自定义功能。内置响应子类如下 –

文本响应对象

TextResponse 对象用于二进制数据，例如图像、声音等，它具有对基本 Response 类进行编码的能力。它有以下类 –

class scrapy.http.TextResponse(url[, encoding[,status = 200, headers, body, flags]])

以下是参数 –

encoding – 它是一个带有编码的字符串，用于对响应进行编码。

注意– 其余参数与响应类相同，在响应对象部分进行了解释。

下表显示了 TextResponse 对象支持的属性以及响应方法 –

下表显示了除响应方法之外TextResponse对象支持的方法 –

HtmlResponse 对象

它是一个通过查看HTML的元 httpequiv属性来支持编码和自动发现的对象。它的参数与响应类相同，在响应对象部分进行了解释。它有以下类 –

class scrapy.http.HtmlResponse(url[,status = 200, headers, body, flags])

XmlResponse 对象

它是一个支持通过查看 XML 行进行编码和自动发现的对象。它的参数与响应类相同，在响应对象部分进行了解释。它有以下类 –

class scrapy.http.XmlResponse(url[, status = 200, headers, body, flags])

Scrapy – 链接提取器

描述

顾名思义，链接提取器是用于使用scrapy.http.Response对象从网页中提取链接的对象。在 Scrapy 中，有内置的提取器，例如scrapy.linkextractors import LinkExtractor。您可以通过实现一个简单的界面，根据您的需要自定义您自己的链接提取器。

每个链接提取器都有一个名为extract_links的公共方法，它包含一个 Response 对象并返回一个 scrapy.link.Link 对象列表。您只能实例化链接提取器一次并多次调用 extract_links 方法以提取具有不同响应的链接。CrawlSpider 类使用带有一组规则的链接提取器，其主要目的是提取链接。

内置链接提取器的参考

通常链接提取器与 Scrapy 组合在一起，并在 scrapy.linkextractors 模块中提供。默认情况下，链接提取器将是 LinkExtractor，其功能与 LxmlLinkExtractor 相同 –

from scrapy.linkextractors import LinkExtractor

Lxml链接提取器

class scrapy.linkextractors.lxmlhtml.LxmlLinkExtractor(allow = (), deny = (), 
   allow_domains = (), deny_domains = (), deny_extensions = None, restrict_xpaths = (), 
   restrict_css = (), tags = ('a', 'area'), attrs = ('href', ), 
   canonicalize = True, unique = True, process_value = None)

该LxmlLinkExtractor是一个高度推荐的链接提取，因为它具有方便的过滤选项，它是用来与LXML强大的HTMLParser的。

例子

以下代码用于提取链接 –

<a href = "javascript:goToPage('../other/page.html'); return false">Link text</a>

以下代码函数可用于 process_value –

def process_value(val): 
   m = re.search("javascript:goToPage\('(.*?)'", val) 
   if m: 
      return m.group(1) 

Scrapy – 设置

描述

可以使用 Scrapy 设置修改 Scrapy 组件的行为。这些设置还可以选择当前处于活动状态的 Scrapy 项目，以防您有多个 Scrapy 项目。

指定设置

当您抓取网站时，您必须通知 Scrapy 您正在使用哪个设置。为此，应使用环境变量SCRAPY_SETTINGS_MODULE，其值应采用 Python 路径语法。

填充设置

下表显示了您可以填充设置的一些机制 –

scrapy crawl myspider -s LOG_FILE = scrapy.log

class DemoSpider(scrapy.Spider): 
   name = 'demo'  
   custom_settings = { 
      'SOME_SETTING': 'some value', 
   }

访问设置

它们可以通过 self.settings 获得，并在初始化后在基础蜘蛛中设置。

以下示例演示了这一点。

class DemoSpider(scrapy.Spider): 
   name = 'demo' 
   start_urls = ['http://example.com']  
   def parse(self, response): 
      print("Existing settings: %s" % self.settings.attributes.keys()) 

要在初始化蜘蛛之前使用设置，您必须覆盖蜘蛛的_init_ ()方法中的from_crawler方法。您可以通过传递给from_crawler方法的属性scrapy.crawler.Crawler.settings访问设置。

以下示例演示了这一点。

class MyExtension(object): 
   def __init__(self, log_is_enabled = False): 
      if log_is_enabled: 
         print("Enabled log") 
         @classmethod 
   def from_crawler(cls, crawler): 
      settings = crawler.settings 
      return cls(settings.getbool('LOG_ENABLED')) 

设置名称的基本原理

设置名称作为前缀添加到它们配置的组件中。例如，对于 robots.txt 扩展名，设置名称可以是 ROBOTSTXT_ENABLED、ROBOTSTXT_OBEY、ROBOTSTXT_CACHEDIR 等。

内置设置参考

下表显示了 Scrapy 的内置设置 –

{  
   'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,
	*/*;q=0.8', 'Accept-Language': 'en',  
} 

{ 'scrapy.downloadermiddlewares.robotstxt.RobotsTxtMiddleware': 100, }

{ 'file': 'scrapy.core.downloader.handlers.file.FileDownloadHandler', }

{ 
   'scrapy.contracts.default.UrlContract' : 1, 
   'scrapy.contracts.default.ReturnsContract': 2, 
} 

{ 
   'scrapy.spidermiddlewares.httperror.HttpErrorMiddleware': 50, 
}

对于其他 Scrapy 设置，请转到此链接。

Scrapy – 异常

描述

不规则的事件被称为异常。在 Scrapy 中，由于缺少配置、从项目管道中删除项目等原因引发异常。以下是 Scrapy 中提到的异常列表及其应用程序。

掉落物品

项目管道利用此异常在任何阶段停止处理项目。它可以写为 –

exception (scrapy.exceptions.DropItem)

关闭蜘蛛

此异常用于停止使用回调请求的蜘蛛。它可以写为 –

exception (scrapy.exceptions.CloseSpider)(reason = 'cancelled')

它包含名为reason (str) 的参数，用于指定关闭的原因。

例如，以下代码显示了此异常用法 –

def parse_page(self, response): 
   if 'Bandwidth exceeded' in response.body: 
      raise CloseSpider('bandwidth_exceeded') 

忽略请求

调度程序或下载程序中间件使用此异常来忽略请求。它可以写为 –

exception (scrapy.exceptions.IgnoreRequest)

未配置

它表示缺少配置情况，应该在组件构造函数中引发。

exception (scrapy.exceptions.NotConfigured)

如果以下任何组件被禁用，则可能会引发此异常。

• 扩展
• 项目管道
• 下载器中间件
• 蜘蛛中间件

不支持

当不支持任何功能或方法时会引发此异常。它可以写为 –

exception (scrapy.exceptions.NotSupported)

Scrapy – 创建项目

描述

要从网页中抓取数据，首先您需要创建 Scrapy 项目，您将在其中存储代码。要创建新目录，请运行以下命令 –

scrapy startproject first_scrapy

上面的代码将创建一个名为 first_scrapy 的目录，它将包含以下结构 –

first_scrapy/
scrapy.cfg            # deploy configuration file
first_scrapy/         # project's Python module, you'll import your code from here
__init__.py
items.py              # project items file
pipelines.py          # project pipelines file
settings.py           # project settings file
spiders/              # a directory where you'll later put your spiders
__init__.py

Scrapy – 定义一个项目

描述

项目是用于收集从网站上报废的数据的容器。您必须通过定义您的项目来启动您的蜘蛛。要定义项目，请编辑在目录first_scrapy（自定义目录）下找到的items.py文件。该items.py看起来如下-

import scrapy  

class First_scrapyItem(scrapy.Item): 
   # define the fields for your item here like: 
      # name = scrapy.Field()

该MyItem从类继承项目包含了一些预先定义的对象是Scrapy已经为我们建造。例如，如果您想从站点中提取名称、URL 和描述，您需要为这三个属性中的每一个定义字段。

因此，让我们添加我们想要收集的那些项目 –

from scrapy.item import Item, Field  

class First_scrapyItem(scrapy.Item): 
   name = scrapy.Field() 
   url = scrapy.Field() 
   desc = scrapy.Field() 

Scrapy – 第一只蜘蛛

描述

Spider 是一个类，它定义了从中提取数据的初始 URL、如何跟踪分页链接以及如何提取和解析items.py 中定义的字段。Scrapy 提供了不同类型的蜘蛛，每一种都有特定的用途。

在 first_scrapy/spiders 目录下创建一个名为“first_spider.py”的文件，我们可以在那里告诉 Scrapy 如何找到我们正在寻找的确切数据。为此，您必须定义一些属性 –

• name – 它定义了蜘蛛的唯一名称。

• allowed_domains – 它包含蜘蛛抓取的基本 URL。

• start-urls – 蜘蛛开始爬行的 URL 列表。

• parse() – 它是一种提取和解析抓取数据的方法。

以下代码演示了蜘蛛代码的样子 –

import scrapy  

class firstSpider(scrapy.Spider): 
   name = "first" 
   allowed_domains = ["dmoz.org"] 
   
   start_urls = [ 
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/", 
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/" 
   ]  
   def parse(self, response): 
      filename = response.url.split("/")[-2] + '.html' 
      with open(filename, 'wb') as f: 
         f.write(response.body)

Scrapy – 爬行

描述

要执行您的蜘蛛，请在您的first_scrapy目录中运行以下命令–

scrapy crawl first

其中，first是创建蜘蛛时指定的蜘蛛的名称。

蜘蛛爬行后，您可以看到以下输出 –

2016-08-09 18:13:07-0400 [scrapy] INFO: Scrapy started (bot: tutorial)
2016-08-09 18:13:07-0400 [scrapy] INFO: Optional features available: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Overridden settings: {}
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled extensions: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled downloader middlewares: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled spider middlewares: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled item pipelines: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Spider opened
2016-08-09 18:13:08-0400 [scrapy] DEBUG: Crawled (200) 
<GET http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/> (referer: None)
2016-08-09 18:13:09-0400 [scrapy] DEBUG: Crawled (200) 
<GET http://www.dmoz.org/Computers/Programming/Languages/Python/Books/> (referer: None)
2016-08-09 18:13:09-0400 [scrapy] INFO: Closing spider (finished)

正如您在输出中看到的那样，对于每个 URL，都有一个日志行，其中(referer: None)指出 URL 是起始 URL，并且它们没有引用。接下来，您应该会看到在您的first_scrapy目录中创建了两个名为Books.html和Resources.html 的新文件。

Scrapy – 提取项目

描述

为了从网页中提取数据，Scrapy 使用了一种称为基于XPath和CSS表达式的选择器的技术。以下是 XPath 表达式的一些示例 –

• /html/head/title – 这将选择 HTML 文档的 <head> 元素内的 <title> 元素。

• /html/head/title/text() – 这将选择同一 <title> 元素中的文本。

• //td – 这将从 <td> 中选择所有元素。

• //div[@class = “slice”] – 这将从div 中选择包含属性 class = “slice” 的所有元素

选择器有四种基本方法，如下表所示 –

在 Shell 中使用选择器

要使用内置的 Scrapy shell 演示选择器，您需要在系统中安装IPython。这里重要的是，在运行 Scrapy 时，URL 应该包含在引号中；否则带有“&”字符的 URL 将不起作用。您可以在项目的顶级目录中使用以下命令启动 shell –

scrapy shell "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/"

外壳将如下所示 –

[ ... Scrapy log here ... ]

2014-01-23 17:11:42-0400 [scrapy] DEBUG: Crawled (200) 
<GET http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>(referer: None)
[s] Available Scrapy objects:
[s]   crawler    <scrapy.crawler.Crawler object at 0x3636b50>
[s]   item       {}
[s]   request    <GET http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
[s]   response   <200 http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
[s]   settings   <scrapy.settings.Settings object at 0x3fadc50>
[s]   spider     <Spider 'default' at 0x3cebf50>
[s] Useful shortcuts:
[s]   shelp()           Shell help (print this help)
[s]   fetch(req_or_url) Fetch request (or URL) and update local objects
[s]   view(response)    View response in a browser

In [1]:

当 shell 加载时，您可以分别使用response.body和response.header访问 body 或 header 。同样，您可以使用response.selector.xpath()或response.selector.css()对响应运行查询。

例如 –

In [1]: response.xpath('//title')
Out[1]: [<Selector xpath = '//title' data = u'<title>My Book - Scrapy'>]

In [2]: response.xpath('//title').extract()
Out[2]: [u'<title>My Book - Scrapy: Index: Chapters</title>']

In [3]: response.xpath('//title/text()')
Out[3]: [<Selector xpath = '//title/text()' data = u'My Book - Scrapy: Index:'>]

In [4]: response.xpath('//title/text()').extract()
Out[4]: [u'My Book - Scrapy: Index: Chapters']

In [5]: response.xpath('//title/text()').re('(\w+):')
Out[5]: [u'Scrapy', u'Index', u'Chapters']

提取数据

要从普通 HTML 站点提取数据，我们必须检查站点的源代码以获取 XPath。检查后，您可以看到数据将在ul标签中。选择li标签内的元素。

以下代码行显示了不同类型数据的提取 –

用于选择 li 标签内的数据 –

response.xpath('//ul/li')

用于选择描述 –

response.xpath('//ul/li/text()').extract()

用于选择站点标题 –

response.xpath('//ul/li/a/text()').extract()

用于选择站点链接 –

response.xpath('//ul/li/a/@href').extract()

以下代码演示了上述提取器的使用 –

import scrapy

class MyprojectSpider(scrapy.Spider):
   name = "project"
   allowed_domains = ["dmoz.org"]
   
   start_urls = [
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/",
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/"
   ]
   def parse(self, response):
      for sel in response.xpath('//ul/li'):
         title = sel.xpath('a/text()').extract()
         link = sel.xpath('a/@href').extract()
         desc = sel.xpath('text()').extract()
         print title, link, desc

Scrapy – 使用项目

描述

Item对象是 Python 的常规字典。我们可以使用以下语法来访问类的属性 –

>>> item = DmozItem()
>>> item['title'] = 'sample title'
>>> item['title']
'sample title'

将上述代码添加到以下示例中 –

import scrapy

from tutorial.items import DmozItem

class MyprojectSpider(scrapy.Spider):
   name = "project"
   allowed_domains = ["dmoz.org"]
   
   start_urls = [
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/",
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/"
   ]
   def parse(self, response):
      for sel in response.xpath('//ul/li'):
         item = DmozItem()
         item['title'] = sel.xpath('a/text()').extract()
         item['link'] = sel.xpath('a/@href').extract()
         item['desc'] = sel.xpath('text()').extract()
         yield item

上述蜘蛛的输出将是 –

[scrapy] DEBUG: Scraped from <200 
http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
   {'desc': [u' - By David Mertz; Addison Wesley. Book in progress, full text, 
      ASCII format. Asks for feedback. [author website, Gnosis Software, Inc.\n],
   'link': [u'http://gnosis.cx/TPiP/'],
   'title': [u'Text Processing in Python']}
[scrapy] DEBUG: Scraped from <200 
http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
   {'desc': [u' - By Sean McGrath; Prentice Hall PTR, 2000, ISBN 0130211192, 
      has CD-ROM. Methods to build XML applications fast, Python tutorial, DOM and 
      SAX, new Pyxie open source XML processing library. [Prentice Hall PTR]\n'],
   'link': [u'http://www.informit.com/store/product.aspx?isbn=0130211192'],
   'title': [u'XML Processing with Python']}

Scrapy – 以下链接

描述

在本章中，我们将研究如何提取我们感兴趣的页面的链接，关注它们并从该页面中提取数据。为此，我们需要在我们之前的代码中进行以下更改，如下所示 –

import scrapy
from tutorial.items import DmozItem

class MyprojectSpider(scrapy.Spider):
   name = "project"
   allowed_domains = ["dmoz.org"]
   
   start_urls = [
      "http://www.dmoz.org/Computers/Programming/Languages/Python/",
   ]
   def parse(self, response):
      for href in response.css("ul.directory.dir-col > li > a::attr('href')"):
         url = response.urljoin(href.extract())
            yield scrapy.Request(url, callback = self.parse_dir_contents)

   def parse_dir_contents(self, response):
      for sel in response.xpath('//ul/li'):
         item = DmozItem()
         item['title'] = sel.xpath('a/text()').extract()
         item['link'] = sel.xpath('a/@href').extract()
         item['desc'] = sel.xpath('text()').extract()
         yield item

上面的代码包含以下方法 –

• parse() – 它将提取我们感兴趣的链接。

• response.urljoin – parse() 方法将使用此方法构建一个新的 url 并提供一个新的请求，该请求将在稍后发送给回调。

• parse_dir_contents() – 这是一个回调，它实际上会抓取感兴趣的数据。

在这里，Scrapy 使用回调机制来跟踪链接。使用这种机制，可以设计更大的爬虫，并可以跟随感兴趣的链接从不同的页面抓取所需的数据。常规方法将是回调方法，它将提取项目，寻找链接到下一页，然后提供相同回调的请求。

下面的示例生成一个循环，它将跟随链接到下一页。

def parse_articles_follow_next_page(self, response):
   for article in response.xpath("//article"):
      item = ArticleItem()
    
      ... extract article data here

      yield item

   next_page = response.css("ul.navigation > li.next-page > a::attr('href')")
   if next_page:
      url = response.urljoin(next_page[0].extract())
      yield scrapy.Request(url, self.parse_articles_follow_next_page)

Scrapy – 抓取数据

描述

存储抓取数据的最佳方法是使用 Feed 导出，这可确保使用多种序列化格式正确存储数据。JSON、JSON 行、CSV、XML 是序列化格式中容易支持的格式。可以使用以下命令存储数据 –

scrapy crawl dmoz -o data.json

此命令将创建一个data.json文件，其中包含 JSON 格式的抓取数据。这种技术适用于少量数据。如果需要处理大量数据，那么我们可以使用Item Pipeline。就像 data.json 文件一样，在tutorial/pipelines.py 中创建项目时会设置一个保留文件。

Scrapy – 日志记录

描述

日志是指事件的跟踪，它使用内置的日志系统并定义函数和类来实现应用程序和库。Logging 是一种即用型材料，可以与 Logging settings 中列出的 Scrapy 设置一起使用。

Scrapy 将设置一些默认设置并在运行命令时借助 scrapy.utils.log.configure_logging() 处理这些设置。

日志级别

在 Python 中，日志消息有五种不同的严重性级别。以下列表按升序显示标准日志消息 –

• logging.DEBUG – 用于调试消息（最低严重性）

• logging.INFO – 用于信息性消息

• logging.WARNING – 用于警告消息

• logging.ERROR – 用于常规错误

• logging.CRITICAL – 用于严重错误（最高严重性）

如何记录消息

以下代码显示使用logging.info级别记录消息。

import logging 
logging.info("This is an information")

上面的日志消息可以使用logging.log作为参数传递，如下所示 –

import logging 
logging.log(logging.INFO, "This is an information")

现在，您还可以使用 loggers 使用 logging helpers logging 来包含消息，以获得清晰显示的日志消息，如下所示 –

import logging
logger = logging.getLogger()
logger.info("This is an information")

可以有多个记录器，并且可以通过使用如下所示的logging.getLogger函数获取它们的名称来访问它们。

import logging
logger = logging.getLogger('mycustomlogger')
logger.info("This is an information")

自定义记录器可用于使用__name__变量的任何模块，该变量包含如下所示的模块路径 –

import logging
logger = logging.getLogger(__name__)
logger.info("This is an information")

从蜘蛛记录

每个蜘蛛实例都有一个记录器，可以按如下方式使用 –

import scrapy 

class LogSpider(scrapy.Spider):  
   name = 'logspider' 
   start_urls = ['http://dmoz.com']  
   def parse(self, response): 
      self.logger.info('Parse function called on %s', response.url)

在上面的代码中，记录器是使用 Spider 的名称创建的，但您可以使用 Python 提供的任何自定义记录器，如下面的代码所示 –

import logging
import scrapy

logger = logging.getLogger('customizedlogger')
class LogSpider(scrapy.Spider):
   name = 'logspider'
   start_urls = ['http://dmoz.com']

   def parse(self, response):
      logger.info('Parse function called on %s', response.url)

日志配置

记录器无法显示他们自己发送的消息。因此，它们需要“处理程序”来显示这些消息，处理程序会将这些消息重定向到它们各自的目的地，例如文件、电子邮件和标准输出。

根据以下设置，Scrapy 将为记录器配置处理程序。

日志设置

以下设置用于配置日志记录 –

• 该LOG_FILE和LOG_ENABLED决定日志消息目的地。

• 当您将LOG_ENCODING设置为 false 时，它​​不会显示日志输出消息。

• 该LOG_LEVEL将确定该消息的严重性顺序; 那些严重性较低的消息将被过滤掉。

• 该LOG_FORMAT和LOG_DATEFORMAT用于指定对所有消息的布局。

• 当您将LOG_STDOUT设置为 true 时，您进程的所有标准输出和错误消息将被重定向到日志。

命令行选项

可以通过传递命令行参数来覆盖 Scrapy 设置，如下表所示 –

scrapy.utils.log 模块

此函数可用于初始化 Scrapy 的日志记录默认值。

scrapy.utils.log.configure_logging(settings = None, install_root_handler = True)

上述功能 –

• 通过 Python 标准日志记录路由警告和扭曲的日志记录。
• 将 DEBUG 分配给 Scrapy，将 ERROR 级别分配给 Twisted 记录器。
• 如果 LOG_STDOUT 设置为 true，则将 stdout 路由到日志。

可以使用settings参数覆盖默认选项。如果未指定设置，则使用默认值。当 install_root_handler 设置为 true 时，可以为根记录器创建处理程序。如果设置为false，则不会设置任何日志输出。当使用 Scrapy 命令时，configure_logging 将被自动调用并且它可以在运行自定义脚本时显式运行。

要手动配置日志输出，您可以使用如下所示的logging.basicConfig() –

import logging 
from scrapy.utils.log import configure_logging  

configure_logging(install_root_handler = False) 
logging.basicConfig ( 
   filename = 'logging.txt', 
   format = '%(levelname)s: %(your_message)s', 
   level = logging.INFO 
)

Scrapy – 统计集合

描述

Stats Collector 是 Scrapy 提供的一种工具，用于以键/值的形式收集统计信息，并使用 Crawler API 访问它（Crawler 提供对所有 Scrapy 核心组件的访问）。统计收集器为每个蜘蛛提供一个统计表，其中统计收集器在蜘蛛打开时自动打开并在蜘蛛关闭时关闭统计收集器。

常见的统计收集器用途

以下代码使用stats属性访问统计信息收集器。

class ExtensionThatAccessStats(object): 
   def __init__(self, stats): 
      self.stats = stats  
   
   @classmethod 
   def from_crawler(cls, crawler): 
      return cls(crawler.stats)

下表显示了可以与统计收集器一起使用的各种选项 –

stats.set_value('hostname', socket.gethostname())

stats.inc_value('customized_count')

stats.max_value('max_items_scraped', value)

stats.min_value('min_free_memory_percent', value)

stats.get_value('customized_count')

stats.get_stats() {'custom_count': 1, 'start_time': 
datetime.datetime(2009, 7, 14, 21, 47, 28, 977139)} 

可用的统计数据收集器

Scrapy 提供了不同类型的统计数据收集器，可以使用STATS_CLASS设置进行访问。

内存状态收集器

它是默认的 Stats 收集器，用于维护用于抓取的每个蜘蛛的统计信息，数据将存储在内存中。

class scrapy.statscollectors.MemoryStatsCollector

DummyStatsCollector

这个统计信息收集器非常有效，什么都不做。这可以使用STATS_CLASS设置进行设置，并可用于禁用统计信息收集以提高性能。

class scrapy.statscollectors.DummyStatsCollector

Scrapy – 发送电子邮件

描述

Scrapy 可以使用自己的工具发送电子邮件，称为Twisted 非阻塞 IO，它远离爬虫的非阻塞 IO。您可以配置发送电子邮件的一些设置，并提供简单的 API 来发送附件。

有两种方法可以实例化 MailSender，如下表所示 –

以下行发送不带附件的电子邮件 –

mailer.send(to = ["[email protected]"], subject = "subject data", body = "body data", 
   cc = ["[email protected]"])

MailSender 类参考

MailSender 类使用Twisted 非阻塞 IO从 Scrapy 发送电子邮件。

class scrapy.mail.MailSender(smtphost = None, mailfrom = None, smtpuser = None, 
   smtppass = None, smtpport = None)

下表显示了MailSender类中使用的参数–

指定的 MailSender 类引用中有以下两种方法。第一种方法，

classmethod from_settings(settings)

它通过使用 Scrapy 设置对象进行合并。它包含以下参数 –

settings (scrapy.settings.Settings object) – 它被视为电子邮件接收器。

另一种方法，

send(to, subject, body, cc = None, attachs = (), mimetype = 'text/plain', charset = None)

下表包含上述方法的参数 –

邮件设置

下面的设置确保我们不用写任何代码，就可以使用项目中的MailSender类来配置一封电子邮件。

Scrapy – Telnet 控制台

描述

Telnet 控制台是在 Scrapy 进程内部运行的 Python shell，用于检查和控制 Scrapy 运行进程。

访问 Telnet 控制台

可以使用以下命令访问 telnet 控制台 –

telnet localhost 6023

基本上，telnet 控制台列在 TCP 端口中，这在TELNETCONSOLE_PORT设置中进行了描述。

变量

下表中给出的一些默认变量用作快捷方式 –

例子

以下是使用 Telnet 控制台说明的一些示例。

暂停、恢复和停止 Scrapy 引擎

要暂停 Scrapy 引擎，请使用以下命令 –

telnet localhost 6023
>>> engine.pause()
>>>

要恢复 Scrapy 引擎，请使用以下命令 –

telnet localhost 6023
>>> engine.unpause()
>>>

要停止 Scrapy 引擎，请使用以下命令 –

telnet localhost 6023
>>> engine.stop()
Connection closed by foreign host.

查看引擎状态

Telnet 控制台使用est()方法检查 Scrapy 引擎的状态，如下面的代码所示 –

telnet localhost 6023
>>> est()
Execution engine status

time()-engine.start_time                        : 8.62972998619
engine.has_capacity()                           : False
len(engine.downloader.active)                   : 16
engine.scraper.is_idle()                        : False
engine.spider.name                              : followall
engine.spider_is_idle(engine.spider)            : False
engine.slot.closing                             : False
len(engine.slot.inprogress)                     : 16
len(engine.slot.scheduler.dqs or [])            : 0
len(engine.slot.scheduler.mqs)                  : 92
len(engine.scraper.slot.queue)                  : 0
len(engine.scraper.slot.active)                 : 0
engine.scraper.slot.active_size                 : 0
engine.scraper.slot.itemproc_size               : 0
engine.scraper.slot.needs_backout()             : False

Telnet 控制台信号

您可以使用 telnet 控制台信号来添加、更新或删除 telnet 本地命名空间中的变量。要执行此操作，您需要在处理程序中添加 telnet_vars dict。

scrapy.extensions.telnet.update_telnet_vars(telnet_vars)

参数 –

telnet_vars (dict)

其中， dict 是包含 telnet 变量的字典。

远程登录设置

下表显示了控制 Telnet 控制台行为的设置 –

Scrapy – 网络服务

描述

可以通过JSON-RPC控制正在运行的 Scrapy 网络爬虫。它由 JSONRPC_ENABLED 设置启用。该服务通过JSON-RPC 2.0协议提供对主要爬虫对象的访问。访问爬虫对象的端点是 –

http://localhost:6080/crawler

下表包含一些显示 Web 服务行为的设置 –