Scrapy-quick-guide

スクレイピー-概要

ScrapyはPythonで書かれた高速でオープンソースのWebクロールフレームワークであり、XPathに基づくセレクターの助けを借りてWebページからデータを抽出するために使用されます。

Scrapyは、BSDでライセンスされた2008年6月26日に初めてリリースされ、2015年6月にマイルストーン1.0がリリースされました。

Scrapyを使用する理由

• 大規模なクロールプロジェクトを構築およびスケーリングする方が簡単です。
• Webサイトからデータを抽出するためのセレクターと呼ばれる組み込みのメカニズムがあります。
• 要求を非同期的に処理し、高速です。
• Auto-throttling mechanismを使用して、クロール速度を自動的に調整します。
• 開発者のアクセシビリティを確保します。

スクレイピーの特徴

• Scrapyはオープンソースであり、無料で使用できるWebクロールフレームワークです。
• Scrapyは、JSON、CSV、XMLなどの形式でフィードエクスポートを生成します。
• Scrapyには、XPathまたはCSS式のいずれかによってソースからデータを選択および抽出するための組み込みのサポートがあります。
• クローラーに基づいたスクレイピーにより、Webページからデータを自動的に抽出できます。

利点

• Scrapyは簡単に拡張でき、高速で強力です。
• これは、クロスプラットフォームアプリケーションフレームワーク（Windows、Linux、Mac OS、およびBSD）です。
• スクレイピーリクエストは、非同期でスケジュールおよび処理されます。
• Scrapyには Scrapyd という組み込みサービスが付属しており、JSON Webサービスを使用してプロジェクトをアップロードし、スパイダーを制御できます。
• 任意のWebサイトを廃棄することは可能ですが、そのWebサイトには生データアクセス用のAPIはありません。

デメリット

• ScrapyはPython 2.7専用です。
  

• インストールは、オペレーティングシステムごとに異なります。

スクレイピー-環境

この章では、Scrapyのインストール方法とセットアップ方法について説明します。 ScrapyはPythonとともにインストールする必要があります。

Scrapyは pip を使用してインストールできます。 インストールするには、次のコマンドを実行します-

pip install Scrapy

Windows

注意-Python 3はWindows OSではサポートされていません。

• ステップ1 *-https://www.python.org/downloads/[Python]からPython 2.7をインストールします

次のパスをPATHに追加して、環境変数を設定します-

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

次のコマンドを使用して、Pythonのバージョンを確認できます-

python --version

• ステップ2 *-https://slproweb.com/products/Win32OpenSSLl[OpenSSL]をインストールします。

環境変数にC：\ OpenSSL-Win32 \ binを追加します。

注意-OpenSSLは、Windowsを除くすべてのオペレーティングシステムにプリインストールされています。

• ステップ3 *-https://www.microsoft.com/downloads/details.aspx?familyid=9B2DA534-3E03-4391-8A4D-074B9F2BC1BF[Visual C ++ 2008]再頒布可能パッケージをインストールします。

• ステップ4 *-https://sourceforge.net/projects/pywin32/[pywin32]をインストールします。

• ステップ5 *-2.7.9より古いPythonバージョンのhttps://pip.pypa.io/en/latest/installing/[pip]をインストールします。

次のコマンドを使用して、pipバージョンを確認できます-

pip --version

• ステップ6 *-スクレイピーをインストールするには、次のコマンドを実行します-

pip install Scrapy

アナコンダ

マシンにhttps://docs.continuum.io/anaconda/[anaconda]またはhttps://conda.pydata.org/docs/install/quickl[miniconda]がインストールされている場合は、次のコマンドを実行して、Scrapyをインストールします。コンダ-

conda install -c scrapinghub scrapy

Scrapinghub会社は、Linux、Windows、およびOS Xの公式condaパッケージをサポートしています。

注-pipを使用したインストールに問題がある場合は、上記のコマンドを使用してScrapyをインストールすることをお勧めします。

Ubuntu 9.10以降

Pythonの最新バージョンはUbuntu OSにプリインストールされています。 Scrapinghubが提供するUbuntuパッケージaptgettableを使用します。 パッケージを使用するには-

• ステップ1 *-Scrapyパッケージの署名に使用されるGPGキーをAPTキーリングにインポートする必要があります-

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 *-https://brew.sh/[homebrew]をインストールします。

• ステップ2 *-システムパッケージの前にhomebrewパッケージを使用するように環境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（project folder）\ scrapy.cfg
• 〜/.config/scrapy.cfg（$ XDG_CONFIG_HOME）および〜/.scrapy.cfg（$ HOME）グローバル設定
• プロジェクトのルート内でscrapy.cfgを見つけることができます。

スクレイピーは、次の環境変数を使用して構成することもできます-

• SCRAPY_SETTINGS_MODULE
• SCRAPY_PROJECT
• SCRAPY_PYTHON_SHELL

デフォルト構造スクレイピープロジェクト

次の構造は、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 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 genspider mydomain mydomain.com

クロールなどのコマンド Scrapyプロジェクト内で使用する必要があります。 次のセクションで、Scrapyプロジェクト内でどのコマンドを実行する必要があるかがわかります。

Scrapyには、プロジェクトに使用できるいくつかの組み込みコマンドが含まれています。 利用可能なコマンドのリストを表示するには、次のコマンドを使用します-

scrapy -h

次のコマンドを実行すると、Scrapyは使用可能なコマンドのリストを表示します-

• fetch -Scrapyダウンローダーを使用してURLを取得します。
• runspider -プロジェクトを作成せずに自己完結型のスパイダーを実行するために使用されます。
• settings -プロジェクトの設定値を指定します。
• shell -指定されたURLのインタラクティブなスクレイピングモジュールです。
• startproject -新しいScrapyプロジェクトを作成します。
• version -Scrapyバージョンを表示します。
• view -Scrapyダウンローダーを使用してURLを取得し、ブラウザーにコンテンツを表示します。

リストされているように、いくつかのプロジェクト関連のコマンドを持つことができます-

• クロール-クモを使用してデータをクロールするために使用されます。
• check -クロールされたコマンドによって返されたアイテムをチェックします。
• list -プロジェクトに存在する利用可能なスパイダーのリストを表示します。
• 編集-エディターを使用してスパイダーを編集できます。
• parse -指定されたURLをスパイダーで解析します。
• ベンチ-クイックベンチマークテストの実行に使用されます（ベンチマークは、Scrapyが1分間にクロールできるページ数を示します）。

カスタムプロジェクトコマンド

Scrapyプロジェクトで COMMANDS_MODULE 設定を使用してカスタムプロジェクトコマンドをビルドできます。 設定にデフォルトの空の文字列が含まれます。 次のカスタムコマンドを追加できます-

COMMANDS_MODULE = 'mycmd.commands'

スクレイピーコマンドは、次のように示されているsetup.pyファイルのscrapy.commandsセクションを使用して追加できます-

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 コマンドを追加します。

スクレイピー-スパイダー

説明

Spiderは、Webサイトを介してリンクをたどり、ページから情報を抽出する方法を定義するクラスです。

スクレイピーのデフォルトのスパイダーは次のとおりです-

スクレイピースパイダー

それは他のすべてのクモが継承しなければならないクモです。 次のクラスがあります-

class scrapy.spiders.Spider

次の表は、scrapy.Spiderクラスのフィールドを示しています-

Sr.No	Field & Description
1	name それはあなたのクモの名前です。
2	allowed_domains これは、クモがクロールするドメインのリストです。
3	start_urls これは、スパイダーがクロールを開始する後のクロールのルートとなるURLのリストです。
4	custom_settings これらは、スパイダーを実行するときに、プロジェクト全体の設定から上書きされる設定です。
5	crawler これは、クモのインスタンスがバインドされているクローラーオブジェクトにリンクする属性です。
6	settings これらは、スパイダーを実行するための設定です。
7	logger これは、ログメッセージの送信に使用されるPythonロガーです。
8	from_crawler(crawler,*args,*kwargs)* これはクラスメソッドであり、スパイダーを作成します。 パラメータは次のとおりです- クローラー-クモのインスタンスがバインドされるクローラー。 * args（list）*-これらの引数はメソッド__init _（）_に渡されます。 * kwargs（dict）*-これらのキーワード引数は__init _（）_メソッドに渡されます。
9	start_requests() 特定のURLが指定されておらず、スパイダーがスクラップ用に開かれている場合、Scrapyは_start_requests（）_メソッドを呼び出します。
10	make_requests_from_url(url) URLをリクエストに変換するために使用されるメソッドです。
11	parse(response) このメソッドは、応答を処理し、さらにURLに続くスクラップデータを返します。
12	log(message[,level,component]) これは、スパイダーロガーを介してログメッセージを送信するメソッドです。
13	closed(reason) このメソッドは、クモが閉じるときに呼び出されます。

