スパイダー¶

スパイダーは、特定のサイト(またはサイトのグループ)のスクレイピング方法を定義するクラスです。クロールの実行方法(リンクの追跡など)やページから構造化データを抽出する方法(アイテムのスクレイピングなど)を含みます。つまり、スパイダーは、特定のサイト(場合によってはサイトのグループ)のページをクロールおよび解析するためのカスタム動作を定義する場所です。

スパイダーのためのスクレイピング・サイクルは以下の通りです:

最初のリクエストを生成して最初のURLをクロールし、それらのリクエストからダウンロードされたレスポンスで呼び出されるコールバック関数を指定することから始めます。

実行する最初のリクエストは、(デフォルトで) start_urls で指定されたURLの Request を生成する start_requests() メソッドと、リクエストのコールバック関数として parse メソッドを呼び出すことによって取得されます。
コールバック関数内では、レスポンス(Webページ)を解析し、抽出されたデータ、 Item オブジェクト、 Request オブジェクト、またはこれらのオブジェクトの反復可能オブジェクトを含む辞書を返します。これらのリクエストにはコールバックも含まれ(同じコールバックの場合もあります)、Scrapyによってダウンロードされ、指定されたコールバックによってレスポンスが処理されます。
コールバック関数内では、通常セレクターを使用してページ内容をパースし、パースしたデータでアイテムを生成します(しかし、パースには、BeautifulSoup、lxml、または任意のメカニズムを使用することもできます)。
最後に、スパイダーから返されたアイテムは通常、データベースに保存されます(アイテムパイプラインを使う事もあります)またはフィード・エクスポートを使用してファイルに書き込まれます。

このサイクルはあらゆる種類のスパイダーに適用されます。そして更に、さまざまな目的の為のさまざまな種類のデフォルト・スパイダーがScrapyに同梱されています。以降、これらについても説明します。

scrapy.Spider¶

class scrapy.spiders.Spider¶

これは最も単純なスパイダーであり、他のすべてのスパイダーの継承元となるものです(Scrapyにバンドルされているスパイダーや、自分で作成したスパイダーを含む)。特別な機能は提供しません。 start_urls スパイダー属性からリクエストを送信し、結果の各レスポンスに対してスパイダーのメソッド parse を呼び出すデフォルトの start_requests() 実装を提供するだけです。

name¶

このスパイダーの名前を定義する文字列。スパイダー名は、スパイダーがScrapyによってどのように配置(およびインスタンス化)されるかであるため、一意でなければなりません。ただし、同じスパイダーの複数のインスタンスをインスタンス化することを妨げるものはありません。これは最も重要なスパイダーの属性であり、必須です。

スパイダーが単一のドメインをスクレイピングする場合、一般的な方法は、TLD の有無にかかわらず、ドメインに基づいてスパイダーに名前を付けることです。よって、たとえば、 mywebsite.com をクロールするスパイダーは、しばしば mywebsite と呼ばれます。

注釈

Python2では、これはASCII文字のみでなければなりません。

allowed_domains¶

このスパイダーがクロールできるドメインを含む文字列のオプションのリスト。 OffsiteMiddleware が有効になっている場合、このリスト(またはそのサブドメイン)で指定されたドメイン名に属さないURLのリクエストは追跡されません。

あなたのターゲットURLが https://www.example.com/1.html である場合、リストに 'example.com' を追加します。

start_urls¶: 特定のURLが指定されていない場合に、スパイダーがクロールを開始するURLのリスト。したがって、ダウンロードされる最初のページはここにリストされているページになります。後続の Request は、開始URLに含まれるデータから連続して生成されます。

custom_settings¶

このスパイダーを実行するときにプロジェクト全体の設定から上書きされる設定の辞書。インスタンス化の前に設定が更新されるため、クラス属性として定義する必要があります。

利用可能な組み込み設定のリストについては、組み込みの設定リファレンスを参照してください。

crawler¶

