Detaillierte Erläuterung von Scrapy-Beispielen des Python-Crawler-Frameworks

Projekt generieren

Scrapy bietet ein Tool zum Generieren eines Projekts. Einige Dateien sind im generierten Projekt voreingestellt, und Benutzer müssen diesen Dateien ihren eigenen Code hinzufügen.

Öffnen Sie die Befehlszeile und führen Sie Folgendes aus: scrapy startproject Tutorial Das generierte Projekt hat eine ähnliche Struktur wie das folgende

tutorial/

scrapy.cfg

Tutorial/

__init__.py

items.py

Pipelines.py

Settings.py

Spiders/

__init__. py

              mehrere URLs einschließen

Die Parse-Methode dient dazu, dass Spinnen eine abrufen. Der Rückruf wird in Zukunft standardmäßig auf der Webseite aufgerufen. Vermeiden Sie die Verwendung dieses Namens, um Ihre eigenen Methoden zu definieren.

Wenn der Spider den Inhalt der URL erhält, ruft er die Parse-Methode auf und übergibt ihr einen Antwortparameter. Die Antwort enthält den Inhalt der erfassten Webseite. In der Parse-Methode können Sie den Inhalt abrufen der Webseite aus der erfassten Webseite. Die Daten werden darin analysiert. Der obige Code speichert einfach den Webseiteninhalt in einer Datei.

from scrapy.spider import BaseSpider
class DmozSpider(BaseSpider):
    name = "dmoz"
    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]
        open(filename, 'wb').write(response.body)

Crawling starten

Sie können die Befehlszeile öffnen, das generierte Projektstammverzeichnis „tutorial/“ eingeben und Scrapy Crawl Dmoz ausführen, dmoz ist der Name von die Spinne.

Webinhalte analysieren

Scrapy bietet eine bequeme Möglichkeit, Daten von Webseiten zu analysieren, was die Verwendung von HtmlXPathSelector erfordert

HtmlXPathSelector verwendet Xpath zum Parsen von Daten

//ul/li bedeutet die Auswahl des li-Tags unter allen ul-Tags

a/@href bedeutet die Auswahl des href-Attributs aller a-Tags

a/text() bedeutet die Auswahl eines Tag-Textes

from scrapy.spider import BaseSpider
from scrapy.selector import HtmlXPathSelector
class DmozSpider(BaseSpider):
    name = "dmoz"
    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):
        hxs = HtmlXPathSelector(response)
        sites = hxs.select('//ul/li')
        for site in sites:
            title = site.select('a/text()').extract()
            link = site.select('a/@href').extract()
            desc = site.select('text()').extract()
            print title, link, desc

a[@href="abc"] bedeutet die Auswahl aller Tags, deren href-Attribut abc ist

Wir können die Daten analysieren und speichern in einem Objekt, das Scrapy verwenden kann, und dann kann Scrapy uns helfen, diese Objekte zu speichern, ohne die Daten selbst in einer Datei speichern zu müssen. Wir müssen einige Klassen zu items.py hinzufügen, die verwendet werden, um die Daten zu beschreiben, die wir speichern möchten.

Beim Ausführen von Scrapy in der Befehlszeile können wir zwei Parameter hinzufügen, damit Scrapy die Analyse verwenden kann Methode Die zurückgegebenen Elemente werden in eine JSON-Datei ausgegeben

scrapy crawl dmoz -o items.json -t json

items.json wird im Stammverzeichnis des Projekts abgelegt

from scrapy.item import Item, Field
class DmozItem(Item):
   title = Field()
   link = Field()
   desc = Field()
然后在spider的parse方法中，我们把解析出来的数据保存在DomzItem对象中。
from scrapy.spider import BaseSpider
from scrapy.selector import HtmlXPathSelector
from tutorial.items import DmozItem
class DmozSpider(BaseSpider):
   name = "dmoz"
   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):
       hxs = HtmlXPathSelector(response)
       sites = hxs.select('//ul/li')
       items = []
       for site in sites:
           item = DmozItem()
           item['title'] = site.select('a/text()').extract()
           item['link'] = site.select('a/@href').extract()
           item['desc'] = site.select('text()').extract()
           items.append(item)
       return items