スパイダー引数

スパイダー引数は、開始URLを指定するために使用され、次のようにcrawlコマンドと -a オプションを使用して渡されます-

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クラスのルールを示しています-

Sr.No	Rule & Description
1	LinkExtractor クモがどのようにリンクをたどり、データを抽出するかを指定します。
2	callback 各ページがスクレイプされた後に呼び出されます。
3	follow リンクをたどり続けるかどうかを指定します。

parse_start_url（応答）

初期応答を解析できるようにすることで、アイテムまたはリクエストオブジェクトを返します。

注-解析関数はCrawlSpiderによってそのロジックを実装するために使用されるため、ルールの作成中に解析以外の解析関数の名前を変更してください。

スパイダーが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

次の表は、イテレータとタグ名を設定するために使用されるクラス属性を示しています-

Sr.No	Attribute & Description
1	iterator 使用するイテレータを定義します。 iternodes、html、または_xml_のいずれかです。 デフォルトは_iternodes_です。
2	itertag 反復するノード名を含む文字列です。
3	namespaces _register_namespace（）_メソッドを使用して名前空間を自動的に登録する（プレフィックス、uri）タプルのリストによって定義されます。
4	adapt_response(response) スパイダーミドルウェアから到着するとすぐに、スパイダーが解析を開始する前に、応答を受信して​​応答本文を変更します。
5	parse_node(response,selector) 指定されたタグ名に一致する各ノードに対して呼び出されると、応答とセレクターを受け取ります。 注-このメソッドをオーバーライドしないと、スパイダーは動作しません。
6	process_results(response,results) スパイダーから返された結果と応答のリストを返します。

CSVFeedSpider

各行を反復処理し、応答としてCSVファイルを受信し、_parse_row（）_メソッドを呼び出します。 次のクラスがあります-

class scrapy.spiders.CSVFeedSpider

次の表は、CSVファイルに関して設定できるオプションを示しています-

Sr.No	Option & Description
1	delimiter 各フィールドのコンマ（ '、'）区切り文字を含む文字列です。
2	quotechar 各フィールドの引用符（ '"'）を含む文字列です。
3	headers これは、フィールドを抽出できるステートメントのリストです。
4	parse_row(response,row) 応答と各行とヘッダーのキーを受け取ります。

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

サイトマップSpider

Sitemapsの助けを借りてSitemapSpiderは、robots.txtからURLを見つけてWebサイトをクロールします。 次のクラスがあります-

class scrapy.spiders.SitemapSpider

次の表は、SitemapSpiderのフィールドを示しています-

Sr.No	Field & Description
1	sitemap_urls サイトマップを指すクロールするURLのリスト。
2	sitemap_rules タプル（正規表現、コールバック）のリストです。正規表現は正規表現であり、コールバックは正規表現に一致するURLを処理するために使用されます。
3	sitemap_follow これは、従うべきサイトマップの正規表現のリストです。
4	sitemap_alternate_links 単一のURLでたどる代替リンクを指定します。

SitemapSpiderの例

次の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

次のコードは、URLに /sitemap_company があるrobots.txtのサイトマップを示しています-

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...

スクレイピー-セレクター

説明

Webページをスクレイピングするときは、XPath式またはCSS式を使用して実現される selectors と呼ばれるメカニズムを使用して、HTMLソースの特定の部分を抽出する必要があります。 セレクタは、Python言語でXMLとHTMLを処理する lxml ライブラリに基づいています。

次のコードスニペットを使用して、セレクタのさまざまな概念を定義します-

<html>
   <head>
      <title>My Website</title>
   </head>

   <body>
      <span>Hello world!!!</span>
      <div class = 'links'>
         <a href = 'onel'>Link 1<img src = 'image1.jpg'/></a>
         <a href = 'twol'>Link 2<img src = 'image2.jpg'/></a>
         <a href = 'threel'>Link 3<img src = 'image3.jpg'/></a>
      </div>
   </body>
</html>

セレクターの構築

*text* または *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'onel'] and image [u'image1.jpg']
Link 2 pointing to url [u'twol'] and image [u'image2.jpg']
Link 3 pointing to url [u'threel'] 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')

次に、以下に示すように*。//p のようにドットをXPathの前に付けることにより、内部のすべての *'p' 要素を抽出できます-

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

EXSLT拡張機能の使用

EXSLTは、XMLドキュメントをXHTMLドキュメントに変換するXSLT（Extensible Stylesheet Language Transformations）の拡張機能を発行するコミュニティです。 次の表に示すように、XPath式で登録されたネームスペースでEXSLT拡張機能を使用できます-

Sr.No	Prefix & Usage	Namespace
1	re 正規表現	http://exslt.org/regexp/indexl
2	set セット操作	http://exslt.org/set/indexl

前のセクションの正規表現を使用してデータを抽出するための簡単なコード形式を確認できます。

SPathyセレクターでXPathを使用するときに役立つXPathのヒントがいくつかあります。 詳細については、このリンク：/scrapy/xpth_tips [link]をクリックしてください。

スクレイピー-アイテム

説明

スクレイピープロセスを使用して、スパイダーを使用してWebページなどのソースからデータを抽出できます。 Scrapyは Item クラスを使用して、スクレイピングされたデータの収集に使用されるオブジェクトの出力を生成します。

アイテムの宣言

あなたは、次のように示されているフィールドオブジェクトとともにクラス定義構文を使用してアイテムを宣言することができます-

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

アイテムフィールド

項目フィールドは、各フィールドのメタデータを表示するために使用されます。 フィールドオブジェクトには値の制限がないため、アクセス可能なメタデータキーはメタデータの参照リストを保持しません。 フィールドオブジェクトはすべてのフィールドメタデータを指定するために使用され、プロジェクトの要件に応じて他のフィールドキーを指定できます。 フィールドオブジェクトには、Item.fields属性を使用してアクセスできます。

アイテムの使用

アイテムを操作するときに定義できる一般的な機能がいくつかあります。 詳細については、このリンク：/scrapy/working_with_items [link]をクリックしてください。

アイテムの拡張

アイテムは、元のアイテムのサブクラスを指定することで拡張できます。 例えば-

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])

アイテムは、コンストラクターのコピーを提供し、フィールド内のアイテムによって与えられる追加の属性を提供します。

フィールドオブジェクト

フィールドオブジェクトは、フィールドクラスが追加のプロセスや属性を発行しない次のクラスを使用して指定することができます-

class scrapy.item.Field([arg])

スクレイピー-アイテムローダー

説明

アイテムローダーは、Webサイトからスクレイピングされたアイテムを埋める便利な方法を提供します。

アイテムローダーの宣言

アイテムローダーの宣言はアイテムのようなものです。

たとえば-

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* 属性は、デフォルトの入出力プロセッサーを宣言するために使用されます。

アイテムローダーを使用してアイテムを作成する

アイテムローダーを使用するには、最初にdictのようなオブジェクトでインスタンス化するか、アイテムが ItemLoader.default_item_class 属性で指定されたアイテムクラスを使用するオブジェクトなしでインスタンス化します。

• セレクターを使用して、アイテムローダーに値を収集できます。
• 同じアイテムフィールドにさらに値を追加できます。アイテムローダーは、適切なハンドラーを使用してこれらの値を追加します。

次のコードは、アイテムローダーを使用してアイテムがどのように読み込まれるかを示しています-

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（）メソッドを使用して *title フィールドが抽出される2つの異なる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（）*メソッドを使用して抽出されたデータで満たされたアイテムを返します。

入出力プロセッサー

アイテムローダーの各フィールドには、1つの入力プロセッサと1つの出力プロセッサが含まれています。

• データが抽出されると、入力プロセッサはそれを処理し、その結果は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 *-次に、値 "demo"が割り当てられ、入力プロセッサに渡されます。

• 行5 *-最後に、データはすべてのフィールドから内部的に収集され、出力プロセッサに渡され、最終値がアイテムに割り当てられます。

入力および出力プロセッサの宣言

入力および出力プロセッサは、ItemLoader定義で宣言されています。 これとは別に、 Item Field メタデータで指定することもできます。

たとえば-