この属性は、クラスを初期化した後に from_crawler() クラスメソッドによって設定され、このスパイダーインスタンスがバインドされている Crawler オブジェクトにリンクします。

クローラーは、単一のエントリアクセス(拡張機能、ミドルウェア、シグナルマネージャーなど)のために、プロジェクト内の多くのコンポーネントをカプセル化します。クローラーAPI を参照して、それらの詳細を確認してください。

settings¶: このスパイダーを実行するための構成(Configuration)。これは Settings のインスタンスです。この主題の詳細な紹介については設定トピックを参照してください。

logger¶: Spiderの name で作成されたPythonロガー。スパイダーからのロギングで説明されているように、これを使用してログメッセージを送信できます。

from_crawler(crawler, *args, **kwargs)¶

これは、Scrapyがスパイダーを作成するために使用するクラスメソッドです。

デフォルトの実装は __init__() メソッドのプロキシとして機能し、指定された引数 args および名前付き引数 kwargs で呼び出すため、おそらくあなたがこれを直接オーバーライドする必要はありません。

それにもかかわらず、このメソッドは新しいインスタンスで crawler および settings 属性を設定するため、スパイダーのコード内で後からアクセスできます。

パラメータ

crawler (Crawler instance) -- スパイダーをバインドするクローラー
args (list) -- __init__() メソッドに渡される引数
kwargs (dict) -- __init__() メソッドに渡されるキーワード引数

start_requests()¶

このメソッドは、このスパイダーの最初のクロール要求で反復可能オブジェクト(iterable)を返す必要があります。スパイダーがスクレイピングのために開かれると、Scrapyによって呼び出されます。 Scrapyはこれを1回だけ呼び出すため、ジェネレータとして start_requests() を実装しても安全です。

デフォルトの実装は、 start_urls の各URLに対して Request(url, dont_filter=True) を生成します。

ドメインのスクレイピングを開始するために使用されるリクエストを変更する場合、これはオーバーライドするメソッドです。たとえば、POST要求を使用してログインすることから開始する必要がある場合は、以下の通りです:

class MySpider(scrapy.Spider):
    name = 'myspider'

    def start_requests(self):
        return [scrapy.FormRequest("http://www.example.com/login",
                                   formdata={'user': 'john', 'pass': 'secret'},
                                   callback=self.logged_in)]

    def logged_in(self, response):
        # here you would extract links to follow and return Requests for
        # each of them, with another callback
        pass

parse(response)¶

これは、リクエストでコールバックが指定されていない場合に、ダウンロードされたレスポンスを処理するためにScrapyが使用するデフォルトのコールバックです。

parse メソッドは、レスポンスを処理し、スクレイピングされたデータや後続のURLを返します。他のリクエストのコールバックには、 Spider クラスと同じ必要条件があります。

このメソッドは、他のリクエストコールバックと同様に、 Request の反復可能オブジェクト(iterable) and/or 辞書または Item オブジェクトを返さなければなりません。

パラメータ: response (Response) -- パース対象のレスポンス

log(message[, level, component])¶: Spiderの logger を介してログメッセージを送信するラッパー。後方互換性のために保持されています。詳細については、スパイダーからのロギングを参照してください。

closed(reason)¶: スパイダーが閉じるときに呼び出されます。このメソッドは、 spider_closed シグナルの signals.connect() へのショートカットを提供します。

ある例を見てみましょう:

import scrapy


class MySpider(scrapy.Spider):
    name = 'example.com'
    allowed_domains = ['example.com']
    start_urls = [
        'http://www.example.com/1.html',
        'http://www.example.com/2.html',
        'http://www.example.com/3.html',
    ]

    def parse(self, response):
        self.logger.info('A response from %s just arrived!', response.url)

単一のコールバックから複数のリクエストとアイテムを返します:

import scrapy

