[Python] Webcrawler (12): Erste Schritte mit dem ersten Crawler-Beispiel des Crawler-Frameworks Scrapy

Wir nutzen die Website dmoz.org als Plattform für Xiaozhuazhua, um seine Fähigkeiten unter Beweis zu stellen.

Zuerst muss ich eine Frage beantworten.

F: Wie viele Schritte sind erforderlich, um eine Website in einem Crawler zu installieren?

Die Antwort ist sehr einfach, vier Schritte:

Neues Projekt (Projekt): Erstellen Sie ein neues Crawler-Projekt

Klare Ziele (Elemente): Klären Sie, was Sie crawlen möchten Ziel

Erstellen Sie einen Crawler (Spider): Erstellen Sie einen Crawler, um mit dem Crawlen von Webseiten zu beginnen

Inhalte speichern (Pipeline): Entwerfen Sie eine Pipeline zum Speichern gecrawlter Inhalte

Okay, jetzt, da der grundlegende Prozess festgelegt ist, schließen Sie ihn einfach Schritt für Schritt ab.

1. Erstellen Sie ein neues Projekt (Projekt)

Halten Sie die Umschalttaste gedrückt und klicken Sie mit der rechten Maustaste in das leere Verzeichnis, wählen Sie „Befehlsfenster hier öffnen“. " und geben Sie den folgenden Befehl ein:

scrapy startproject tutorial

wobei Tutorial der Projektname ist.

Sie können sehen, dass ein Tutorial-Ordner mit der folgenden Verzeichnisstruktur erstellt wird:

tutorial/  
    scrapy.cfg  
    tutorial/  
        __init__.py  
        items.py  
        pipelines.py  
        settings.py  
        spiders/  
            __init__.py  
            ...

Im Folgenden finden Sie eine kurze Einführung in die Rolle jeder Datei:

• scrapy.cfg: Die Konfigurationsdatei des Projekts
  

• Tutorial/: Das Python-Modul des Projekts, auf den Code wird von hier aus verwiesen

• tutorial/items.py: die Elementdatei des Projekts

• tutorial/pipelines.py: die Pipelines-Datei des Projekts

• Tutorial/settings.py: Projekteinstellungsdatei

• tutorial/spiders/: Verzeichnis zum Speichern von Crawlern

2. Ziel (Element) löschen

In Scrapy sind Elemente Container, die zum Laden von gecrawlten Inhalten verwendet werden, ähnlich wie Dic in Python, das ein Wörterbuch ist, aber zusätzlichen Schutz bietet, um Fehler zu reduzieren.

Im Allgemeinen können Elemente mit der Klasse scrapy.item.Item erstellt werden und Eigenschaften können mit dem Objekt scrapy.item.Field definiert werden (das als ORM-ähnliche Zuordnungsbeziehung verstanden werden kann).

Als nächstes beginnen wir mit dem Aufbau des Artikelmodells.

Zunächst einmal ist der Inhalt, den wir wollen:

• Name (Name)

• Link (URL)

• Beschreibung

Ändern Sie die Datei items.py im Tutorialverzeichnis und fügen Sie sie nach der ursprünglichen Klasse Our hinzu eigene Klasse.

Da wir den Inhalt der dmoz.org-Website erfassen möchten, können wir ihn DmozItem nennen:

# Define here the models for your scraped items  
#  
# See documentation in:  
# http://doc.scrapy.org/en/latest/topics/items.html  
  
from scrapy.item import Item, Field  
  
class TutorialItem(Item):  
    # define the fields for your item here like:  
    # name = Field()  
    pass  
  
class DmozItem(Item):  
    title = Field()  
    link = Field()  
    desc = Field()

Es mag zunächst etwas unklar erscheinen, aber die Definition dieser Elemente kann Let Sie wissen, was Ihre Artikel sind, wenn Sie andere Komponenten verwenden.

Item kann einfach als gekapseltes Klassenobjekt verstanden werden.

3. Einen Crawler erstellen (Spider)

Um einen Crawler zu erstellen, gibt es zwei Schritte: Zuerst kriechen und dann holen.

Das heißt, Sie müssen zuerst den gesamten Inhalt der gesamten Webseite abrufen und dann die Teile herausnehmen, die für Sie nützlich sind.

3.1 Crawling

Spider ist eine vom Benutzer geschriebene Klasse zum Crawlen von Informationen aus einer Domäne (oder Domänengruppe).

Sie definieren eine Liste von URLs zum Herunterladen, ein Schema zum Verfolgen von Links und eine Möglichkeit, Webinhalte zu analysieren, um Elemente zu extrahieren.

