Webcrawler ist ein Programm, das Daten im Internet crawlt. Es kann zum Crawlen der HTML-Daten bestimmter Webseiten verwendet werden. Obwohl wir einige Bibliotheken verwenden, um ein Crawler-Programm zu entwickeln, kann die Verwendung eines Frameworks die Effizienz erheblich verbessern und die Entwicklungszeit verkürzen. Scrapy ist in Python geschrieben, leichtgewichtig, einfach und benutzerfreundlich. Die Verwendung von Scrapy kann die Sammlung von Online-Daten problemlos vervollständigen. Es hat uns viel Arbeit abgenommen, ohne dass wir große Anstrengungen unternehmen müssen, um es selbst zu entwickeln.
Zuerst müssen wir eine Frage beantworten.
F: Wie viele Schritte sind erforderlich, um eine Website in einem Crawler zu installieren?
Die Antwort ist einfach, vier Schritte:
Erstellen Sie ein neues Projekt (Projekt): Erstellen Sie ein neues Crawler-Projekt
Klare Ziele (Elemente): Klären Sie die Ziele, die Sie crawlen möchten
Erstellen Sie eine Spinne ( Spider) : Erstellen Sie einen Crawler und beginnen Sie mit dem Crawlen der Webseite
Speicherinhalt (Pipeline): Entwerfen Sie eine Pipeline zum Speichern des gecrawlten Inhalts
Okay, jetzt, da der grundlegende Prozess festgelegt ist, schließen Sie diesen Schritt einfach ab Schritt für Schritt.
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 Befehl ein:
scrapy startproject tutorial
Unter anderem ist Tutorial der Projektname.
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: Projektkonfiguration Datei
tutorial/: Das Python-Modul des Projekts, der Code wird von hier aus referenziert
tutorial/items.py: die Items-Datei des Projekts
tutorial/pipelines.py: die Pipelines-Datei des Projekt
tutorial/settings.py: Projekteinstellungsdatei
tutorial/spiders/: Verzeichnis zum Speichern von Crawlern
2. Ziele löschen (Element)
In Scrapy sind Elemente Container, die zum Laden verwendet werden Gecrawlter Inhalt, ein bisschen wie Python Dic in DIC, ist ebenfalls ein Wörterbuch, bietet aber zusätzlichen Schutz, 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.
Zuallererst wollen wir:
Name (Name)
Link (URL)
Beschreibung (Beschreibung)
Ändern Sie die Datei items.py im Tutorial-Verzeichnis. in Fügen Sie unsere eigene Klasse nach der ursprünglichen Klasse hinzu.
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 verwirrend erscheinen, aber die Definition dieser Elemente ermöglicht Ihnen die Verwendung von When Wenn Sie andere Komponenten verwenden, wissen Sie, um welche Artikel es sich handelt.
Item kann einfach als gekapseltes Klassenobjekt verstanden werden.
3. Eine Spinne herstellen
Um eine Spinne herzustellen, 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 unter verschiedenen Crawlern eindeutig sein muss. Ein anderer Name muss sein definiert.
start_urls: Liste der gecrawlten URLs. 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 als einzigen Parameter. Sie ist für das Parsen und Abgleichen der erfassten Daten (Parsing in Elemente) und die Verfolgung weiterer URLs verantwortlich.
Hier können Sie auf die im Breiten-Crawler-Tutorial erwähnten Ideen zurückgreifen, um die Bereitstellung des Tutorials zu erleichtern: [Java] Zhihu Chin Episode 5: Verwendung des HttpClient-Toolkits und des Breiten-Crawlers.
Das heißt, die URL wird gespeichert und basierend auf diesem Ausgangspunkt schrittweise verbreitet, und alle Webseiten-URLs, die die Bedingungen erfüllen, werden erfasst und gespeichert und weiter gecrawlt.
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 Webseiten crawlt diesen 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 ausgeführte Ergebnis ist wie in der Abbildung dargestellt:
Es wurde ein Fehler gemeldet:
UnicodeDecodeError: 'ascii' codec can't decode byte 0xb0 in position 1: ordinal not in range(128)
An Beim Ausführen des ersten Scrapy-Projekts wurde ein Fehler gemeldet. Schade.
Es sollte ein Codierungsproblem vorliegen und die Lösung gefunden:
Erstellen Sie eine neue sitecustomize.py im Libsite-Packages-Ordner von Python:
import sys sys.setdefaultencoding('gb2312')
Erneut ausführen, OK Das Problem ist gelöst. Schauen Sie sich die Ergebnisse 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文档
当然title这个标签对我们来说没有太多的价值，下面我们就来真正抓取一些有意义的东西。
使用火狐的审查元素我们可以清楚地看到，我们需要的东西如下：
我们可以用如下代码来抓取这个
sel.xpath('//ul/li')
从
sel.xpath('//ul/li/text()').extract()
可以这样获取网站的标题：
sel.xpath('//ul/li/a/text()').extract()
从
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 the Selectors）：
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语法相同的元素。
审查元素我们发现我们需要的
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 items4.存储内容（Pipeline）
保存信息的最简单的方法是通过Feed exports，主要有四种：JSON，JSON lines，CSV，XML。
我们将结果用最常用的JSON导出，命令如下：
scrapy crawl dmoz -o items.json -t json
-o 后面是导出文件名，-t 后面是导出类型。
然后来看一下导出的结果，用文本编辑器打开json文件即可（为了方便显示，在item中删去了除了title之外的属性）：
因为这个只是一个小型的例子，所以这样简单的处理就可以了。
如果你想用抓取的items做更复杂的事情，你可以写一个 Item Pipeline(条目管道)。
这个我们以后再慢慢玩^_^
以上便是python爬虫框架Scrapy制作爬虫抓取网站内容的全部过程了，非常的详尽吧，希望能够对大家有所帮助，有需要的话也可以和我联系，一起进步
Python-Crawler-Methode zum Abrufen von Daten
Darstellungsmethode der String-Konstante
So betreten Sie die 404-Website
Der Unterschied zwischen der bidirektionalen Bindung von vue2 und vue3
Ist das Hongmeng-System einfach zu bedienen?
Die Webseite kann nicht geöffnet werden
Soundkartentreiber für HP Notebooks
MySQL erstellt eine gespeicherte Prozedur
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