Lassen Sie Scrapy automatisch alle Links auf der Webseite crawlen

Im obigen Beispiel crawlt Scrapy nur den Inhalt der beiden URLs in start_urls, normalerweise aber das, was wir erreichen wollen ist automatisch scrapy. Entdecken Sie alle Links auf einer Webseite und crawlen Sie dann den Inhalt dieser Links. Um dies zu erreichen, können wir die benötigten Links in der Parse-Methode extrahieren, dann einige Request-Objekte erstellen und sie zurückgeben. Scrapy crawlt diese Links automatisch. Der Code ist ähnlich:

parse ist der Standardrückruf, der eine Anforderungsliste zurückgibt. Immer wenn eine Webseite erfasst wird, wird parse_item aufgerufen wird auch Gibt eine Liste zurück, Scrapy crawlt die Webseite basierend auf dieser Liste und ruft nach dem Abrufen parse_details

auf. Um diese Art von Arbeit zu erleichtern, stellt Scrapy eine weitere Spider-Basisklasse bereit, die wir verwenden können Um es bequem zu implementieren, müssen wir CrawlSpider verwenden. Im Vergleich zu BaseSpider verfügt die neue Klasse über ein zusätzliches Regelattribut, das jeweils mehrere Regeln enthalten kann Die Regel beschreibt, welche Links gecrawlt werden müssen und welche nicht. Dies ist die Dokumentation für die Regelklasse http://doc.scrapy.org/en/latest/topics/spiders.html#scrapy.contrib.spiders.Rule

Diese Regeln können Rückrufe haben oder nicht Wenn kein Rückruf erfolgt, folgt Scrapy einfach allen diesen Links.

Verwendung von Pipelines.py

class MySpider(BaseSpider):
    name = 'myspider'
    start_urls = (
        'http://example.com/page1',
        'http://example.com/page2',
        )
    def parse(self, response):
        # collect `item_urls`
        for item_url in item_urls:
            yield Request(url=item_url, callback=self.parse_item)
    def parse_item(self, response):
        item = MyItem()
        # populate `item` fields
        yield Request(url=item_details_url, meta={'item': item},
            callback=self.parse_details)
    def parse_details(self, response):
        item = response.meta['item']
        # populate more `item` fields
        return item

In Pipelines.py können wir einige Klassen hinzufügen, um die Elemente herauszufiltern, die wir nicht möchten. Das Element wird in der Datenbank gespeichert.

Wenn das Element die Anforderungen nicht erfüllt, wird eine Ausnahme ausgelöst und das Element wird nicht in die JSON-Datei ausgegeben.

from scrapy.contrib.linkextractors.sgml import SgmlLinkExtractor
class MininovaSpider(CrawlSpider):
    name = 'mininova.org'
    allowed_domains = ['mininova.org']
    start_urls = ['http://www.mininova.org/today']
    rules = [Rule(SgmlLinkExtractor(allow=['/tor/\d+'])),
             Rule(SgmlLinkExtractor(allow=['/abc/\d+']), 'parse_torrent')]
    def parse_torrent(self, response):
        x = HtmlXPathSelector(response)
        torrent = TorrentItem()
        torrent['url'] = response.url
        torrent['name'] = x.select("//h1/text()").extract()
        torrent['description'] = x.select("//div[@id='description']").extract()
        torrent['size'] = x.select("//div[@id='info-left']/p[2]/text()[2]").extract()
        return torrent

Um Pipelines zu verwenden, müssen wir auch Settings.py ändern

Eine Zeile hinzufügen

ITEM_PIPELINES = ['dirbot.pipelines.FilterWordsPipeline']

Führen Sie jetzt Scrapy Crawl dmoz -o items.json -t json aus. Elemente, die die Anforderungen nicht erfüllen, werden herausgefiltert

from scrapy.exceptions import DropItem
class FilterWordsPipeline(object):
    """A pipeline for filtering out items which contain certain words in their
    description"""
    # put all words in lowercase
    words_to_filter = ['politics', 'religion']
    def process_item(self, item, spider):
        for word in self.words_to_filter:
            if word in unicode(item['description']).lower():
                raise DropItem("Contains forbidden word: %s" % word)
        else:
            return item