Um einen Spider zu erstellen, müssen Sie eine Unterklasse mit scrapy.spider.BaseSpider erstellen und drei obligatorische Attribute festlegen:

Name: Der Identifikationsname des Crawlers, der eindeutig sein muss. Sie müssen Definieren Sie unterschiedliche Namen in verschiedenen Crawlern.

start_urls: gecrawlte URL-Liste. Der Crawler beginnt hier mit dem Abrufen von Daten, sodass der erste Datendownload von diesen URLs aus startet. Andere Sub-URLs werden von diesen Start-URLs geerbt generiert.

parse(): Übergeben Sie beim Aufruf das von jeder URL zurückgegebene Antwortobjekt. Es ist für das Parsen und Abgleichen der erfassten Daten (in Elemente analysiert) und die Nachverfolgung verantwortlich URL.

Hier können Sie auf die im Breiten-Crawler-Tutorial erwähnten Ideen zurückgreifen, um das Verständnis zu erleichtern: [Java] Zhihu Chin Episode 5: Verwendung des HttpClient-Toolkits und des Breiten-Crawlers.

Das heißt, die URL wird gespeichert und basierend darauf als Ausgangspunkt schrittweise verbreitet, wobei alle Webseiten-URLs erfasst werden, die die Bedingungen erfüllen, und sie gespeichert werden, um mit dem Crawlen fortzufahren.

Schreiben wir den ersten Crawler mit dem Namen dmoz_spider.py und speichern ihn im Tutorialspiders-Verzeichnis.

Der dmoz_spider.py-Code lautet wie folgt:

from scrapy.spider import Spider  
  
class DmozSpider(Spider):  
    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)

allow_domains ist der zu durchsuchende Domainnamenbereich, der auch der Einschränkungsbereich des Crawlers ist. Er legt fest, dass der Crawler nur crawlt Webseiten unter diesem Domainnamen.

Wie aus der Parse-Funktion ersichtlich ist, werden die letzten beiden Adressen des Links herausgenommen und als Dateinamen gespeichert.

Dann führen Sie es aus und schauen Sie es sich an. Halten Sie die Umschalttaste gedrückt und klicken Sie mit der rechten Maustaste in das Tutorial-Verzeichnis. Öffnen Sie hier das Befehlsfenster und geben Sie Folgendes ein:

scrapy crawl dmoz

Das laufende Ergebnis ist wie in der Abbildung gezeigt:

Fehler gemeldet:

UnicodeDecodeError: 'ascii' codec can't decode byte 0xb0 in position 1: ordinal not in range (128)

Ich erhalte eine Fehlermeldung, wenn ich das erste Scrapy-Projekt ausführe, was wirklich bedauerlich ist.

Es sollte ein Codierungsproblem vorliegen, nachdem ich bei Google gesucht habe:

Erstellen Sie eine neue sitecustomize.py im Ordner Libsite-packages python :

import sys    
sys.setdefaultencoding('gb2312')

Führen Sie es erneut aus, OK, das Problem ist gelöst, schauen Sie sich das Ergebnis an:

最后一句INFO: Closing spider (finished)表明爬虫已经成功运行并且自行关闭了。

包含 [dmoz]的行 ，那对应着我们的爬虫运行的结果。

可以看到start_urls中定义的每个URL都有日志行。

还记得我们的start_urls吗？

http://www.dmoz.org/Computers/Programming/Languages/Python/Books
http://www.dmoz.org/Computers/Programming/Languages/Python/Resources

因为这些URL是起始页面，所以他们没有引用(referrers)，所以在它们的每行末尾你会看到 (referer: )。

在parse 方法的作用下，两个文件被创建：分别是 Books 和 Resources，这两个文件中有URL的页面内容。

那么在刚刚的电闪雷鸣之中到底发生了什么呢？

首先，Scrapy为爬虫的 start_urls属性中的每个URL创建了一个 scrapy.http.Request 对象 ，并将爬虫的parse 方法指定为回调函数。

然后，这些 Request被调度并执行，之后通过parse()方法返回scrapy.http.Response对象，并反馈给爬虫。

3.2取

爬取整个网页完毕，接下来的就是的取过程了。

光存储一整个网页还是不够用的。

在基础的爬虫里，这一步可以用正则表达式来抓。

在Scrapy里，使用一种叫做 XPath selectors的机制，它基于 XPath表达式。

如果你想了解更多selectors和其他机制你可以查阅资料：点我点我

这是一些XPath表达式的例子和他们的含义

/html/head/title: 选择HTML文档

元素下面的'] In [3]: sel.xpath('//title/text()') Out[3]: [] In [4]: sel.xpath('//title/text()').extract() Out[4]: [u'Open Directory - Computers: Programming: Languages: Python: Books'] In [5]: sel.xpath('//title/text()').re('(\w+):') Out[5]: [u'Computers', u'Programming', u'Languages', u'Python']