import scrapy
from scrapy.loader.processors import Join, MapCompose, TakeFirst
from w3libl 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")

• アイテムローダーコンテキストでインスタンス化する入出力プロセッサのアイテムローダー宣言について-

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

ItemLoaderオブジェクト

これは、指定されたアイテムを取り込むための新しいアイテムローダーを返すオブジェクトです。 次のクラスがあります-

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

次の表は、ItemLoaderオブジェクトのパラメータを示しています-

Sr.No	Parameter & Description
1	item これは、add_xpath（）、add_css（）、またはadd_value（）を呼び出して入力するアイテムです。
2	selector Webサイトからデータを抽出するために使用されます。
3	response default_selector_classを使用してセレクターを構築するために使用されます。

次の表は、ItemLoaderオブジェクトのメソッドを示しています-

Sr.No	Method & Description	Example
1	get_value(value, *processors, **kwargs) 指定されたプロセッサとキーワード引数により、値はget_value（）メソッドによって処理されます。	>>> from scrapy.loader.processors import TakeFirst >>> loader.get_value(u'title: demoweb', TakeFirst(), unicode.upper, re = 'title: (.+)') 'DEMOWEB`
2	add_value(field_name, value, *processors, **kwargs) 値を処理し、フィールド入力プロセッサを通過する前にプロセッサとキーワード引数を与えることにより、get_valueを介して最初に渡されるフィールドに追加します。	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')
3	replace_value(field_name, value, *processors, **kwargs) 収集されたデータを新しい値に置き換えます。	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')
4	get_xpath(xpath, *processors, **kwargs) _XPath_を受け取ることでプロセッサとキーワード引数を与えることでUnicode文字列を抽出するために使用されます。	# 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 (.*)")
5	add_xpath(field_name, xpath, *processors, **kwargs) Unicode文字列を抽出するフィールドへの_XPath_を受け取ります。	# 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 (.*)')
6	replace_xpath(field_name, xpath, *processors, **kwargs) サイトからの_XPath_を使用して、収集されたデータを置き換えます。	# HTML code: <div class = "item-name">DVD</div> loader.replace_xpath('name', ' # HTML code: <div id = "length">the length is 45cm</div> loader.replace_xpath('length', '
7	get_css(css, *processors, **kwargs) Unicode文字列の抽出に使用されるCSSセレクターを受け取ります。	loader.get_css("div.item-name") loader.get_css("div#length", TakeFirst(), re = "the length is (.*)")
8	add_css(field_name, css, *processors, **kwargs) add_value（）メソッドに似ていますが、CSSセレクターをフィールドに追加する点が1つ異なります。	loader.add_css('name', 'div.item-name') loader.add_css('length', 'div#length', re = 'the length is (.*)')
9	replace_css(field_name, css, *processors, **kwargs) CSSセレクターを使用して、抽出されたデータを置き換えます。	loader.replace_css('name', 'div.item-name') loader.replace_css('length', 'div#length', re = 'the length is (.*)')
10	load_item() データが収集されると、このメソッドはアイテムに収集されたデータを入れて返します。	def parse(self, response): l = ItemLoader(item = Product(), response = response) l.add_xpath('title', '// div[@class = "product_title"]') loader.load_item()
11	nested_xpath(xpath) XPathセレクターでネストされたローダーを作成するために使用されます。	loader = ItemLoader(item = Item()) loader.add_xpath('social', ' a[@class = "social"]/@href') loader.add_xpath('email', ' a[@class = "email"]/@href')
12	nested_css(css) CSSセレクターでネストされたローダーを作成するために使用されます。	loader = ItemLoader(item = Item()) loader.add_css('social', 'a[@class = "social"]/@href') loader.add_css('email', 'a[@class = "email"]/@href')

次の表は、ItemLoaderオブジェクトの属性を示しています-

Sr.No	Attribute & Description
1	item これは、アイテムローダーが解析を実行するオブジェクトです。
2	context アクティブなのは、アイテムローダーの現在のコンテキストです。
3	default_item_class コンストラクタで指定されていない場合、アイテムを表すために使用されます。
4	default_input_processor default_input_processorsが使用されるのは、入力プロセッサを指定しないフィールドのみです。
5	default_output_processor default_output_processorsが使用されるのは、出力プロセッサを指定しないフィールドのみです。
6	default_selector_class コンストラクターで指定されていない場合、セレクターの構築に使用されるクラスです。
7	selector これは、サイトからデータを抽出するために使用できるオブジェクトです。

入れ子ローダー

ドキュメントのサブセクションから値を解析する際に、ネストされたローダーを作成するために使用されます。 ネストされたローダーを作成しない場合は、抽出する値ごとに完全な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()

アイテムローダーの再利用と拡張

アイテムローダーは、プロジェクトがより多くのスパイダーを取得するときに根本的な問題となるメンテナンスを軽減するように設計されています。

たとえば、サイトの製品名が3つのダッシュで囲まれていると仮定します（例： --DVD ---）。 次のコードに示すように、最終製品名に不要な場合は、デフォルトの製品アイテムローダーを再利用して、これらのダッシュを削除できます-

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

受信した値のリストから、null/空でない最初の値を返します。 たとえば-

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

class 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）

これは、各入力値が最初の関数に渡されるプロセッサによって定義され、その関数の結果は2番目の関数に渡され、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）

入力値が反復され、最初の関数が各要素に適用されるプロセッサです。 次に、これらの関数呼び出しの結果が連結されて新しい反復可能オブジェクトが作成され、それが最後の関数まで2番目の関数などに適用されます。

たとえば-

>>> 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シェルの主な目的は、抽出されたコード、XPath、またはCSS式をテストすることです。 また、データをスクレイピングするWebページを指定するのにも役立ちます。

シェルの構成

シェルはhttps://ipython.org/[IPython]（インタラクティブコンピューティングに使用）コンソールをインストールすることで設定できます。これは自動補完、色付き出力などを提供する強力なインタラクティブシェルです。

Unixプラットフォームで作業している場合は、IPythonをインストールすることをお勧めします。 IPythonにアクセスできない場合は、https://www.bpython-interpreter.org/[bpython]を使用することもできます。

SCRAPY_PYTHON_SHELLと呼ばれる環境変数を設定するか、次のようにscrapy.cfgファイルを定義することにより、シェルを構成することができます-

[settings]
shell = bpython

シェルを起動する

スクレイピーシェルは、次のコマンドを使用して起動することができます-

scrapy shell <url>

_url_は、データのスクレイピングが必要なURLを指定します。

シェルを使用する

シェルは、次の表で説明するように、いくつかの追加のショートカットとScrapyオブジェクトを提供します-

利用可能なショートカット

シェルは、プロジェクトで次の利用可能なショートカットを提供します-

Sr.No	Shortcut & Description
1	shelp() ヘルプオプションで使用可能なオブジェクトとショートカットを提供します。
2	fetch(request_or_url) 要求またはURLからの応答を収集し、関連するオブジェクトが適切に更新されます。
3	view(response) 観察のためにローカルブラウザで指定されたリクエストの応答を表示し、外部リンクを正しく表示するために、応答本文にベースタグを追加します。

利用可能なスクレイピーオブジェクト

シェルは、プロジェクトで次の利用可能なスクレイピーオブジェクトを提供します-

Sr.No	Object & Description
1	crawler 現在のクローラーオブジェクトを指定します。
2	spider 現在のURLにスパイダーがない場合、新しいスパイダーを定義することでURLまたはスパイダーオブジェクトを処理します。
3	request 最後に収集されたページの要求オブジェクトを指定します。
4	response 最後に収集されたページの応答オブジェクトを指定します。
5	settings 現在のScrapy設定が提供されます。

シェルセッションの例

scrapy.orgサイトをスクレイピングしてから、説明どおりにreddit.comからデータのスクレイピングを開始しましょう。

先に進む前に、まず次のコマンドに示すようにシェルを起動します-

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

上記のURLを使用している間、Scrapyは使用可能なオブジェクトを表示します-

[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
...

スパイダーからシェルを呼び出して応答を検査する

スパイダーから処理された応答は、その応答を取得する予定がある場合にのみ検査できます。

例えば-

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)

上記のコードに示すように、次の関数を使用して、スパイダーからシェルを呼び出して応答を検査できます-

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"]')

出力を次のように表示します

[]

上記の行には、空白の出力のみが表示されています。 今、あなたは次のように応答を検査するためにシェルを呼び出すことができます-

>> view(response)

応答を次のように表示します

True