class MySpider(scrapy.Spider):
    name = 'example.com'
    allowed_domains = ['example.com']
    start_urls = [
        'http://www.example.com/1.html',
        'http://www.example.com/2.html',
        'http://www.example.com/3.html',
    ]

    def parse(self, response):
        for h3 in response.xpath('//h3').getall():
            yield {"title": h3}

        for href in response.xpath('//a/@href').getall():
            yield scrapy.Request(response.urljoin(href), self.parse)

start_urls の代わりに、あなたは、 start_requests() を直接使用することができます。データをさらに構造化するには、アイテムを使用できます:

import scrapy
from myproject.items import MyItem

class MySpider(scrapy.Spider):
    name = 'example.com'
    allowed_domains = ['example.com']

    def start_requests(self):
        yield scrapy.Request('http://www.example.com/1.html', self.parse)
        yield scrapy.Request('http://www.example.com/2.html', self.parse)
        yield scrapy.Request('http://www.example.com/3.html', self.parse)

    def parse(self, response):
        for h3 in response.xpath('//h3').getall():
            yield MyItem(title=h3)

        for href in response.xpath('//a/@href').getall():
            yield scrapy.Request(response.urljoin(href), self.parse)

スパイダー引数¶

スパイダーは、振る舞いを変更する引数を受け取ることができます。スパイダー引数の一般的な使用法のいくつかは、開始URLを定義するか、サイトの特定のセクションへのクロールを制限することですが、スパイダーの機能を構成(configure)するためでも使用できます。

スパイダー引数は、 crawl コマンドの -a コマンドライン・オプションを使用して渡します。

scrapy crawl myspider -a category=electronics

スパイダーは、 __init__ メソッド内の引数にアクセスできます。:

import scrapy

class MySpider(scrapy.Spider):
    name = 'myspider'

    def __init__(self, category=None, *args, **kwargs):
        super(MySpider, self).__init__(*args, **kwargs)
        self.start_urls = ['http://www.example.com/categories/%s' % category]
        # ...

デフォルトの __init__ メソッドはスパイダー引数を取り、それらを属性としてスパイダーにコピーします。上記の例は次のように書くこともできます:

import scrapy

class MySpider(scrapy.Spider):
    name = 'myspider'

    def start_requests(self):
        yield scrapy.Request('http://www.example.com/categories/%s' % self.category)

スパイダー引数は文字列にすぎないことに注意してください。スパイダー自身はスパイダー引数文字列の解析を行いません。コマンドラインから start_urls 属性を設定する場合、 ast.literal_eval や json.loads のようなのを使用して自分でリストに落とし込み、それを属性として設定する必要があります。そうしないと、start_urls 文字列を反復して、各文字が個別のURLとして認識されることになります(訳注:pythonによくある落とし穴で、list('hoge') は ['h','o','g','e'] になる)。

有効なユースケースは、 http認証資格情報(auth credentials)に使用される HttpAuthMiddleware またはユーザエージェントとして使用される UserAgentMiddleware を設定することです。

scrapy crawl myspider -a http_user=myuser -a http_pass=mypassword -a user_agent=mybot

スパイダー引数は、Scrapyd schedule.json APIを介して渡すこともできます。 Scrapyd documentation をご覧ください。

汎用スパイダー¶

Scrapyには、スパイダーのサブクラス化に使用できる便利な汎用スパイダーがいくつか付属しています。それらの目的は、特定のルールに基づいてサイト上のすべてのリンクをたどったり、サイトマップからクロールしたり、XML/CSVフィードを解析するなど、いくつかの一般的なスクレイピング・パターンに便利な機能を提供することです。

※この節のスパイダー例は、 myproject.items モジュールで宣言された TestItem を含むプロジェクトがあると仮定しています:

import scrapy

class TestItem(scrapy.Item):
    id = scrapy.Field()
    name = scrapy.Field()
    description = scrapy.Field()

CrawlSpider¶

class scrapy.spiders.CrawlSpider¶