当然title这个标签对我们来说没有太多的价值，下面我们就来真正抓取一些有意义的东西。

使用火狐的审查元素我们可以清楚地看到，我们需要的东西如下：

我们可以用如下代码来抓取这个

标签：

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

从

标签中，可以这样获取网站的描述：

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

可以这样获取网站的标题：

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

可以这样获取网站的超链接：

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

当然，前面的这些例子是直接获取属性的方法。

我们注意到xpath返回了一个对象列表，

那么我们也可以直接调用这个列表中对象的属性挖掘更深的节点

（参考：Nesting selectors andWorking with relative XPaths in theSelectors）：

sites = sel.xpath('//ul/li')for site in sites:
   title = site.xpath('a/text()').extract()
   link = site.xpath('a/@href').extract()
   desc = site.xpath('text()').extract()
   print title, link, desc

3.4xpath实战

我们用shell做了这么久的实战，最后我们可以把前面学习到的内容应用到dmoz_spider这个爬虫中。

在原爬虫的parse函数中做如下修改：

from scrapy.spider import Spider  
from scrapy.selector import Selector  
  
class DmozSpider(Spider):  
    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):  
        sel = Selector(response)  
        sites = sel.xpath('//ul/li')  
        for site in sites:  
            title = site.xpath('a/text()').extract()  
            link = site.xpath('a/@href').extract()  
            desc = site.xpath('text()').extract()  
            print title

注意，我们从scrapy.selector中导入了Selector类，并且实例化了一个新的Selector对象。这样我们就可以像Shell中一样操作xpath了。

我们来试着输入一下命令运行爬虫（在tutorial根目录里面）：

scrapy crawl dmoz

运行结果如下：

果然，成功的抓到了所有的标题。但是好像不太对啊，怎么Top，Python这种导航栏也抓取出来了呢？

我们只需要红圈中的内容：

看来是我们的xpath语句有点问题，没有仅仅把我们需要的项目名称抓取出来，也抓了一些无辜的但是xpath语法相同的元素。

审查元素我们发现我们需要的

具有class='directory-url'的属性，

那么只要把xpath语句改成sel.xpath('//ul[@class="directory-url"]/li')即可


将xpath语句做如下调整：

from scrapy.spider import Spider  
from scrapy.selector import Selector  
  
class DmozSpider(Spider):  
    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):  
        sel = Selector(response)  
        sites = sel.xpath('//ul[@class="directory-url"]/li')  
        for site in sites:  
            title = site.xpath('a/text()').extract()  
            link = site.xpath('a/@href').extract()  
            desc = site.xpath('text()').extract()  
            print title

成功抓出了所有的标题，绝对没有滥杀无辜：



3.5使用Item


接下来我们来看一看如何使用Item。

前面我们说过，Item 对象是自定义的python字典，可以使用标准字典语法获取某个属性的值：

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

作为一只爬虫，Spiders希望能将其抓取的数据存放到Item对象中。为了返回我们抓取数据，spider的最终代码应当是这样:

from scrapy.spider import Spider  
from scrapy.selector import Selector  
  
from tutorial.items import DmozItem  
  
class DmozSpider(Spider):  
    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):  
        sel = Selector(response)  
        sites = sel.xpath('//ul[@class="directory-url"]/li')  
        items = []  
        for site in sites:  
            item = DmozItem()  
            item['title'] = site.xpath('a/text()').extract()  
            item['link'] = site.xpath('a/@href').extract()  
            item['desc'] = site.xpath('text()').extract()  
            items.append(item)  
        return items

4.存储内容（Pipeline）

保存信息的最简单的方法是通过Feed exports，主要有四种：JSON，JSON lines，CSV，XML。

我们将结果用最常用的JSON导出，命令如下：

scrapy crawl dmoz -o items.json -t json

-o 后面是导出文件名，-t 后面是导出类型。

然后来看一下导出的结果，用文本编辑器打开json文件即可（为了方便显示，在item中删去了除了title之外的属性）：



Da es sich nur um ein kleines Beispiel handelt, reicht eine einfache Verarbeitung aus.

Wenn Sie mit den erfassten Artikeln komplexere Dinge tun möchten, können Sie eine Artikelpipeline schreiben.

Wir werden in Zukunft langsam damit spielen^_^

Das Obige ist der Inhalt von [Python] Web Crawler (12): Das erste Crawler-Beispiel-Einführungs-Tutorial des Crawler-Frameworks Scrapy, Weitere Informationen Bitte beachten Sie den Inhalt der chinesischen PHP-Website (www.php.cn)!