スクレイピー-アイテムパイプライン

説明

• アイテムパイプライン*は、廃棄されたアイテムを処理する方法です。 アイテムがアイテムパイプラインに送信されると、アイテムはスパイダーによってスクレイピングされ、順次実行される複数のコンポーネントを使用して処理されます。

アイテムが受信されるたびに、次のアクションのいずれかを決定します-

• アイテムの処理を続けます。
• パイプラインからドロップします。
• アイテムの処理を停止します。

アイテムのパイプラインは、一般的に次の目的で使用されます-

• スクレイプされたアイテムをデータベースに保存します。
• 受け取ったアイテムが繰り返されると、繰り返されたアイテムがドロップされます。
• アイテムにターゲットフィールドがあるかどうかを確認します。
• HTMLデータを消去します。

構文

あなたは次の方法を使用してアイテムパイプラインを書くことができます-

process_item(self, item, spider)

上記の方法には、次のパラメータが含まれています-

• アイテム（アイテムオブジェクトまたはディクショナリ）-削り取られたアイテムを指定します。 *spider（spider object）-アイテムをこすったクモ。

次の表に示す追加の方法を使用できます-

Sr.No	Method & Description	Parameters
1	open_spider(self, spider)* クモが開いているときに選択されます。	spider (spider object) − It refers to the spider which was opened.
2	close_spider(self, spider) クモが閉じているときに選択されます。	spider (spider object) − It refers to the spider which was closed.
3	from_crawler(cls, crawler) クローラーの助けを借りて、パイプラインはScrapyの信号や設定などのコアコンポーネントにアクセスできます。	crawler (Crawler object) − It refers to the crawler that uses this pipeline.

例

以下は、さまざまな概念で使用されるアイテムパイプラインの例です。

タグのないアイテムのドロップ

次のコードでは、パイプラインは、VATを含まないアイテムの_（price）属性のバランスをとる（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形式のシリアル化形式で1行に1つのアイテムが含まれます。 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_設定にクラスを追加することにより、アイテムパイプラインコンポーネントをアクティブ化できます。 実行する順序でクラスに整数値を割り当てることができ（順序はより低い値からより高い値のクラスまで可能）、値は0〜1000の範囲になります。

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

Scrapy-フィードのエクスポート

説明

フィードエクスポートは、サイトからスクレイピングされたデータを保存する方法で、*「エクスポートファイル」*を生成します。

シリアル化形式

複数のシリアル化形式とストレージバックエンドを使用して、フィードエクスポートはアイテムエクスポーターを使用し、スクレイプされたアイテムを含むフィードを生成します。

次の表は、サポートされている形式を示しています

Sr.No	Format & Description
1	JSON FEED_FORMATは_json_です 使用されるエクスポーターは_class scrapy.exporters.JsonItemExporter_です
2	JSON lines FEED_FROMATは_jsonlines_です 使用されるエクスポーターは_class scrapy.exporters.JsonLinesItemExporter_です
3	CSV FEED_FORMATは_CSV_です 使用されるエクスポーターは_class scrapy.exporters.CsvItemExporter_です
4	XML FEED_FORMATは_xml_です 使用されるエクスポーターは_class scrapy.exporters.XmlItemExporter_です

*FEED_EXPORTERS* 設定を使用すると、サポートされている形式も拡張できます-

Sr.No	Format & Description
1	Pickle FEED_FORMATはピケルです 使用されるエクスポーターは_class scrapy.exporters.PickleItemExporter_です
2	Marshal FEED_FORMATはマーシャルです 使用されるエクスポーターは_class scrapy.exporters.MarshalItemExporter_です

ストレージバックエンド

ストレージバックエンドは、URIを使用してフィードを保存する場所を定義します。

次の表は、サポートされているストレージバックエンドを示しています-

Sr.No	Storage Backend & Description
1	Local filesystem URIスキームは_file_であり、フィードの保存に使用されます。
2	FTP URIスキームは_ftp_であり、フィードの保存に使用されます。
3	S3 URIスキームは_S3_であり、フィードはAmazon S3に保存されます。 外部ライブラリhttps://github.com/boto/botocore[botocore]またはhttps://github.com/boto/boto[boto]が必要です。
4	Standard output URIスキームは_stdout_であり、フィードは標準出力に保存されます。

ストレージURIパラメーター

以下は、フィードの作成中に置き換えられるストレージURLのパラメーターです-

• ％（time）s：このパラメーターはタイムスタンプに置き換えられます。 *％（name）s：このパラメーターはスパイダー名に置き換えられます。

設定

次の表は、フィードのエクスポートを構成できる設定を示しています-

Sr.No	Setting & Description
1	FEED_URI* これは、フィードのエクスポートを有効にするために使用されるエクスポートフィードのURIです。
2	FEED_FORMAT これは、フィードに使用されるシリアル化形式です。
3	FEED_EXPORT_FIELDS エクスポートする必要があるフィールドを定義するために使用されます。
4	FEED_STORE_EMPTY フィードをアイテムなしでエクスポートするかどうかを定義します。
5	FEED_STORAGES 追加のフィードストレージバックエンドを備えた辞書です。
6	FEED_STORAGES_BASE フィードストレージバックエンドが組み込まれた辞書です。
7	FEED_EXPORTERS フィードエクスポーターが追加された辞書です。
8	FEED_EXPORTERS_BASE フィードエクスポーターが組み込まれた辞書です。

スクレイピー-リクエストとレスポンス

説明

Scrapyは、 Request および Response オブジェクトを使用してWebサイトをクロールできます。 要求オブジェクトはシステムを通過し、スパイダーを使用して要求を実行し、応答オブジェクトを返すと要求に戻ります。

リクエストオブジェクト

要求オブジェクトは、応答を生成するHTTP要求です。 次のクラスがあります-

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

次の表は、リクエストオブジェクトのパラメータを示しています-

Sr.No	Parameter & Description
1	url URLリクエストを指定する文字列です。
2	callback これは、要求の応答を最初のパラメーターとして使用する呼び出し可能な関数です。
3	method HTTPメソッド要求を指定する文字列です。
4	headers これは、リクエストヘッダーを含む辞書です。
5	body 要求本文を持つ文字列またはユニコードです。
6	cookies これは、リクエストCookieを含むリストです。
7	meta これは、リクエストのメタデータの値を含む辞書です。
8	encoding URLのエンコードに使用されるutf-8エンコードを含む文字列です。
9	priority これは、スケジューラーが優先順位を使用して要求を処理する順序を定義する整数です。
10	dont_filter これは、スケジューラがリクエストをフィルタリングしないことを指定するブール値です。
11	errback 要求の処理中に例外が発生したときに呼び出される呼び出し可能な関数です。

追加データをコールバック関数に渡す

要求のコールバック関数は、応答が最初のパラメーターとしてダウンロードされるときに呼び出されます。

たとえば-

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

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

次の例に示すように、呼び出し可能な関数に引数を渡し、2番目のコールバックでそれらの引数を受け取りたい場合、 Request.meta 属性を使用できます-

def parse_page1(self, response):
   item = DemoItem()
   item['foremost_link'] = response.url
   request = scrapy.Request("http://www.something.com/some_pagel",
      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

リクエスト処理で例外をキャッチするためのエラーバックの使用

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のキーの一部を示しています-

Sr.No	Key & Description
1	dont_redirect trueに設定するとキーになり、応答のステータスに基づいて要求をリダイレクトしません。
2	dont_retry trueに設定するとキーになり、失敗した要求を再試行せず、ミドルウェアによって無視されます。
3	handle_httpstatus_list これは、要求ごとに許可できる応答コードを定義するキーです。
4	handle_httpstatus_all これは、_true_に設定することにより、要求の応答コードを許可するために使用されるキーです。
5	dont_merge_cookies これは、_true_に設定することにより、既存のCookieとのマージを回避するために使用されるキーです。
6	cookiejar これは、スパイダーごとに複数のCookieセッションを保持するために使用されるキーです。
7	dont_cache これは、各ポリシーでのHTTPリクエストとレスポンスのキャッシュを回避するために使用されるキーです。
8	redirect_urls これは、リクエストが通過するURLを含むキーです。
9	bindaddress 要求の実行に使用できるのは、発信IPアドレスのIPです。
10	dont_obey_robotstxt trueに設定するとキーになり、ROBOTSTXT_OBEYが有効になっている場合でも、robots.txt除外標準で禁止されているリクエストをフィルタリングしません。
11	download_timeout ダウンローダーがタイムアウトするまで待機するスパイダーごとのタイムアウト（秒単位）を設定するために使用されます。
12	download_maxsize ダウンローダーがダウンロードするスパイダーごとの最大サイズ（バイト単位）を設定するために使用されます。
13	proxy 要求オブジェクトにプロキシを設定して、要求を使用するためのHTTPプロキシを設定できます。

サブクラスのリクエスト

要求クラスをサブクラス化することにより、独自のカスタム機能を実装できます。 組み込みの要求サブクラスは次のとおりです-

FormRequestオブジェクト

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, ...])