これは、一連のルールを定義してリンクをたどる便利なメカニズムを提供するため、通常のWebサイトをクロールするために最も一般的に使用されるスパイダーです。特定のWebサイトやプロジェクトには最適ではないかもしれませんが、いくつかのケースでは十分に汎用的であるため、このスパイダーから始めて、必要に応じてカスタム機能をオーバーライドしたり、独自のスパイダーを実装したりできます。

Spiderから継承された(指定必須の)属性以外に、このclassは新しい属性をサポートします。:

rules¶: これは、1つ(または複数)の Rule オブジェクトのリストです。各 Rule サイトをクロールするための特定の動作を定義します。規則オブジェクトについては以下で説明します。複数の規則が同じリンクに一致する場合、この属性で定義されている順序に従って、一致する最初の規則が使用されます。

このスパイダーにはオーバーライド可能なメソッドもあります:

parse_start_url(response)¶: このメソッドは、start_urlsレスポンスに対して呼び出されます。最初のレスポンスを解析したら、Item オブジェクトまたは Request オブジェクトまたは、それらを含む反復可能オブジェクト(iterable)を返さなければなりません。

クロール規則¶

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

link_extractor は、クロールされた各ページからリンクを抽出する方法を定義するリンク抽出オブジェクトです。生成された各リンクは、 Request オブジェクトを生成するために使用されます。このオブジェクトでは、meta 辞書(link_text キー)にリンクのテキストを含みます。

callback は、指定のリンク抽出器で抽出された各リンクに対して呼び出される呼び出し可能オブジェクト(callable)または文字列(この場合、その名前のスパイダー・オブジェクトのメソッドが使用されます)です。このコールバックは Response を最初の引数として受け取り、単一のインスタンスまたは Item の反復可能オブジェクト(iterable)または辞書そして/または Request オブジェクト(またはそのサブクラス)、のいずれかを返す必要があります。上記のように、受け取った Response オブジェクトには、その meta 辞書に Request を生成したリンクのテキストを含みます(link_text キー)。

警告

CrawlSpider はロジックを実装するために parse メソッド自体を使用するため、クロール・スパイダー規則を記述するときは、コールバックとして parse を使用しないでください。つまり、あなたが parse メソッドをオーバーライドしちゃうと、クロール・スパイダーは機能しなくなります。

cb_kwargs は、コールバック関数に渡されるキーワード引数を含む辞書です。

follow は、このルールで抽出された各レスポンスからリンクをたどるかどうかを指定するブール値です。 callback がNoneの場合、 follow のデフォルトは True になります。それ以外の場合、デフォルトは False になります。

process_links は呼び出し可能オブジェクト(callable)、または指定された link_extractor を使用して各レスポンスから抽出されたリンクのリストごとに呼び出される文字列(この場合、その名前のスパイダー・オブジェクトのメソッドが使用されます)です。これは主にフィルタリングの目的で使用されます。

process_request は、この規則によって抽出されたすべての Request に対して呼び出される呼び出し可能オブジェクト(callable)(または文字列、その場合はその名前のスパイダー・オブジェクトのメソッドが使用されます)です。この呼び出し可能オブジェクト(callable)は、最初の引数としてリクエストを受け取り、2番目の引数としてリクエストの発信元である Response を受け取る必要があります。 Request オブジェクト、または None を返す必要があります(リクエストを除外するため)。

CrawlSpider例¶

では、規則を使用したCrawlSpiderの例を見てみましょう:

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

class MySpider(CrawlSpider):
    name = 'example.com'
    allowed_domains = ['example.com']
    start_urls = ['http://www.example.com']

    rules = (
        # Extract links matching 'category.php' (but not matching 'subsection.php')
        # and follow links from them (since no callback means follow=True by default).
        Rule(LinkExtractor(allow=('category\.php', ), deny=('subsection\.php', ))),

        # Extract links matching 'item.php' and parse them with the spider's method parse_item
        Rule(LinkExtractor(allow=('item\.php', )), callback='parse_item'),
    )

    def parse_item(self, response):
        self.logger.info('Hi, this is an item page! %s', response.url)
        item = scrapy.Item()
        item['id'] = response.xpath('//td[@id="item_id"]/text()').re(r'ID: (\d+)')
        item['name'] = response.xpath('//td[@id="item_name"]/text()').get()
        item['description'] = response.xpath('//td[@id="item_description"]/text()').get()
        item['link_text'] = response.meta['link_text']
        return item