次の表は、上記のクラスのパラメータを示しています-

Sr.No	Parameter & Description
1	response これは、応答のHTMLフォームを使用してフォームフィールドに事前入力するために使用されるオブジェクトです。
2	formname 指定されている場合、name属性を持つフォームが使用される文字列です。
3	formnumber 応答に複数のフォームがある場合に使用されるフォームの整数です。
4	formdata これは、オーバーライドに使用されるフォームデータのフィールドのディクショナリです。
5	formxpath 指定された場合は文字列で、xpathに一致する形式が使用されます。
6	formcss 指定された場合は文字列で、CSSセレクターに一致する形式が使用されます。
7	clickdata クリックされたコントロールを観察するために使用される属性の辞書です。
8	dont_click trueに設定されている場合、フォームからのデータは、要素をクリックせずに送信されます。

例

以下は、リクエストの使用例の一部です-

• 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（）を使用してユーザーログインをシミュレートする*

通常、Webサイトは、事前に入力されたフォームフィールドを提供する要素を使用します。

• 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])

次の表は、応答オブジェクトのパラメータを示しています-

Sr.No	Parameter & Description
1	url URL応答を指定する文字列です。
2	status HTTPステータスレスポンスを含む整数です。
3	headers これは、応答ヘッダーを含む辞書です。
4	body 応答本文を含む文字列です。
5	flags 応答のフラグを含むリストです。

応答サブクラス

応答クラスをサブクラス化することにより、独自のカスタム機能を実装できます。 組み込みの応答サブクラスは次のとおりです-

• TextResponseオブジェクト*

TextResponseオブジェクトは、画像、音声などのバイナリデータに使用されます。 基本Responseクラスをエンコードする機能があります。 次のクラスがあります-

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

以下はパラメータです-

*encoding* -応答のエンコードに使用されるエンコード付きの文字列です。

注-残りのパラメーターは応答クラスと同じで、*応答オブジェクト*セクションで説明されています。

次の表は、応答メソッドに加えて、TextResponseオブジェクトでサポートされる属性を示しています-

Sr.No	Attribute & Description
1	text response.textに複数回アクセスできる応答本文です。
2	encoding これは、応答のエンコードを含む文字列です。
3	selector これは、最初のアクセスでインスタンス化される属性であり、ターゲットとして応答を使用します。

次の表は、_response_メソッドに加えて_TextResponse_オブジェクトでサポートされるメソッドを示しています-

Sr.No	Method & Description
1	xpath (query) TextResponse.selector.xpath（query）へのショートカットです。
2	css (query) TextResponse.selector.css（query）へのショートカットです。
3	body_as_unicode() これはメソッドとして使用できる応答本文であり、response.textに複数回アクセスできます。

HtmlResponseオブジェクト

これは、HTMLの_meta httpequiv_属性を調べることにより、エンコードと自動検出をサポートするオブジェクトです。 そのパラメーターは応答クラスと同じであり、応答オブジェクトのセクションで説明されています。 次のクラスがあります-

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

XmlResponseオブジェクト

これは、XML行を見てエンコードと自動検出をサポートするオブジェクトです。 そのパラメーターは応答クラスと同じであり、応答オブジェクトのセクションで説明されています。 次のクラスがあります-

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

スクレイピー-リンク抽出

説明

名前自体が示すように、リンクエクストラクターは、 scrapy.http.Response オブジェクトを使用してWebページからリンクを抽出するために使用されるオブジェクトです。 Scrapyには、 scrapy.linkextractors import LinkExtractor などの組み込みエクストラクターがあります。 シンプルなインターフェースを実装することにより、ニーズに応じて独自のリンク抽出ツールをカスタマイズできます。

すべてのリンク抽出プログラムには、 extract_links と呼ばれるパブリックメソッドがあり、Responseオブジェクトを含み、scrapy.link.Linkオブジェクトのリストを返します。 リンクエクストラクターを1回だけインスタンス化し、extract_linksメソッドを何度も呼び出して、異なる応答のリンクを抽出できます。 CrawlSpiderclassは、リンクを抽出することを主な目的とする一連のルールでリンクエクストラクターを使用します。

組み込みのLink Extractorのリファレンス

通常、リンク抽出はScrapyでグループ化され、scrapy.linkextractorsモジュールで提供されます。 デフォルトでは、リンク抽出はLinkExtractorになり、LxmlLinkExtractorと機能的に同等です-

from scrapy.linkextractors import LinkExtractor

LxmlLinkExtractor

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で使用されるため、非常に推奨されるリンク抽出ツールです。

Sr.No	Parameter & Description
1	allow *(a regular expression (or list of)) 抽出されるURLに一致する単一の式または式のグループを許可します。 記載されていない場合は、すべてのリンクに一致します。
2	deny *(a regular expression (or list of)) 抽出されないURLに一致する単一の式または式のグループをブロックまたは除外します。 言及されていないか空のままになっている場合、不要なリンクは削除されません。
3	allow_domains *(str or list) リンクの抽出元のドメインに一致する単一の文字列または文字列のリストを許可します。
4	deny_domains *(str or list) リンクが抽出されないドメインに一致する単一の文字列または文字列のリストをブロックまたは除外します。
5	deny_extensions *(list) リンクを抽出するときに、拡張子を持つ文字列のリストをブロックします。 設定されていない場合、デフォルトで_IGNORED_EXTENSIONS_に設定され、_scrapy.linkextractors_パッケージに事前定義されたリストが含まれます。
6	restrict_xpaths *(str or list) これは、リンクが応答から抽出されるXPathリスト領域です。 指定すると、リンクはXPathによって選択されたテキストからのみ抽出されます。
7	restrict_css *(str or list) 応答内のCSSで選択された領域からリンクを抽出するrestrict_xpathsパラメーターと同様に動作します。
8	tags *(str or list) リンクを抽出するときに考慮する必要がある単一のタグまたはタグのリスト。 デフォルトでは、（「a」、「area」）になります。
9	attrs *(list) リンクを抽出する際には、単一の属性または属性のリストを考慮する必要があります。 デフォルトでは、（「href」）になります。
10	canonicalize *(boolean) 抽出されたURLは、_scrapy.utils.url.canonicalize_url_を使用して標準形式になります。 デフォルトでは、Trueになります。
11	unique *(boolean) 抽出されたリンクが繰り返される場合に使用されます。
12	process_value* (callable) これは、スキャンされたタグと属性から値を受け取る関数です。 受信した値は変更されて返されるか、リンクを拒否するために何も返されません。 使用しない場合、デフォルトではラムダx：xになります。

例

次のコードは、リンクを抽出するために使用されます-

<a href = "javascript:goToPage('../other/pagel'); 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プロジェクトを選択することもできます。

設定の指定

Webサイトをスクラップするときは、使用している設定をScrapyに通知する必要があります。 これには、環境変数 SCRAPY_SETTINGS_MODULE を使用し、その値はPythonパス構文である必要があります。

設定の入力

次の表は、設定を入力できるメカニズムの一部を示しています-

Sr.No	Mechanism & Description
1	Command line options ここでは、他のオプションをオーバーライドすることにより、渡される引数が最も優先されます。 -sは、1つ以上の設定をオーバーライドするために使用されます。 scrapy crawl myspider -s LOG_FILE = scrapy.log
2	Settings per-spider クモは、custom_settings属性を使用して、プロジェクトの設定を上書きする独自の設定を持つことができます。 class DemoSpider(scrapy.Spider): name = 'demo' custom_settings = { 'SOME_SETTING': 'some value', }
3	Project settings module ここで、settings.pyファイルの設定を追加または変更するなど、カスタム設定を入力できます。
4	Default settings per-command 各Scrapyツールコマンドは、default_settings属性で独自の設定を定義し、グローバルなデフォルト設定を上書きします。
5	Default global settings これらの設定は、scrapy.settings.default_settingsモジュールにあります。

アクセス設定

これらは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の組み込み設定を示しています-