このスパイダーはexample.comのホームページのクロールを開始し、カテゴリ・リンクとアイテム・リンクを収集し、後者を parse_item メソッドでパースします。各アイテムのレスポンスに対して、XPathを使用してHTMLからいくつかのデータを抽出し、 Item は抽出されたデータで満たされます。

XMLFeedSpider¶

class scrapy.spiders.XMLFeedSpider¶

XMLFeedSpiderは、特定のノード名でXMLフィードを反復処理することにより、XMLフィードをパースするために設計されています。イテレータは、「iternodes」、「xml」、および「html」から選択できます。 xml および html イテレータはパースするために一度DOM全体を生成します。そのため、パフォーマンス上の理由から iternodes イテレータを使用することをお勧めします。ただし、不正なマークアップを使用したXMLを解析する場合は、イテレータとして html を使用すると便利です。

イテレータとタグ名を設定するには、以下のクラス属性を定義する必要があります:

iterator¶

使用するイテレータを定義する文字列。以下のいずれかです:

'iternodes' - 正規表現に基づく高速イテレータ

'html' - Selector を使用するイテレータ。これはDOM解析を使用し、すべてのDOMをメモリにロードする必要があることに注意してください。これは大きなフィードの場合に問題になる可能性があります。

'xml' - Selector を使用するイテレータ。これはDOM解析を使用し、すべてのDOMをメモリにロードする必要があることに注意してください。これは大きなフィードの場合に問題になる可能性があります。

デフォルトは 'iternodes' です。

itertag¶

反復するノード(または要素)の名前を表す文字列。例:

itertag = 'product'

namespaces¶

このスパイダーで処理されるドキュメントで利用可能な名前空間を定義する (prefix, uri) タプルのリスト。 prefix と uri は、 register_namespace() メソッドを使用して名前空間を自動的に登録するために使用されます。

あなたは、それから、 itertag 属性に名前空間を持つノードを指定できます。

例:

class YourSpider(XMLFeedSpider):

    namespaces = [('n', 'http://www.sitemaps.org/schemas/sitemap/0.9')]
    itertag = 'n:url'
    # ...

これらの新しい属性とは別に、このスパイダーには以下のオーバーライド可能なメソッドもあります。:

adapt_response(response)¶: スパイダー・ミドルウェアから到着するとすぐに、スパイダーがパース開始する前に、レスポンスを受信するメソッド。パース前にレスポンス・ボディを変更するために使用できます。このメソッドはレスポンスを受け取り、レスポンスを返します(同じ、または別のレスポンスになる可能性があります)。

parse_node(response, selector)¶: このメソッドは、指定されたタグ名(itertag)に一致するノードに対して呼び出されます。各ノードのレスポンス Selector を受け取ります。このメソッドのオーバーライドは必須です。そうしないと、このスパイダーは動作しません。このメソッドは、 Item オブジェクトまたは、 Request オブジェクト、またはそれらのいずれかを含む反復可能オブジェクト(iterable)のいずれかを返す必要があります。

process_results(response, results)¶: このメソッドは、スパイダーによって返された各結果(アイテムまたはリクエスト)に対して呼び出され、結果をフレームワーク・コアに返す前に必要な最後の処理(アイテムIDの設定など)を実行することを目的としています。結果のリストと、それらの結果を生成したレスポンスを受け取ります。結果(アイテムまたはリクエスト)のリストを返す必要があります。

XMLFeedSpiderの例¶

これらのスパイダーは非常に使いやすいので、例を見てみましょう:

from scrapy.spiders import XMLFeedSpider
from myproject.items import TestItem

class MySpider(XMLFeedSpider):
    name = 'example.com'
    allowed_domains = ['example.com']
    start_urls = ['http://www.example.com/feed.xml']
    iterator = 'iternodes'  # This is actually unnecessary, since it's the default value
    itertag = 'item'

    def parse_node(self, response, node):
        self.logger.info('Hi, this is a <%s> node!: %s', self.itertag, ''.join(node.getall()))

        item = TestItem()
        item['id'] = node.xpath('@id').get()
        item['name'] = node.xpath('name').get()
        item['description'] = node.xpath('description').get()
        return item

私たちがここで行ったことは、基本的には、指定した start_urls からフィードをダウンロードし、それぞれの item タグを反復処理し、それらを出力し、いくつかのランダムなデータを Item に保存するスパイダーを作成することです。

CSVFeedSpider¶

class scrapy.spiders.CSVFeedSpider¶

このスパイダーはXMLFeedSpiderに非常に似ていますが、ノードではなく行を反復処理する点が異なります。各反復で呼び出されるメソッドは parse_row() です。

delimiter¶: CSVファイルの各フィールドを区切る文字(文字列)。デフォルトは ',' (カンマ)。

quotechar¶: CSVファイルの各フィールドを囲い込む文字(文字列)。デフォルトは '\"' (ダブルクォーテーション)。

headers¶: CSVファイルの列名のリスト。

parse_row(response, row)¶: CSVファイルの、レスポンスと、提供された(または検出された)ヘッダー行ごとにキーを持つ、(各行を表す)辞書を受け取ります。このスパイダーは、前処理および後処理のために adapt_response および process_results メソッドをオーバーライドする機会も与えます。

CSVFeedSpider例¶

いささか前の例に似ているけれども、 CSVFeedSpider を使用している例を見てみましょう:

from scrapy.spiders import CSVFeedSpider
from myproject.items import TestItem

class MySpider(CSVFeedSpider):
    name = 'example.com'
    allowed_domains = ['example.com']
    start_urls = ['http://www.example.com/feed.csv']
    delimiter = ';'
    quotechar = "'"
    headers = ['id', 'name', 'description']

    def parse_row(self, response, row):
        self.logger.info('Hi, this is a row!: %r', row)

        item = TestItem()
        item['id'] = row['id']
        item['name'] = row['name']
        item['description'] = row['description']
        return item

SitemapSpider¶

class scrapy.spiders.SitemapSpider¶

SitemapSpiderでは、 Sitemaps を使用してURLを検出することにより、サイトをクロールできます。

ネストされたサイトマップをサポートし、 robots.txt からサイトマップのURLを検出します。

sitemap_urls¶

あなたがクロールしたいサイトマップのURLを指定するURLのリスト。

また、あなたは robots.txt を指定することもできます。robots.txtは、サイトマップのURLをパースするために解析されます。

sitemap_rules¶

タプル (regex, callback) のリスト。その内訳は以下の通りです:

regex は、サイトマップから抽出するURLに一致する正規表現です。 regex は文字列またはコンパイル済みの正規表現オブジェクトのいずれかです。
callback は、正規表現に一致するURLの処理に使用するコールバックです。 callback は文字列(スパイダーメソッドの名前を示す)または呼び出し可能オブジェクト(callable)です。

例えば:

sitemap_rules = [('/product/', 'parse_product')]

順番に規則の適用を試み、一致する最初の規則のみが使用されます。

あなたがこの属性を省略すると、サイトマップで見つかったすべてのURLは parse コールバックで処理されます。

sitemap_follow¶

追跡すべきサイトマップの正規表現のリスト。これは、他のサイトマップファイルを指す Sitemap index files を使用するサイト専用です。

デフォルトでは、すべてのサイトマップが追跡されます。

sitemap_alternate_links¶