Sr.No	Setting & Description
1	AWS_ACCESS_KEY_ID Amazon Webサービスへのアクセスに使用されます。 デフォルト値：なし
2	AWS_SECRET_ACCESS_KEY Amazon Webサービスへのアクセスに使用されます。 デフォルト値：なし
3	BOT_NAME User-Agentの構築に使用できるボットの名前です。 デフォルト値： 'scrapybot'
4	CONCURRENT_ITEMS 並列処理に使用されるアイテムプロセッサ内の既存のアイテムの最大数。 デフォルト値：100
5	CONCURRENT_REQUESTS Scrapyダウンローダーが実行する既存のリクエストの最大数。 デフォルト値：16
6	CONCURRENT_REQUESTS_PER_DOMAIN 任意の単一ドメインで同時に実行される既存のリクエストの最大数。 デフォルト値：8
7	CONCURRENT_REQUESTS_PER_IP 任意の単一IPに対して同時に実行される既存のリクエストの最大数。 デフォルト値：0
8	DEFAULT_ITEM_CLASS アイテムを表すために使用されるクラスです。 デフォルト値： 'scrapy.item.Item'
9	DEFAULT_REQUEST_HEADERS これは、ScrapyのHTTP要求に使用されるデフォルトのヘッダーです。 デフォルト値- { 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9, */*;q=0.8', 'Accept-Language': 'en', }
10	DEPTH_LIMIT クモがサイトをクロールする最大の深さ。 デフォルト値：0
11	DEPTH_PRIORITY これは、深さに応じてリクエストの優先度を変更するために使用される整数です。 デフォルト値：0
12	DEPTH_STATS 深度統計を収集するかどうかを示します。 デフォルト値：True
13	DEPTH_STATS_VERBOSE この設定を有効にすると、要求の数が詳細レベルごとに統計で収集されます。 デフォルト値：False
14	DNSCACHE_ENABLED メモリキャッシュでDNSを有効にするために使用されます。 デフォルト値：True
15	DNSCACHE_SIZE メモリキャッシュ内のDNSのサイズを定義します。 デフォルト値：10000
16	DNS_TIMEOUT DNSがクエリを処理するためのタイムアウトを設定するために使用されます。 デフォルト値：60
17	DOWNLOADER クロールプロセスに使用されるダウンローダーです。 デフォルト値： 'scrapy.core.downloader.Downloader'
18	DOWNLOADER_MIDDLEWARES これは、ダウンローダーミドルウェアとその注文を保持する辞書です。 デフォルト値：\ {}
19	DOWNLOADER_MIDDLEWARES_BASE これは、デフォルトで有効になっているダウンローダーミドルウェアを保持する辞書です。 デフォルト値- { 'scrapy.downloadermiddlewares.robotstxt.RobotsTxtMiddleware': 100, }
20	DOWNLOADER_STATS この設定は、ダウンローダーの統計を有効にするために使用されます。 デフォルト値：True
21	DOWNLOAD_DELAY サイトからページをダウンロードするまでのダウンローダーの合計時間を定義します。 デフォルト値：0
22	DOWNLOAD_HANDLERS これは、ダウンロードハンドラーを備えた辞書です。 デフォルト値：\ {}
23	DOWNLOAD_HANDLERS_BASE これは、デフォルトで有効になっているダウンロードハンドラーを備えた辞書です。 デフォルト値- { 'file': 'scrapy.core.downloader.handlers.file.FileDownloadHandler', }
24	DOWNLOAD_TIMEOUT ダウンローダーがタイムアウトするまで待機する合計時間です。 デフォルト値：180
25	DOWNLOAD_MAXSIZE ダウンローダーがダウンロードする応答の最大サイズです。 デフォルト値：1073741824（1024MB）
26	DOWNLOAD_WARNSIZE ダウンローダーが警告する応答のサイズを定義します。 デフォルト値：33554432（32MB）
27	DUPEFILTER_CLASS これは、重複するリクエストの検出とフィルタリングに使用されるクラスです。 デフォルト値： 'scrapy.dupefilters.RFPDupeFilter'
28	DUPEFILTER_DEBUG trueに設定すると、この設定はすべての重複フィルターをログに記録します。 デフォルト値：False
29	EDITOR editコマンドを使用してスパイダーを編集するために使用されます。 デフォルト値：環境に依存
30	EXTENSIONS これは、プロジェクトで有効になっている拡張機能を持つ辞書です。 デフォルト値：\ {}
31	EXTENSIONS_BASE 拡張機能が組み込まれた辞書です。 デフォルト値：\ {'scrapy.extensions.corestats.CoreStats'：0、}
32	FEED_TEMPDIR クローラーの一時ファイルを保存できるカスタムフォルダーを設定するために使用されるディレクトリです。
33	ITEM_PIPELINES パイプラインを持つ辞書です。 デフォルト値：\ {}
34	LOG_ENABLED ロギングを有効にするかどうかを定義します。 デフォルト値：True
35	LOG_ENCODING ロギングに使用されるエンコードのタイプを定義します。 デフォルト値： 'utf-8'
36	LOG_FILE ロギングの出力に使用されるファイルの名前です。 デフォルト値：なし
37	LOG_FORMAT これは、ログメッセージのフォーマットに使用できる文字列です。 デフォルト値： '％（asctime）s [％（name）s]％（levelname）s：％（message）s'
38	LOG_DATEFORMAT これは、日付/時刻をフォーマットできる文字列です。 デフォルト値： '％Y-％m-％d％H：％M：％S'
39	LOG_LEVEL 最小ログレベルを定義します。 デフォルト値： 'DEBUG'
40	LOG_STDOUT この設定をtrueに設定すると、すべてのプロセス出力がログに表示されます。 デフォルト値：False
41	MEMDEBUG_ENABLED メモリデバッグを有効にするかどうかを定義します。 デフォルト値：False
42	MEMDEBUG_NOTIFY メモリデバッグが有効なときに特定のアドレスに送信されるメモリレポートを定義します。 デフォルト値：[]
43	MEMUSAGE_ENABLED Scrapyプロセスがメモリ制限を超えたときにメモリ使用量を有効にするかどうかを定義します。 デフォルト値：False
44	MEMUSAGE_LIMIT_MB 許可されるメモリの最大制限（メガバイト単位）を定義します。 デフォルト値：0
45	MEMUSAGE_CHECK_INTERVAL_SECONDS 間隔の長さを設定することにより、現在のメモリ使用量を確認するために使用されます。 デフォルト値：60.0
46	MEMUSAGE_NOTIFY_MAIL メモリが制限に達すると、電子メールのリストで通知するために使用されます。 デフォルト値：False
47	MEMUSAGE_REPORT 各クモを閉じるときにメモリ使用量レポートを送信するかどうかを定義します。 デフォルト値：False
48	MEMUSAGE_WARNING_MB 警告が送信される前に許可される合計メモリを定義します。 デフォルト値：0
49	NEWSPIDER_MODULE これは、genspiderコマンドを使用して新しいスパイダーが作成されるモジュールです。 デフォルト値：
50	RANDOMIZE_DOWNLOAD_DELAY Scrapyがサイトからリクエストをダウンロードしている間に待機するランダムな時間を定義します。 デフォルト値：True
51	REACTOR_THREADPOOL_MAXSIZE これは、リアクタースレッドプールの最大サイズを定義します。 デフォルト値：10
52	REDIRECT_MAX_TIMES リクエストをリダイレクトできる回数を定義します。 デフォルト値：20
53	REDIRECT_PRIORITY_ADJUST この設定を設定すると、リクエストのリダイレクト優先度が調整されます。 デフォルト値：+2
54	RETRY_PRIORITY_ADJUST この設定は、設定されると、リクエストの再試行優先度を調整します。 デフォルト値：-1
55	ROBOTSTXT_OBEY _true_に設定されている場合、scrapyはrobots.txtポリシーに従います。 デフォルト値：False
56	SCHEDULER クロールの目的で使用されるスケジューラを定義します。 デフォルト値： 'scrapy.core.scheduler.Scheduler'
57	SPIDER_CONTRACTS これは、クモをテストするためのクモ契約を持つプロジェクト内の辞書です。 デフォルト値：\ {}
58	SPIDER_CONTRACTS_BASE これは、Scrapyでデフォルトで有効になっているScrapyコントラクトを保持する辞書です。 デフォルト値- { 'scrapy.contracts.default.UrlContract' : 1, 'scrapy.contracts.default.ReturnsContract': 2, }
59	SPIDER_LOADER_CLASS スパイダーをロードする_SpiderLoader API_を実装するクラスを定義します。 デフォルト値： 'scrapy.spiderloader.SpiderLoader'
60	SPIDER_MIDDLEWARES スパイダーミドルウェアを保持する辞書です。 デフォルト値：\ {}
61	SPIDER_MIDDLEWARES_BASE これは、Scrapyでデフォルトで有効になっているスパイダーミドルウェアを保持する辞書です。 デフォルト値- { 'scrapy.spidermiddlewares.httperror.HttpErrorMiddleware': 50, }
62	SPIDER_MODULES Scrapyが探すスパイダーを含むモジュールのリストです。 デフォルト値：[]
63	STATS_CLASS Stats Collector APIを実装して統計を収集するクラスです。 デフォルト値： 'scrapy.statscollectors.MemoryStatsCollector'
64	STATS_DUMP この設定をtrueに設定すると、統計がログにダンプされます。 デフォルト値：True
65	STATSMAILER_RCPTS スパイダーがスクレイピングを完了すると、Scrapyはこの設定を使用して統計を送信します。 デフォルト値：[]
66	TELNETCONSOLE_ENABLED telnetconsoleを有効にするかどうかを定義します。 デフォルト値：True
67	TELNETCONSOLE_PORT telnetコンソールのポートを定義します。 デフォルト値：[6023、6073]
68	TEMPLATES_DIR これは、新しいプロジェクトの作成中に使用できるテンプレートを含むディレクトリです。 デフォルト値：スクレイピーモジュール内のテンプレートディレクトリ
69	URLLENGTH_LIMIT クロールされたURLに許可されるURLの長さの最大制限を定義します。 デフォルト値：2083
70	USER_AGENT サイトのクロール中に使用されるユーザーエージェントを定義します。 デフォルト値：「Scrapy/VERSION（+ http：//scrapy.org）」

その他のScrapy設定については、次のリンクにアクセスしてください：/scrapy/scrapy_other_settings [link]。

スクレイピー-例外

説明

不規則なイベントは例外と呼ばれます。 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')

IgnoreRequest

この例外は、スケジューラまたはダウンローダーミドルウェアが要求を無視するために使用されます。 それは次のように書くことができます-

exception (scrapy.exceptions.IgnoreRequest)

未構成

構成が欠落していることを示しており、コンポーネントコンストラクターで発生する必要があります。

exception (scrapy.exceptions.NotConfigured)

次のコンポーネントのいずれかが無効になっている場合、この例外が発生する可能性があります。

• 拡張機能
• アイテムパイプライン
• ダウンローダーミドルウェア
• スパイダーミドルウェア

サポートされていません

この例外は、機能またはメソッドがサポートされていない場合に発生します。 それは次のように書くことができます-

exception (scrapy.exceptions.NotSupported)

スクレイピー-プロジェクトを作成する

説明

Webページからデータをスクラップするには、まずコードを保存する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

スクレイピー-アイテムを定義する

説明

アイテムは、Webサイトから廃棄されるデータを収集するために使用されるコンテナです。 アイテムを定義してクモを起動する必要があります。 アイテムを定義するには、ディレクトリ 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がすでに作成したいくつかの事前定義済みオブジェクトを含む_Item_を継承します。 たとえば、サイトから名前、URL、説明を抽出する場合、これらの3つの属性のそれぞれにフィールドを定義する必要があります。

したがって、収集したいアイテムを追加しましょう-

from scrapy.item import Item, Field

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

スクレイピー-最初のSp

説明

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] + 'l'
      with open(filename, 'wb') as f:
         f.write(response.body)

スクレイピー-クロール

説明

スパイダーを実行するには、_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が開始URLであり、リファラーがないことを示すログ行があります。 次に、_Booksl_および_Resourcesl_という名前の2つの新しいファイルが_first_scrapy_ディレクトリに作成されます。

スクレイピー-アイテムの抽出

説明

Webページからデータを抽出するために、Scrapyはhttps://www.w3.org/TR/xpath/[XPath]およびhttps://www.w3.org/TR/selectors/[CSS]に基づくセレクターと呼ばれる手法を使用します式。 以下は、XPath式のいくつかの例です-

• /html/head/title -これにより、HTMLドキュメントの<head>要素内の<title>要素が選択されます。
• /html/head/title/text（）-これは、同じ<title>要素内のテキストを選択します。
• //td -これは、<td>からすべての要素を選択します。
• //div [@class = "slice"] -これは_div_から属性class = "slice"を含むすべての要素を選択します

セレクタには、次の表に示す4つの基本的な方法があります-

Sr.No	Method & Description
1	extract() 選択したデータとともにUnicode文字列を返します。
2	re() 正規表現が引数として与えられたときに抽出されたUnicode文字列のリストを返します。
3	xpath() 引数として指定されたxpath式で選択されたノードを表すセレクターのリストを返します。
4	css() 引数として指定されたCSS式で選択されたノードを表すセレクターのリストを返します。

シェルでセレクターを使用する

組み込みのScrapyシェルでセレクターをデモンストレーションするには、システムにhttps://ipython.org/[IPython]がインストールされている必要があります。 ここで重要なことは、Scrapyの実行中にURLを引用符に含める必要があることです。そうしないと、「＆」文字を含むURLは機能しません。 あなたは、プロジェクトのトップレベルディレクトリで次のコマンドを使用してシェルを開始することができます-

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]:

シェルがロードされると、それぞれ_response.body_と_response.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

スクレイピー-アイテムの使用

説明

*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/scrapy_using_item [前のコード]次のように表示-

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)

スクレイピー-スクレイピングされたデータ

説明

スクレイピングされたデータを保存する最良の方法は、フィードエクスポートを使用することです。これにより、複数のシリアル化形式を使用してデータが適切に保存されます。 JSON、JSON行、CSV、XMLは、シリアル化形式で容易にサポートされる形式です。 データは、次のコマンドで保存することができます-

scrapy crawl dmoz -o data.json

このコマンドは、JSONのスクレイピングデータを含む data.json ファイルを作成します。 この手法は、少量のデータに適しています。 大量のデータを処理する必要がある場合は、アイテムパイプラインを使用できます。 data.jsonファイルと同様に、プロジェクトが tutorial/pipelines.py で作成されると、予約ファイルがセットアップされます。

スクレイピー-ロギング

説明

• ロギング*は、イベントの追跡を意味します。これは、組み込みのロギングシステムを使用し、アプリケーションとライブラリを実装する関数とクラスを定義します。 ロギングはすぐに使用できる素材であり、ロギング設定にリストされているスクレイピー設定で使用できます。

Scrapyはいくつかのデフォルト設定を設定し、コマンドの実行時にscrapy.utils.log.configure_logging（）の助けを借りてそれらの設定を処理します。

ログレベル

Pythonでは、ログメッセージに5つの異なるレベルの重大度があります。 次のリストは、昇順で標準ログメッセージを示しています-

• 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")

今、あなたはまた、ロガーを使用して、次のように明確に示されたロギングメッセージを取得するロギングヘルパーロギングを使用してメッセージを囲むことができます-

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に設定すると、プロセスのすべての標準出力とエラーメッセージがログにリダイレクトされます。

コマンドラインオプション

スクレイピー設定は、次の表に示すようにコマンドライン引数を渡すことでオーバーライドできます-

Sr.No	Command & Description
1	--logfile FILE _LOG_FILE_をオーバーライドします
2	--loglevel/-L LEVEL _LOG_LEVEL_をオーバーライドします
3	--nolog _LOG_ENABLED_をFalseに設定します

scrapy.utils.logモジュール

この関数は、Scrapyのデフォルトのロギングを初期化するために使用できます。

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

Sr.No	Parameter & Description
1	settings (dict, None) ルートロガーのハンドラーを作成および構成します。 デフォルトでは、_None_です。
2	install_root_handler (bool) ルートロギングハンドラーのインストールを指定します。 デフォルトでは、_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
)

スクレイピー-統計コレクション

説明

Stats Collectorは、キー/値の形式で統計を収集するためにScrapyが提供する機能であり、Crawler APIを使用してアクセスされます（CrawlerはすべてのScrapyコアコンポーネントへのアクセスを提供します）。 統計情報コレクターは、スパイダーごとに1つの統計表を提供します。このテーブルでは、スパイダーが開いているときに統計情報コレクターが自動的に開き、スパイダーが閉じているときに統計情報コレクターを閉じます。

一般的な統計コレクターの使用

次のコードは、 stats 属性を使用して統計情報コレクターにアクセスします。

class ExtensionThatAccessStats(object):
   def __init__(self, stats):
      self.stats = stats

   @classmethod
   def from_crawler(cls, crawler):
      return cls(crawler.stats)

次の表は、統計コレクターで使用できるさまざまなオプションを示しています-

Sr.No	Parameters	Description
1	stats.set_value('hostname', socket.gethostname())	It is used to set the stats value.
2	stats.inc_value('customized_count')	It increments the stat value.
3	stats.max_value('max_items_scraped', value)	You can set the stat value, only if greater than previous value.
4	stats.min_value('min_free_memory_percent', value)	You can set the stat value, only if lower than previous value.
5	stats.get_value('customized_count')	It fetches the stat value.
6	stats.get_stats() {'custom_count': 1, 'start_time': datetime.datetime(2009, 7, 14, 21, 47, 28, 977139)}	It fetches all the stats

利用可能な統計情報コレクター

Scrapyは、 STATS_CLASS 設定を使用してアクセスできるさまざまなタイプの統計情報コレクターを提供します。

MemoryStatsCollector

これは、スクレイピングに使用されたすべてのスパイダーの統計情報を保持するデフォルトの統計情報コレクターであり、データはメモリに保存されます。

class scrapy.statscollectors.MemoryStatsCollector

DummyStatsCollector

この統計情報コレクターは非常に効率的で、何もしません。 これは、_STATS_CLASS_設定を使用して設定でき、パフォーマンスを改善するために統計コレクションを無効にするために使用できます。

class scrapy.statscollectors.DummyStatsCollector

スクレイピー-電子メールの送信

説明

Scrapyは、https://twistedmatrix.com/documents/current/core/howto/defer-introl [Twisted non-blocking IO]と呼ばれる独自の機能を使用して電子メールを送信でき、クローラーの非ブロックIOを回避します。 メール送信のいくつかの設定を構成し、添付ファイルを送信するためのシンプルなAPIを提供できます。

次の表に示すようにMailSenderをインスタンス化する2つの方法があります-

Sr.No	Parameters	Method
1	from scrapy.mail import MailSender mailer = MailSender()	By using a standard constructor.
2	mailer = MailSender.from_settings(settings)	By using Scrapy settings object.

次の行は、添付ファイルなしで電子メールを送信します-

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

MailSenderクラスリファレンス

MailSenderクラスは、Scrapyからメールを送信するためにhttps://twistedmatrix.com/documents/current/core/howto/defer-introl[Twisted non-blocking IO]を使用します。

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

次の表は、_MailSender_クラスで使用されるパラメータを示しています-

Sr.No	Parameter & Description
1	smtphost (str) SMTPホストは、電子メールの送信に使用されます。 そうでない場合は、_MAIL_HOST_設定が使用されます。
2	mailfrom (str) 受信者のアドレスは、電子メールの送信に使用されます。 そうでない場合は、_MAIL_FROM_設定が使用されます。
3	smtpuser SMTPユーザーを指定します。 使用されない場合、_MAIL_USER_設定が使用され、記載されていない場合はSMTP検証は行われません。
4	smtppass (str) 検証用のSMTPパスを指定します。
5	smtpport (int) 接続用のSMTPポートを指定します。
6	smtptls (boolean) SMTP STARTTLSを使用して実装します。
7	smtpssl (boolean) 安全なSSL接続を使用して管理します。

次の2つのメソッドは、指定されたMailSenderクラス参照にあります。 最初の方法、

classmethod from_settings(settings)

Scrapy設定オブジェクトを使用して組み込みます。 次のパラメータが含まれています-

• settings（scrapy.settings.Settingsオブジェクト）*-電子メールの受信者として扱われます。

別の方法、

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

次の表には、上記のメソッドのパラメータが含まれています-

Sr.No	Parameter & Description
1	to (list) 電子メールの受信者を指します。
2	subject (str) 電子メールの件名を指定します。
3	cc (list) 受信者のリストを参照します。
4	body (str) 電子メールの本文データを指します。
5	attachs (iterable) メールの添付ファイル、添付ファイルのMIMEタイプ、添付ファイルの名前を参照します。
6	mimetype (str) 電子メールのMIMEタイプを表します。
7	charset (str) 電子メールのコンテンツに使用される文字エンコードを指定します。

メール設定

次の設定により、コードを記述せずに、プロジェクトのMailSenderクラスを使用して電子メールを構成できます。

Sr.No	Settings & Description	Default Value
1	MAIL_FROM 電子メールを送信するための送信者の電子メールを指します。	'scrapy@localhost'
2	MAIL_HOST 電子メールの送信に使用されるSMTPホストを指します。	'localhost'
3	MAIL_PORT 電子メールの送信に使用されるSMTPポートを指定します。	25
4	MAIL_USER SMTP検証を指します。 この設定が無効に設定されている場合、検証は行われません。	None
5	MAIL_PASS SMTP検証に使用されるパスワードを提供します。	None
6	MAIL_TLS SSL/TLSを使用して、安全でない接続を安全な接続にアップグレードする方法を提供します。	False
7	MAIL_SSL SSL暗号化接続を使用して接続を実装します。	False

スクレイピー-Telnetコンソール

説明

Telnetコンソールは、Scrapyプロセス内で実行されるPythonシェルであり、Scrapy実行プロセスの検査と制御に使用されます。

Telnetコンソールにアクセス

telnetコンソールは、次のコマンドを使用してアクセスできます-

telnet localhost 6023

基本的に、telnetコンソールはTCPポートにリストされます。これについては、 TELNETCONSOLE_PORT 設定で説明されています。

変数

次の表に示されているデフォルト変数のいくつかは、ショートカットとして使用されます-

Sr.No	Shortcut & Description
1	crawler これは、Scrapy Crawler（scrapy.crawler.Crawler）オブジェクトを指します。
2	engine これはCrawler.engine属性を指します。
3	spider これはアクティブなクモを指します。
4	slot これはエンジンスロットを指します。
5	extensions これは、Extension Manager（Crawler.extensions）属性を指します。
6	stats これは、統計コレクター（Crawler.stats）属性を指します。
7	setting これは、Scrapy設定オブジェクト（Crawler.settings）属性を指します。
8	est これは、エンジンステータスのレポートを印刷することを意味します。
9	prefs これは、デバッグ用のメモリを指します。
10	p これは、https://docs.python.org/3/library/pprintl#pprint.pprint [pprint.pprint]関数へのショートカットを指します。
11	hpy これはメモリのデバッグを指します。

例

以下は、Telnetコンソールを使用したいくつかの例です。

Scrapyエンジンの一時停止、再開、停止

スクレイピーエンジンを一時停止するには、次のコマンドを使用します-

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

スクレイピーエンジンを再開するには、次のコマンドを使用します-

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

スクレイピーエンジンを停止するには、次のコマンドを使用します-

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設定

次の表は、Telnetコンソールの動作を制御する設定を示しています-

Sr.No	Settings & Description	Default Value
1	TELNETCONSOLE_PORT これは、telnetコンソールのポート範囲を指します。 noneに設定されている場合、ポートは動的に割り当てられます。	[6023, 6073]
2	TELNETCONSOLE_HOST これは、Telnetコンソールがリッスンするインターフェイスを指します。	'127.0.0.1'

スクレイピー-Webサービス

説明

実行中のScrapy Webクローラーは、 JSON-RPC を介して制御できます。 JSONRPC_ENABLED設定により有効になります。 このサービスは、https://www.jsonrpc.org/[JSON-RPC 2.0]プロトコルを介してメインクローラーオブジェクトへのアクセスを提供します。 クローラーオブジェクトにアクセスするためのエンドポイントは-

http://localhost:6080/crawler

次の表には、Webサービスの動作を示す設定の一部が含まれています-

Sr.No	Setting & Description	Default Value
1	JSONRPC_ENABLED これはブール値を指します。これは、Webサービスとその拡張機能を有効にするかどうかを決定します。	True
2	JSONRPC_LOGFILE これは、Webサービスに対して行われたHTTP要求のログに使用されるファイルを指します。 設定されていない場合、標準のScrapyログが使用されます。	None
3	JSONRPC_PORT これは、Webサービスのポート範囲を指します。 noneに設定されている場合、ポートは動的に割り当てられます。	[6080, 7030]
4	JSONRPC_HOST これは、Webサービスがリッスンするインターフェイスを指します。	'127.0.0.1'