ある url の代替リンクをたどるかどうかを指定します。これらは、同じ url ブロック内で渡される別の言語の同じWebサイトへのリンクです。

例えば:

<url>
    <loc>http://example.com/</loc>
    <xhtml:link rel="alternate" hreflang="de" href="http://example.com/de"/>
</url>

sitemap_alternate_links を設定すると、両方のURLが取得されます。 sitemap_alternate_links を無効にすると、 http://example.com/ のみが取得されます。

デフォルトでは sitemap_alternate_links は無効です。

sitemap_filter(entries)¶

これは、属性に基づいてサイトマップ・エントリを選択するためにオーバーライドできるフィルター関数です。

例えば:

<url>
    <loc>http://example.com/</loc>
    <lastmod>2005-01-01</lastmod>
</url>

私たちは、日付で entries をフィルタリングする sitemap_filter 関数を定義できます:

from datetime import datetime
from scrapy.spiders import SitemapSpider

class FilteredSitemapSpider(SitemapSpider):
    name = 'filtered_sitemap_spider'
    allowed_domains = ['example.com']
    sitemap_urls = ['http://example.com/sitemap.xml']

    def sitemap_filter(self, entries):
        for entry in entries:
            date_time = datetime.strptime(entry['lastmod'], '%Y-%m-%d')
            if date_time.year >= 2005:
                yield entry

これにより、2005年以降に変更された entries のみが取得されます。

エントリは、サイトマップ・ドキュメントから抽出された辞書オブジェクトです。通常、キーはタグ名で、値はその中のテキストです。

重要な注意 :

loc属性が必要なため、このタグのないエントリは破棄されます。
代替リンクはキー alternate でリストに保存されます(sitemap_alternate_links 参照)
名前空間が削除されるため、 {namespace}tagname という名前のlxmlタグは tagname のみになります。

あなたがこのメソッドを省略すると、サイトマップで見つかったすべてのエントリが処理され、他の属性とその設定を参照します。

SitemapSpider例¶

最も単純な例: parse コールバックを使用して、サイトマップを通じて検出されたすべてのURLを処理します:

from scrapy.spiders import SitemapSpider

class MySpider(SitemapSpider):
    sitemap_urls = ['http://www.example.com/sitemap.xml']

    def parse(self, response):
        pass # ... scrape item here ...

特定のコールバックでいくつかのURLを処理し、別個のコールバックでその他のURLを処理します:

from scrapy.spiders import SitemapSpider

class MySpider(SitemapSpider):
    sitemap_urls = ['http://www.example.com/sitemap.xml']
    sitemap_rules = [
        ('/product/', 'parse_product'),
        ('/category/', 'parse_category'),
    ]

    def parse_product(self, response):
        pass # ... scrape product ...

    def parse_category(self, response):
        pass # ... scrape category ...

robots.txt ファイルで定義されたサイトマップに従い、URLに /sitemap_shop が含まれるサイトマップのみを追跡します:

from scrapy.spiders import SitemapSpider

class MySpider(SitemapSpider):
    sitemap_urls = ['http://www.example.com/robots.txt']
    sitemap_rules = [
        ('/shop/', 'parse_shop'),
    ]
    sitemap_follow = ['/sitemap_shops']

    def parse_shop(self, response):
        pass # ... scrape shop here ...

SitemapSpiderとurlsの他のソースを組み合わせます:

from scrapy.spiders import SitemapSpider

class MySpider(SitemapSpider):
    sitemap_urls = ['http://www.example.com/robots.txt']
    sitemap_rules = [
        ('/shop/', 'parse_shop'),
    ]

    other_urls = ['http://www.example.com/about']

    def start_requests(self):
        requests = list(super(MySpider, self).start_requests())
        requests += [scrapy.Request(x, self.parse_other) for x in self.other_urls]
        return requests

    def parse_shop(self, response):
        pass # ... scrape shop here ...

    def parse_other(self, response):
        pass # ... scrape other here ...