Scrapy - Kurzanleitung
Scrapy ist ein schnelles, in Python geschriebenes Open-Source-Webcrawling-Framework, mit dem die Daten mithilfe von auf XPath basierenden Selektoren von der Webseite extrahiert werden.
Scrapy wurde erstmals am 26. Juni 2008 unter BSD-Lizenz veröffentlicht. Ein Meilenstein 1.0 wurde im Juni 2015 veröffentlicht.
Warum Scrapy verwenden?
Es ist einfacher, große Crawling-Projekte zu erstellen und zu skalieren.
Es verfügt über einen integrierten Mechanismus namens Selectors zum Extrahieren der Daten von Websites.
Es verarbeitet die Anforderungen asynchron und ist schnell.
Die Kriechgeschwindigkeit wird mithilfe des automatischen Drosselungsmechanismus automatisch angepasst .
Gewährleistet die Zugänglichkeit für Entwickler.
Eigenschaften von Scrapy
Scrapy ist Open Source und kann kostenlos als Web-Crawler-Framework verwendet werden.
Scrapy generiert Feed-Exporte in Formaten wie JSON, CSV und XML.
Scrapy bietet eine integrierte Unterstützung für die Auswahl und Extraktion von Daten aus Quellen mithilfe von XPath- oder CSS-Ausdrücken.
Scrapy basiert auf Crawler und ermöglicht das automatische Extrahieren von Daten von den Webseiten.
Vorteile
Scrapy ist leicht erweiterbar, schnell und leistungsstark.
Es ist ein plattformübergreifendes Anwendungsframework (Windows, Linux, Mac OS und BSD).
Scrapy-Anforderungen werden asynchron geplant und verarbeitet.
Scrapy wird mit einem integrierten Service namens geliefert Scrapyd Hiermit können Sie Projekte hochladen und Spider mithilfe des JSON-Webdienstes steuern.
Es ist möglich, jede Website zu verschrotten, obwohl diese Website keine API für den Zugriff auf Rohdaten hat.
Nachteile
Scrapy ist nur für Python 2.7. +
Die Installation ist für verschiedene Betriebssysteme unterschiedlich.
In diesem Kapitel wird erläutert, wie Sie Scrapy installieren und einrichten. Scrapy muss mit Python installiert werden.
Scrapy kann mithilfe von installiert werden pip. Führen Sie zur Installation den folgenden Befehl aus:
pip install Scrapy
Windows
Note - Python 3 wird unter Windows nicht unterstützt.
Step 1- Installieren Sie Python 2.7 von Python
Legen Sie Umgebungsvariablen fest, indem Sie dem PATH die folgenden Pfade hinzufügen:
C:\Python27\;C:\Python27\Scripts\;
Sie können die Python-Version mit dem folgenden Befehl überprüfen:
python --version
Step 2- Installieren Sie OpenSSL .
Fügen Sie C: \ OpenSSL-Win32 \ bin zu Ihren Umgebungsvariablen hinzu.
Note - OpenSSL ist auf allen Betriebssystemen außer Windows vorinstalliert.
Step 3- Installieren Sie Visual C ++ 2008 Redistributables.
Step 4- Installieren Sie pywin32 .
Step 5- Installieren Sie pip für Python-Versionen älter als 2.7.9.
Sie können die Pip-Version mit dem folgenden Befehl überprüfen:
pip --version
Step 6 - Um Scrapy zu installieren, führen Sie den folgenden Befehl aus:
pip install Scrapy
Anakonda
Wenn Sie Anaconda oder Miniconda auf Ihrem Computer installiert haben, führen Sie den folgenden Befehl aus, um Scrapy mit conda - zu installieren.
conda install -c scrapinghub scrapy
Die Firma Scrapinghub unterstützt offizielle Conda-Pakete für Linux, Windows und OS X.
Note - Es wird empfohlen, Scrapy mit dem obigen Befehl zu installieren, wenn Probleme bei der Installation über pip auftreten.
Ubuntu 9.10 oder höher
Die neueste Version von Python ist unter Ubuntu OS vorinstalliert. Verwenden Sie die von Scrapinghub bereitgestellten Ubuntu-Pakete aptgettable. So verwenden Sie die Pakete -
Step 1 - Sie müssen den GPG-Schlüssel importieren, mit dem Scrapy-Pakete in den APT-Schlüsselring signiert werden. -
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 627220E7
Step 2 - Verwenden Sie als Nächstes den folgenden Befehl, um die Datei /etc/apt/sources.list.d/scrapy.list zu erstellen. -
echo 'deb http://archive.scrapy.org/ubuntu scrapy main' | sudo tee
/etc/apt/sources.list.d/scrapy.list
Step 3 - Paketliste aktualisieren und Scrapy installieren -
sudo apt-get update && sudo apt-get install scrapy
Archlinux
Sie können Scrapy aus dem AUR Scrapy-Paket mit dem folgenden Befehl installieren:
yaourt -S scrapy
Mac OS X
Verwenden Sie den folgenden Befehl, um die Xcode-Befehlszeilentools zu installieren:
xcode-select --install
Installieren Sie anstelle von System Python eine neue aktualisierte Version, die nicht mit dem Rest Ihres Systems in Konflikt steht.
Step 1- Installieren Sie Homebrew .
Step 2 - Setzen Sie die Umgebungsvariable PATH, um anzugeben, dass Homebrew-Pakete vor Systempaketen verwendet werden sollen. -
echo "export PATH = /usr/local/bin:/usr/local/sbin:$PATH" >> ~/.bashrc
Step 3 - Um sicherzustellen, dass die Änderungen vorgenommen wurden, laden Sie neu .bashrc mit dem folgenden Befehl -
source ~/.bashrc
Step 4 - Installieren Sie als Nächstes Python mit dem folgenden Befehl: -
brew install python
Step 5 - Installieren Sie Scrapy mit dem folgenden Befehl:
pip install Scrapy
Beschreibung
Das Scrapy-Befehlszeilentool wird zur Steuerung von Scrapy verwendet, das häufig als bezeichnet wird 'Scrapy tool'. Es enthält die Befehle für verschiedene Objekte mit einer Gruppe von Argumenten und Optionen.
Konfigurationseinstellungen
Scrapy finden Konfigurationseinstellungen in der scrapy.cfgDatei. Es folgen einige Standorte -
C: \ Scrapy (Projektordner) \ Scrapy.cfg im System
~ / .config / Scrapy.cfg ($ XDG_CONFIG_HOME) und ~ / .scrapy.cfg ($ HOME) für globale Einstellungen
Sie finden die Dateirapy.cfg im Stammverzeichnis des Projekts.
Scrapy kann auch mithilfe der folgenden Umgebungsvariablen konfiguriert werden:
- SCRAPY_SETTINGS_MODULE
- SCRAPY_PROJECT
- SCRAPY_PYTHON_SHELL
Scrapy-Projekt mit Standardstruktur
Die folgende Struktur zeigt die Standarddateistruktur des Scrapy-Projekts.
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
. . .
Das scrapy.cfgDatei ist ein Projektstammverzeichnis, das den Projektnamen mit den Projekteinstellungen enthält. Zum Beispiel -
[settings]
default = [name of the project].settings
[deploy]
#url = http://localhost:6800/
project = [name of the project]
Scrapy Tool verwenden
Das Scrapy-Tool bietet einige Verwendungsmöglichkeiten und verfügbare Befehle wie folgt:
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
Ein Projekt erstellen
Mit dem folgenden Befehl können Sie das Projekt in Scrapy erstellen:
scrapy startproject project_name
Dadurch wird das aufgerufene Projekt erstellt project_nameVerzeichnis. Wechseln Sie als Nächstes mit dem folgenden Befehl zum neu erstellten Projekt:
cd project_name
Projekte steuern
Sie können das Projekt steuern und mit dem Scrapy-Tool verwalten sowie die neue Spinne mit dem folgenden Befehl erstellen:
scrapy genspider mydomain mydomain.com
Die Befehle wie crawlen usw. müssen im Scrapy-Projekt verwendet werden. Im nächsten Abschnitt erfahren Sie, welche Befehle im Scrapy-Projekt ausgeführt werden müssen.
Scrapy enthält einige integrierte Befehle, die für Ihr Projekt verwendet werden können. Verwenden Sie den folgenden Befehl, um die Liste der verfügbaren Befehle anzuzeigen:
scrapy -h
Wenn Sie den folgenden Befehl ausführen, zeigt Scrapy die Liste der verfügbaren Befehle wie folgt an:
fetch - Die URL wird mit dem Scrapy-Downloader abgerufen.
runspider - Es wird verwendet, um eine in sich geschlossene Spinne auszuführen, ohne ein Projekt zu erstellen.
settings - Gibt den Projekteinstellungswert an.
shell - Es ist ein interaktives Scraping-Modul für die angegebene URL.
startproject - Es wird ein neues Scrapy-Projekt erstellt.
version - Es zeigt die Scrapy-Version an.
view - Es ruft die URL mit dem Scrapy-Downloader ab und zeigt den Inhalt in einem Browser an.
Sie können einige projektbezogene Befehle wie folgt haben -
crawl - Es wird verwendet, um Daten mit der Spinne zu crawlen.
check - Es überprüft die vom Crawler-Befehl zurückgegebenen Elemente.
list - Es zeigt die Liste der verfügbaren Spinnen an, die im Projekt vorhanden sind.
edit - Sie können die Spinnen mit dem Editor bearbeiten.
parse - Es analysiert die angegebene URL mit der Spinne.
bench - Es wird verwendet, um einen schnellen Benchmark-Test durchzuführen (Benchmark gibt an, wie viele Seiten von Scrapy pro Minute gecrawlt werden können).
Benutzerdefinierte Projektbefehle
Sie können mit einen benutzerdefinierten Projektbefehl erstellen COMMANDS_MODULEEinstellung im Scrapy-Projekt. Die Einstellung enthält eine leere Standardzeichenfolge. Sie können den folgenden benutzerdefinierten Befehl hinzufügen:
COMMANDS_MODULE = 'mycmd.commands'
Scrapy-Befehle können mithilfe des Scrapy.commands-Abschnitts in der Datei setup.py wie folgt hinzugefügt werden:
from setuptools import setup, find_packages
setup(name = 'scrapy-module_demo',
entry_points = {
'scrapy.commands': [
'cmd_demo = my_module.commands:CmdDemo',
],
},
)
Der obige Code fügt hinzu cmd_demo Befehl in der setup.py Datei.
Beschreibung
Spider ist eine Klasse, die dafür verantwortlich ist, wie die Links über eine Website verfolgt und die Informationen von den Seiten extrahiert werden.
Die Standardspinnen von Scrapy sind wie folgt:
Scrapy.Spider
Es ist eine Spinne, von der jede andere Spinne erben muss. Es hat die folgende Klasse -
class scrapy.spiders.Spider
Die folgende Tabelle zeigt die Felder der Scrapy.Spider-Klasse -
Sr.Nr. | Feld Beschreibung |
---|---|
1 | name Es ist der Name Ihrer Spinne. |
2 | allowed_domains Es ist eine Liste von Domänen, auf denen die Spinne kriecht. |
3 | start_urls Es handelt sich um eine Liste von URLs, die die Wurzeln für spätere Crawls bilden, von denen aus die Spinne zu crawlen beginnt. |
4 | custom_settings Dies sind die Einstellungen, die beim Ausführen der Spinne aus der projektweiten Konfiguration überschrieben werden. |
5 | crawler Es ist ein Attribut, das mit dem Crawler-Objekt verknüpft ist, an das die Spider-Instanz gebunden ist. |
6 | settings Dies sind die Einstellungen zum Ausführen einer Spinne. |
7 | logger Es ist ein Python-Logger, der zum Senden von Protokollnachrichten verwendet wird. |
8 | from_crawler(crawler,*args,**kwargs) Es ist eine Klassenmethode, die Ihre Spinne erzeugt. Die Parameter sind -
|
9 | start_requests() Wenn keine bestimmten URLs angegeben sind und die Spinne zum Verschrotten geöffnet ist, ruft Scrapy die Methode start_requests () auf . |
10 | make_requests_from_url(url) Es ist eine Methode zum Konvertieren von URLs in Anforderungen. |
11 | parse(response) Diese Methode verarbeitet die Antwort und gibt verschrottete Daten nach weiteren URLs zurück. |
12 | log(message[,level,component]) Es ist eine Methode, die eine Protokollnachricht über den Spider Logger sendet. |
13 | closed(reason) Diese Methode wird aufgerufen, wenn sich die Spinne schließt. |
Spinnenargumente
Spider-Argumente werden zum Angeben von Start-URLs verwendet und mit dem Befehl crawl with übergeben -a Option, wie folgt dargestellt -
scrapy crawl first_scrapy -a group = accessories
Der folgende Code zeigt, wie eine Spinne Argumente empfängt -
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]
Generische Spinnen
Sie können generische Spinnen verwenden, um Ihre Spinnen von zu klassifizieren. Ihr Ziel ist es, allen Links auf der Website zu folgen, basierend auf bestimmten Regeln, um Daten von allen Seiten zu extrahieren.
Nehmen wir für die Beispiele in den folgenden Spinnen an, wir haben ein Projekt mit den folgenden Feldern:
import scrapy
from scrapy.item import Item, Field
class First_scrapyItem(scrapy.Item):
product_title = Field()
product_link = Field()
product_description = Field()
CrawlSpider
CrawlSpider definiert eine Reihe von Regeln, um den Links zu folgen und mehr als eine Seite zu verschrotten. Es hat die folgende Klasse -
class scrapy.spiders.CrawlSpider
Im Folgenden sind die Attribute der CrawlSpider-Klasse aufgeführt:
Regeln
Es ist eine Liste von Regelobjekten, die definiert, wie der Crawler dem Link folgt.
Die folgende Tabelle zeigt die Regeln der CrawlSpider-Klasse -
Sr.Nr. | Regel & Beschreibung |
---|---|
1 | LinkExtractor Es gibt an, wie Spider den Links folgt und die Daten extrahiert. |
2 | callback Es soll aufgerufen werden, nachdem jede Seite abgekratzt wurde. |
3 | follow Es gibt an, ob Links weiter verfolgt werden sollen oder nicht. |
parse_start_url (Antwort)
Es gibt entweder ein Element oder ein Anforderungsobjekt zurück, indem die ersten Antworten analysiert werden.
Note - Stellen Sie sicher, dass Sie beim Schreiben der Regeln eine andere Analysefunktion als parse umbenennen, da die Analysefunktion von CrawlSpider zur Implementierung der Logik verwendet wird.
Schauen wir uns das folgende Beispiel an, in dem Spider beginnt, die Homepage von demoexample.com zu crawlen und alle Seiten, Links und Analysen mit der Methode parse_items zu sammeln.
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
Es ist die Basisklasse für Spinnen, die aus XML-Feeds kratzen und über Knoten iterieren. Es hat die folgende Klasse -
class scrapy.spiders.XMLFeedSpider
Die folgende Tabelle zeigt die Klassenattribute, die zum Festlegen eines Iterators und eines Tag-Namens verwendet werden.
Sr.Nr. | Attribut & Beschreibung |
---|---|
1 | iterator Es definiert den zu verwendenden Iterator. Es kann entweder iternodes, html oder xml sein . Standard ist iternodes . |
2 | itertag Es ist eine Zeichenfolge mit dem zu iterierenden Knotennamen. |
3 | namespaces Es wird durch eine Liste von (Präfix-, Uri-) Tupeln definiert, die Namespaces mithilfe der Methode register_namespace () automatisch registrieren . |
4 | adapt_response(response) Es empfängt die Antwort und ändert den Antworttext, sobald er von der Spider-Middleware eingeht, bevor die Spider mit dem Parsen beginnt. |
5 | parse_node(response,selector) Es erhält die Antwort und einen Selektor, wenn es für jeden Knoten aufgerufen wird, der mit dem angegebenen Tag-Namen übereinstimmt. Note - Ihre Spinne funktioniert nicht, wenn Sie diese Methode nicht überschreiben. |
6 | process_results(response,results) Es gibt eine Liste der Ergebnisse und Antworten zurück, die von der Spinne zurückgegeben wurden. |
CSVFeedSpider
Es durchläuft jede seiner Zeilen, empfängt eine CSV-Datei als Antwort und ruft die Methode parse_row () auf . Es hat die folgende Klasse -
class scrapy.spiders.CSVFeedSpider
Die folgende Tabelle zeigt die Optionen, die für die CSV-Datei festgelegt werden können.
Sr.Nr. | Option & Beschreibung |
---|---|
1 | delimiter Es ist eine Zeichenfolge, die für jedes Feld ein Komma-Trennzeichen (',') enthält. |
2 | quotechar Es ist eine Zeichenfolge, die für jedes Feld ein Anführungszeichen ('"') enthält. |
3 | headers Es ist eine Liste von Anweisungen, aus denen die Felder extrahiert werden können. |
4 | parse_row(response,row) Es erhält eine Antwort und jede Zeile zusammen mit einem Schlüssel für den Header. |
CSVFeedSpider Beispiel
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
SitemapSpider
SitemapSpider crawlt mithilfe von Sitemaps eine Website, indem die URLs aus robots.txt gesucht werden. Es hat die folgende Klasse -
class scrapy.spiders.SitemapSpider
Die folgende Tabelle zeigt die Felder von SitemapSpider -
Sr.Nr. | Feld Beschreibung |
---|---|
1 | sitemap_urls Eine Liste von URLs, die Sie crawlen möchten und auf die Sitemaps verweisen. |
2 | sitemap_rules Es handelt sich um eine Liste von Tupeln (regulärer Ausdruck, Rückruf), wobei regulärer Ausdruck ein regulärer Ausdruck ist und der Rückruf zum Verarbeiten von URLs verwendet wird, die einem regulären Ausdruck entsprechen. |
3 | sitemap_follow Es ist eine Liste der regulären Ausdrücke der Sitemap. |
4 | sitemap_alternate_links Gibt alternative Links an, denen für eine einzelne URL gefolgt werden soll. |
SitemapSpider Beispiel
Der folgende SitemapSpider verarbeitet alle URLs -
from scrapy.spiders import SitemapSpider
class DemoSpider(SitemapSpider):
urls = ["http://www.demoexample.com/sitemap.xml"]
def parse(self, response):
# You can scrap items here
Der folgende SitemapSpider verarbeitet einige URLs mit Rückruf -
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
Der folgende Code zeigt Sitemaps in der robots.txt, deren URL hat /sitemap_company - -
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
Sie können SitemapSpider sogar mit anderen URLs kombinieren, wie im folgenden Befehl gezeigt.
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...
Beschreibung
Wenn Sie die Webseiten kratzen, müssen Sie einen bestimmten Teil der HTML-Quelle mithilfe des aufgerufenen Mechanismus extrahieren selectors, erreicht durch Verwendung von XPath- oder CSS-Ausdrücken. Selektoren bauen auf demlxml Bibliothek, die XML und HTML in Python verarbeitet.
Verwenden Sie das folgende Codefragment, um verschiedene Konzepte von Selektoren zu definieren:
<html>
<head>
<title>My Website</title>
</head>
<body>
<span>Hello world!!!</span>
<div class = 'links'>
<a href = 'one.html'>Link 1<img src = 'image1.jpg'/></a>
<a href = 'two.html'>Link 2<img src = 'image2.jpg'/></a>
<a href = 'three.html'>Link 3<img src = 'image3.jpg'/></a>
</div>
</body>
</html>
Selektoren konstruieren
Sie können die Selektorklasseninstanzen erstellen, indem Sie die übergeben text oder TextResponseObjekt. Basierend auf dem bereitgestellten Eingabetyp wählt der Selektor die folgenden Regeln aus:
from scrapy.selector import Selector
from scrapy.http import HtmlResponse
Mit dem obigen Code können Sie aus dem Text Folgendes konstruieren:
Selector(text = body).xpath('//span/text()').extract()
Das Ergebnis wird als - angezeigt
[u'Hello world!!!']
Sie können aus der Antwort Folgendes konstruieren:
response = HtmlResponse(url = 'http://mysite.com', body = body)
Selector(response = response).xpath('//span/text()').extract()
Das Ergebnis wird als - angezeigt
[u'Hello world!!!']
Verwenden von Selektoren
Mit dem obigen einfachen Codefragment können Sie den XPath für die Auswahl des Textes erstellen, der im Titel-Tag definiert ist, wie unten gezeigt -
>>response.selector.xpath('//title/text()')
Jetzt können Sie die Textdaten mit dem extrahieren .extract() Methode wie folgt gezeigt -
>>response.xpath('//title/text()').extract()
Das Ergebnis wird als -
[u'My Website']
Sie können den Namen aller angezeigten Elemente wie folgt anzeigen:
>>response.xpath('//div[@class = "links"]/a/text()').extract()
Die Elemente werden als - angezeigt
Link 1
Link 2
Link 3
Wenn Sie das erste Element extrahieren möchten, verwenden Sie die Methode .extract_first(), wie folgt dargestellt -
>>response.xpath('//div[@class = "links"]/a/text()').extract_first()
Das Element wird als - angezeigt
Link 1
Verschachtelungsselektoren
Mit dem obigen Code können Sie die Selektoren verschachteln, um den Seitenlink und die Bildquelle mit dem anzuzeigen .xpath() Methode, wie folgt gezeigt -
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
Das Ergebnis wird als - angezeigt
Link 1 pointing to url [u'one.html'] and image [u'image1.jpg']
Link 2 pointing to url [u'two.html'] and image [u'image2.jpg']
Link 3 pointing to url [u'three.html'] and image [u'image3.jpg']
Selektoren, die reguläre Ausdrücke verwenden
Mit Scrapy können die Daten mit regulären Ausdrücken extrahiert werden .re()Methode. Aus dem obigen HTML-Code werden die folgenden Bildnamen extrahiert:
>>response.xpath('//a[contains(@href, "image")]/text()').re(r'Name:\s*(.*)')
In der obigen Zeile werden die Bildnamen als - angezeigt.
[u'Link 1',
u'Link 2',
u'Link 3']
Relative XPaths verwenden
Wenn Sie mit XPaths arbeiten, beginnt dies mit dem /, verschachtelte Selektoren und XPath beziehen sich auf den absoluten Pfad des Dokuments und nicht auf den relativen Pfad des Selektors.
Wenn Sie die extrahieren möchten <p> Elemente, dann gewinnen Sie zuerst alle div-Elemente -
>>mydiv = response.xpath('//div')
Als nächstes können Sie alle extrahieren 'p' Elemente im Inneren, indem dem XPath ein Punkt als vorangestellt wird .//p wie unten gezeigt -
>>for p in mydiv.xpath('.//p').extract()
Verwenden von EXSLT-Erweiterungen
EXSLT ist eine Community, die die Erweiterungen für XSLT (Extensible Stylesheet Language Transformations) herausgibt, mit denen XML-Dokumente in XHTML-Dokumente konvertiert werden. Sie können die EXSLT-Erweiterungen mit dem registrierten Namespace in den XPath-Ausdrücken verwenden, wie in der folgenden Tabelle gezeigt -
Sr.Nr. | Präfix & Verwendung | Namespace |
---|---|---|
1 | re Reguläre Ausdrücke |
http://exslt.org/regexp/index.html |
2 | set Manipulation einstellen |
http://exslt.org/set/index.html |
Sie können das einfache Codeformat zum Extrahieren von Daten mithilfe regulärer Ausdrücke im vorherigen Abschnitt überprüfen.
Es gibt einige XPath-Tipps, die nützlich sind, wenn Sie XPath mit Scrapy-Selektoren verwenden. Für weitere Informationen klicken Sie auf diesen Link .
Beschreibung
Der Scrapy-Prozess kann verwendet werden, um die Daten mithilfe der Spinnen aus Quellen wie Webseiten zu extrahieren. Scrapy verwendetItem Klasse, um die Ausgabe zu erzeugen, deren Objekte zum Sammeln der verkratzten Daten verwendet werden.
Artikel deklarieren
Sie können die Elemente mithilfe der Klassendefinitionssyntax zusammen mit den folgenden Feldobjekten deklarieren:
import scrapy
class MyProducts(scrapy.Item):
productName = Field()
productLink = Field()
imageURL = Field()
price = Field()
size = Field()
Artikelfelder
Die Elementfelder werden verwendet, um die Metadaten für jedes Feld anzuzeigen. Da es keine Einschränkung der Werte für die Feldobjekte gibt, enthalten die zugänglichen Metadatenschlüssel keine Referenzliste der Metadaten. Die Feldobjekte werden verwendet, um alle Feldmetadaten anzugeben, und Sie können jeden anderen Feldschlüssel gemäß Ihren Anforderungen im Projekt angeben. Auf die Feldobjekte kann mit dem Attribut Item.fields zugegriffen werden.
Arbeiten mit Gegenständen
Es gibt einige allgemeine Funktionen, die definiert werden können, wenn Sie mit den Elementen arbeiten. Für weitere Informationen klicken Sie auf diesen Link .
Elemente erweitern
Die Elemente können durch Angabe der Unterklasse des ursprünglichen Elements erweitert werden. Zum Beispiel -
class MyProductDetails(Product):
original_rate = scrapy.Field(serializer = str)
discount_rate = scrapy.Field()
Sie können die vorhandenen Feldmetadaten verwenden, um die Feldmetadaten zu erweitern, indem Sie weitere Werte hinzufügen oder die vorhandenen Werte ändern, wie im folgenden Code gezeigt.
class MyProductPackage(Product):
name = scrapy.Field(Product.fields['name'], serializer = serializer_demo)
Objekt Objekte
Die Elementobjekte können mithilfe der folgenden Klasse angegeben werden, die das neue initialisierte Element aus dem angegebenen Argument bereitstellt:
class scrapy.item.Item([arg])
Das Element enthält eine Kopie des Konstruktors und ein zusätzliches Attribut, das von den Elementen in den Feldern angegeben wird.
Feldobjekte
Die Feldobjekte können mit der folgenden Klasse angegeben werden, in der die Feldklasse den zusätzlichen Prozess oder die zusätzlichen Attribute nicht ausgibt:
class scrapy.item.Field([arg])
Beschreibung
Artikellader bieten eine bequeme Möglichkeit, die von den Websites abgekratzten Artikel zu füllen.
Artikellader deklarieren
Die Deklaration von Item Loadern ist wie Items.
Zum Beispiel -
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
Im obigen Code können Sie sehen, dass Eingabeprozessoren mit deklariert werden _in Suffix- und Ausgabeprozessoren werden mit deklariert _out Suffix.
Das ItemLoader.default_input_processor und ItemLoader.default_output_processor Attribute werden verwendet, um Standardeingabe- / Ausgabeprozessoren zu deklarieren.
Verwenden von Item Loadern zum Auffüllen von Items
Um Item Loader zu verwenden, instanziieren Sie zuerst mit einem diktartigen Objekt oder ohne ein Objekt, in dem das Item die in angegebene Item-Klasse verwendet ItemLoader.default_item_class Attribut.
Sie können Selektoren verwenden, um Werte im Item Loader zu sammeln.
Sie können weitere Werte in dasselbe Elementfeld einfügen, wobei Item Loader einen geeigneten Handler verwendet, um diese Werte hinzuzufügen.
Der folgende Code zeigt, wie Elemente mit Elementladern gefüllt werden.
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()
Wie oben gezeigt, gibt es zwei verschiedene XPaths, von denen die title Feld wird mit extrahiert add_xpath() Methode -
1. //div[@class = "product_title"]
2. //div[@class = "product_name"]
Danach wird eine ähnliche Anfrage für verwendet descFeld. Die Größendaten werden mit extrahiertadd_css() Methode und last_updated wird mit einem Wert "gestern" mit gefüllt add_value() Methode.
Sobald alle Daten gesammelt sind, rufen Sie an ItemLoader.load_item() Methode, die die mit Daten extrahierten Elemente zurückgibt, die mit extrahiert wurden add_xpath(), add_css() und add_value() Methoden.
Eingabe- und Ausgabeprozessoren
Jedes Feld eines Item Loader enthält einen Eingabeprozessor und einen Ausgabeprozessor.
Wenn Daten extrahiert werden, verarbeitet der Eingabeprozessor sie und das Ergebnis wird in ItemLoader gespeichert.
Rufen Sie nach dem Sammeln der Daten die Methode ItemLoader.load_item () auf, um das aufgefüllte Item-Objekt abzurufen.
Schließlich können Sie dem Element das Ergebnis des Ausgabeprozessors zuweisen.
Der folgende Code zeigt, wie Eingabe- und Ausgabeprozessoren für ein bestimmtes Feld aufgerufen werden:
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]
Line 1 - Die Titeldaten werden aus xpath1 extrahiert und durch den Eingabeprozessor geleitet. Das Ergebnis wird gesammelt und in ItemLoader gespeichert.
Line 2 - In ähnlicher Weise wird der Titel aus xpath2 extrahiert und durch denselben Eingabeprozessor geleitet, und sein Ergebnis wird zu den für [1] gesammelten Daten hinzugefügt.
Line 3 - Der Titel wird aus dem CSS-Selektor extrahiert und durch denselben Eingabeprozessor geleitet. Das Ergebnis wird zu den für [1] und [2] gesammelten Daten hinzugefügt.
Line 4 - Als nächstes wird der Wert "Demo" zugewiesen und durch die Eingabeprozessoren geleitet.
Line 5 - Schließlich werden die Daten intern aus allen Feldern gesammelt und an den Ausgabeprozessor übergeben, und der Endwert wird dem Element zugewiesen.
Deklarieren von Eingabe- und Ausgabeprozessoren
Die Eingabe- und Ausgabeprozessoren sind in der ItemLoader-Definition deklariert. Abgesehen davon können sie auch in der angegeben werdenItem Field Metadaten.
Zum Beispiel -
import scrapy
from scrapy.loader.processors import Join, MapCompose, TakeFirst
from w3lib.html 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()
Es zeigt eine Ausgabe als -
{'title': u'Hello world', 'size': u'100 kg'}
Item Loader-Kontext
Der Item Loader-Kontext ist ein Diktat beliebiger Schlüsselwerte, die von Eingabe- und Ausgabeprozessoren gemeinsam genutzt werden.
Angenommen , Sie haben eine Funktion 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
Durch das Empfangen von loader_context-Argumenten wird dem Item Loader mitgeteilt, dass er den Item Loader-Kontext empfangen kann. Es gibt verschiedene Möglichkeiten, den Wert des Item Loader-Kontexts zu ändern:
Aktuell aktiven Item Loader-Kontext ändern -
loader = ItemLoader (product)
loader.context ["unit"] = "mm"
On Item Loader Instanziierung -
loader = ItemLoader(product, unit = "mm")
On Item Loader-Deklaration für Eingabe- / Ausgabeprozessoren, die mit dem Item Loader-Kontext instanziiert werden -
class ProductLoader(ItemLoader):
length_out = MapCompose(parse_length, unit = "mm")
ItemLoader-Objekte
Es ist ein Objekt, das einen neuen Elementlader zurückgibt, um das angegebene Element zu füllen. Es hat die folgende Klasse -
class scrapy.loader.ItemLoader([item, selector, response, ]**kwargs)
Die folgende Tabelle zeigt die Parameter von ItemLoader-Objekten -
Sr.Nr. | Parameter & Beschreibung |
---|---|
1 | item Es ist das Element, das durch Aufrufen von add_xpath (), add_css () oder add_value () aufgefüllt werden muss. |
2 | selector Es wird verwendet, um Daten von Websites zu extrahieren. |
3 | response Es wird verwendet, um einen Selektor mit default_selector_class zu erstellen. |
Die folgende Tabelle zeigt die Methoden von ItemLoader-Objekten -
Sr.Nr. | Methode & Beschreibung | Beispiel |
---|---|---|
1 | get_value(value, *processors, **kwargs) Durch einen bestimmten Prozessor und Schlüsselwortargumente wird der Wert von der Methode get_value () verarbeitet. |
|
2 | add_value(field_name, value, *processors, **kwargs) Es verarbeitet den Wert und fügt dem Feld, in dem er zuerst durch get_value übergeben wird, hinzu, indem Prozessoren und Schlüsselwortargumente angegeben werden, bevor der Feldeingabeprozessor durchlaufen wird. |
|
3 | replace_value(field_name, value, *processors, **kwargs) Es ersetzt die gesammelten Daten durch einen neuen Wert. |
|
4 | get_xpath(xpath, *processors, **kwargs) Es wird verwendet, um Unicode-Zeichenfolgen zu extrahieren, indem Prozessoren und Schlüsselwortargumente durch Empfang von XPath angegeben werden . |
|
5 | add_xpath(field_name, xpath, *processors, **kwargs) Es empfängt XPath für das Feld, das Unicode-Zeichenfolgen extrahiert. |
|
6 | replace_xpath(field_name, xpath, *processors, **kwargs) Es ersetzt die gesammelten Daten mit XPath von Websites. |
|
7 | get_css(css, *processors, **kwargs) Es empfängt den CSS-Selektor, der zum Extrahieren der Unicode-Zeichenfolgen verwendet wird. |
|
8 | add_css(field_name, css, *processors, **kwargs) Es ähnelt der Methode add_value () mit dem Unterschied, dass dem Feld ein CSS-Selektor hinzugefügt wird. |
|
9 | replace_css(field_name, css, *processors, **kwargs) Es ersetzt die extrahierten Daten mit dem CSS-Selektor. |
|
10 | load_item() Wenn die Daten erfasst werden, füllt diese Methode den Artikel mit den erfassten Daten und gibt sie zurück. |
|
11 | nested_xpath(xpath) Es wird verwendet, um verschachtelte Loader mit einem XPath-Selektor zu erstellen. |
|
12 | nested_css(css) Es wird verwendet, um verschachtelte Loader mit einem CSS-Selektor zu erstellen. |
|
Die folgende Tabelle zeigt die Attribute von ItemLoader-Objekten -
Sr.Nr. | Attribut & Beschreibung |
---|---|
1 | item Es ist ein Objekt, für das der Item Loader eine Analyse durchführt. |
2 | context Es ist der aktuelle Kontext von Item Loader, der aktiv ist. |
3 | default_item_class Es wird verwendet, um die Elemente darzustellen, wenn dies nicht im Konstruktor angegeben ist. |
4 | default_input_processor Die Felder, in denen kein Eingabeprozessor angegeben ist, sind die einzigen, für die default_input_processors verwendet werden. |
5 | default_output_processor Die Felder, in denen der Ausgabeprozessor nicht angegeben ist, sind die einzigen, für die default_output_processors verwendet werden. |
6 | default_selector_class Es ist eine Klasse, die zum Erstellen des Selektors verwendet wird, wenn sie nicht im Konstruktor angegeben ist. |
7 | selector Es ist ein Objekt, mit dem die Daten von Websites extrahiert werden können. |
Verschachtelte Lader
Es wird verwendet, um verschachtelte Loader zu erstellen, während die Werte aus dem Unterabschnitt eines Dokuments analysiert werden. Wenn Sie keine verschachtelten Loader erstellen, müssen Sie für jeden Wert, den Sie extrahieren möchten, vollständigen XPath oder CSS angeben.
Angenommen, die Daten werden aus einer Headerseite extrahiert.
<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>
Als Nächstes können Sie einen verschachtelten Loader mit Header-Auswahl erstellen, indem Sie dem Header verwandte Werte hinzufügen.
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()
Wiederverwenden und Erweitern von Gegenstandsladern
Gegenstandslader sollen die Wartung erleichtern, die zu einem grundlegenden Problem wird, wenn Ihr Projekt mehr Spinnen erwirbt.
Angenommen, der Produktname einer Site ist in drei Strichen eingeschlossen (z. B. --DVD ---). Sie können diese Bindestriche entfernen, indem Sie den Standard-Product Item Loader wiederverwenden, wenn Sie ihn nicht in den endgültigen Produktnamen haben möchten, wie im folgenden Code gezeigt -
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)
Verfügbare integrierte Prozessoren
Im Folgenden sind einige der häufig verwendeten integrierten Prozessoren aufgeführt:
Klasse Scrapy.loader.processors.Identity
Es gibt den ursprünglichen Wert zurück, ohne ihn zu ändern. Zum Beispiel -
>>> from scrapy.loader.processors import Identity
>>> proc = Identity()
>>> proc(['a', 'b', 'c'])
['a', 'b', 'c']
Klasse Scrapy.loader.processors.TakeFirst
Es gibt den ersten Wert aus der Liste der empfangenen Werte zurück, der nicht null / nicht leer ist. Zum Beispiel -
>>> from scrapy.loader.processors import TakeFirst
>>> proc = TakeFirst()
>>> proc(['', 'a', 'b', 'c'])
'a'
Klasse Scrapy.loader.processors.Join (Trennzeichen = u '')
Es gibt den an das Trennzeichen angehängten Wert zurück. Das Standardtrennzeichen ist u '' und entspricht der Funktionu' '.join. Zum Beispiel -
>>> 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'
Klasse Scrapy.loader.processors.Compose (* Funktionen, ** Standard_Lader_Kontext)
Es wird von einem Prozessor definiert, bei dem jeder seiner Eingabewerte an die erste Funktion übergeben wird und das Ergebnis dieser Funktion an die zweite Funktion usw. übergeben wird, bis die ast-Funktion den Endwert als Ausgabe zurückgibt.
Zum Beispiel -
>>> from scrapy.loader.processors import Compose
>>> proc = Compose(lambda v: v[0], str.upper)
>>> proc(['python', 'scrapy'])
'PYTHON'
Klasse Scrapy.loader.processors.MapCompose (* Funktionen, ** Standard_Lader_Kontext)
Es ist ein Prozessor, bei dem der Eingabewert iteriert wird und die erste Funktion auf jedes Element angewendet wird. Als nächstes wird das Ergebnis dieser Funktionsaufrufe verkettet, um eine neue Iterierbarkeit zu erstellen, die dann auf die zweite Funktion usw. bis zur letzten Funktion angewendet wird.
Zum Beispiel -
>>> 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']
Klasse Scrapy.loader.processors.SelectJmes (json_path)
Diese Klasse fragt den Wert unter Verwendung des angegebenen json-Pfads ab und gibt die Ausgabe zurück.
Zum Beispiel -
>>> from scrapy.loader.processors import SelectJmes, Compose, MapCompose
>>> proc = SelectJmes("hello")
>>> proc({'hello': 'scrapy'})
'scrapy'
>>> proc({'hello': {'scrapy': 'world'}})
{'scrapy': 'world'}
Es folgt der Code, der den Wert durch Importieren von json abfragt -
>>> 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']
Beschreibung
Die Scrapy-Shell kann verwendet werden, um die Daten mit fehlerfreiem Code ohne Verwendung von Spider zu verschrotten. Der Hauptzweck der Scrapy-Shell besteht darin, den extrahierten Code, XPath oder CSS-Ausdrücke zu testen. Außerdem können Sie die Webseiten angeben, von denen Sie die Daten abkratzen.
Shell konfigurieren
Die Shell kann durch Installieren der IPython- Konsole (für interaktives Rechnen verwendet) konfiguriert werden. Hierbei handelt es sich um eine leistungsstarke interaktive Shell, die die automatische Vervollständigung, kolorierte Ausgabe usw. ermöglicht.
Wenn Sie auf der Unix-Plattform arbeiten, ist es besser, IPython zu installieren. Sie können auch bpython verwenden , wenn auf IPython nicht zugegriffen werden kann.
Sie können die Shell konfigurieren, indem Sie die Umgebungsvariable SCRAPY_PYTHON_SHELL festlegen oder die Dateirapy.cfg wie folgt definieren:
[settings]
shell = bpython
Shell starten
Die Scrapy-Shell kann mit dem folgenden Befehl gestartet werden:
scrapy shell <url>
Die URL gibt die URL an, für die die Daten gelöscht werden müssen.
Verwenden der Shell
Die Shell bietet einige zusätzliche Verknüpfungen und Scrapy-Objekte, wie in der folgenden Tabelle beschrieben.
Verfügbare Verknüpfungen
Shell bietet die folgenden verfügbaren Verknüpfungen im Projekt:
Sr.Nr. | Verknüpfung & Beschreibung |
---|---|
1 | shelp() Es bietet die verfügbaren Objekte und Verknüpfungen mit der Hilfeoption. |
2 | fetch(request_or_url) Es sammelt die Antwort von der Anfrage oder URL und die zugehörigen Objekte werden ordnungsgemäß aktualisiert. |
3 | view(response) Sie können die Antwort für die angegebene Anforderung im lokalen Browser zur Beobachtung anzeigen. Um den externen Link korrekt anzuzeigen, wird ein Basistag an den Antworttext angehängt. |
Verfügbare Scrapy-Objekte
Shell bietet die folgenden verfügbaren Scrapy-Objekte im Projekt:
Sr.Nr. | Objekt & Beschreibung |
---|---|
1 | crawler Es gibt das aktuelle Crawler-Objekt an. |
2 | spider Wenn für die aktuelle URL keine Spinne vorhanden ist, wird die URL oder das Spinnenobjekt durch Definieren der neuen Spinne verarbeitet. |
3 | request Es gibt das Anforderungsobjekt für die zuletzt gesammelte Seite an. |
4 | response Es gibt das Antwortobjekt für die zuletzt gesammelte Seite an. |
5 | settings Es bietet die aktuellen Scrapy-Einstellungen. |
Beispiel einer Shell-Sitzung
Lassen Sie uns versuchen, die Websiterapy.org zu kratzen, und dann beginnen, die Daten von reddit.com wie beschrieben zu kratzen.
Bevor wir fortfahren, starten wir zuerst die Shell wie im folgenden Befehl gezeigt -
scrapy shell 'http://scrapy.org' --nolog
Scrapy zeigt die verfügbaren Objekte unter Verwendung der obigen URL an -
[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
Beginnen Sie als nächstes mit der Bearbeitung von Objekten, die wie folgt dargestellt sind:
>> 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
...
Aufrufen der Shell von Spinnen, um die Antworten zu überprüfen
Sie können die Antworten, die von der Spinne verarbeitet werden, nur überprüfen, wenn Sie diese Antwort erwarten.
Zum Beispiel -
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)
Wie im obigen Code gezeigt, können Sie die Shell von Spinnen aus aufrufen, um die Antworten mit der folgenden Funktion zu überprüfen:
scrapy.shell.inspect_response
Führen Sie nun die Spinne aus und Sie erhalten den folgenden Bildschirm:
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'
Mit dem folgenden Code können Sie überprüfen, ob der extrahierte Code funktioniert:
>> response.xpath('//div[@class = "val"]')
Es zeigt die Ausgabe als
[]
In der obigen Zeile wurde nur eine leere Ausgabe angezeigt. Jetzt können Sie die Shell aufrufen, um die Antwort wie folgt zu überprüfen:
>> view(response)
Es zeigt die Antwort als an
True
Beschreibung
Item Pipelineist eine Methode, bei der die verschrotteten Elemente verarbeitet werden. Wenn ein Artikel an die Artikel-Pipeline gesendet wird, wird er von einer Spinne abgekratzt und mit mehreren Komponenten verarbeitet, die nacheinander ausgeführt werden.
Immer wenn ein Artikel eingeht, entscheidet er über eine der folgenden Aktionen:
- Verarbeiten Sie den Artikel weiter.
- Lass es aus der Pipeline fallen.
- Beenden Sie die Verarbeitung des Artikels.
Item-Pipelines werden im Allgemeinen für folgende Zwecke verwendet:
- Scraped Items in der Datenbank speichern.
- Wenn der empfangene Artikel wiederholt wird, wird der wiederholte Artikel gelöscht.
- Es wird geprüft, ob sich das Element in Zielfeldern befindet.
- HTML-Daten löschen.
Syntax
Sie können die Item-Pipeline mit der folgenden Methode schreiben:
process_item(self, item, spider)
Die obige Methode enthält folgende Parameter:
- Element (Elementobjekt oder Wörterbuch) - Gibt das abgekratzte Element an.
- Spinne (Spinnenobjekt) - Die Spinne, die den Gegenstand abgekratzt hat.
Sie können zusätzliche Methoden verwenden, die in der folgenden Tabelle aufgeführt sind:
Sr.Nr. | Methode & Beschreibung | Parameter |
---|---|---|
1 | open_spider(self, spider) Es wird ausgewählt, wenn die Spinne geöffnet wird. |
Spinne (Spinnenobjekt) - Bezieht sich auf die Spinne, die geöffnet wurde. |
2 | close_spider(self, spider) Es wird ausgewählt, wenn die Spinne geschlossen ist. |
Spinne (Spinnenobjekt) - Bezieht sich auf die Spinne, die geschlossen wurde. |
3 | from_crawler(cls, crawler) Mit Hilfe des Crawlers kann die Pipeline auf die Kernkomponenten wie Signale und Einstellungen von Scrapy zugreifen. |
Crawler (Crawler-Objekt) - Bezieht sich auf den Crawler, der diese Pipeline verwendet. |
Beispiel
Im Folgenden finden Sie Beispiele für die Elementpipeline, die in verschiedenen Konzepten verwendet wird.
Löschen von Elementen ohne Tag
Im folgenden Code gleicht die Pipeline das Attribut (Preis) für diejenigen Artikel aus, die keine Mehrwertsteuer enthalten (Attribut excludes_vat), und ignoriert diejenigen Artikel, die kein Preisschild haben.
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)
Schreiben von Elementen in eine JSON-Datei
Der folgende Code speichert alle von allen Spinnen abgekratzten Gegenstände in einem einzigen items.jlDatei, die ein Element pro Zeile in serialisierter Form im JSON-Format enthält. DasJsonWriterPipeline Klasse wird im Code verwendet, um zu zeigen, wie die Elementpipeline geschrieben wird -
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
Elemente in MongoDB schreiben
Sie können die MongoDB-Adresse und den Datenbanknamen in den Scrapy-Einstellungen angeben und die MongoDB-Sammlung kann nach der Elementklasse benannt werden. Der folgende Code beschreibt die Verwendungfrom_crawler() Methode, um die Ressourcen richtig zu sammeln -
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
Filter duplizieren
Ein Filter sucht nach wiederholten Elementen und löscht die bereits verarbeiteten Elemente. Im folgenden Code haben wir eine eindeutige ID für unsere Artikel verwendet, aber Spider gibt viele Artikel mit derselben ID zurück -
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
Aktivieren einer Item-Pipeline
Sie können eine Item-Pipeline-Komponente aktivieren, indem Sie ihre Klasse zur Einstellung ITEM_PIPELINES hinzufügen , wie im folgenden Code gezeigt. Sie können den Klassen ganzzahlige Werte in der Reihenfolge zuweisen, in der sie ausgeführt werden (die Reihenfolge kann für Klassen mit höherem Wert niedriger sein), und die Werte liegen im Bereich von 0 bis 1000.
ITEM_PIPELINES = {
'myproject.pipelines.PricePipeline': 100,
'myproject.pipelines.JsonWriterPipeline': 600,
}
Beschreibung
Feed-Exporte sind eine Methode zum Speichern der von den Sites gescrapten Daten, die a generieren "export file".
Serialisierungsformate
Feed-Exporte verwenden mehrere Serialisierungsformate und Speicher-Backends und verwenden Artikelexporteure. Sie generieren einen Feed mit abgekratzten Artikeln.
Die folgende Tabelle zeigt die unterstützten Formate -
Sr.Nr. | Format & Beschreibung |
---|---|
1 | JSON FEED_FORMAT ist json Der verwendete Exporter ist die Klasse Scrapy.exporters.JsonItemExporter |
2 | JSON lines FEED_FROMAT ist jsonlines Der verwendete Exporter ist die Klasse Scrapy.exporters.JsonLinesItemExporter |
3 | CSV FEED_FORMAT ist CSV Der verwendete Exporter ist die Klasse Scrapy.exporters.CsvItemExporter |
4 | XML FEED_FORMAT ist xml Der verwendete Exporter ist die Klasse Scrapy.exporters.XmlItemExporter |
Verwenden von FEED_EXPORTERS Einstellungen können die unterstützten Formate auch erweitert werden -
Sr.Nr. | Format & Beschreibung |
---|---|
1 | Pickle FEED_FORMAT ist pickel Der verwendete Exporter ist die Klasse Scrapy.exporters.PickleItemExporter |
2 | Marshal FEED_FORMAT ist Marschall Der verwendete Exporter ist die Klasse Scrapy.exporters.MarshalItemExporter |
Speicher-Backends
Das Speicher-Backend definiert, wo der Feed mithilfe des URI gespeichert werden soll.
Die folgende Tabelle zeigt die unterstützten Speicher-Backends -
Sr.Nr. | Speicher-Backend & Beschreibung |
---|---|
1 | Local filesystem Das URI-Schema ist eine Datei und wird zum Speichern der Feeds verwendet. |
2 | FTP Das URI-Schema ist ftp und wird zum Speichern der Feeds verwendet. |
3 | S3 Das URI-Schema lautet S3 und die Feeds werden in Amazon S3 gespeichert. Externe Bibliotheken Botocore oder Boto sind erforderlich. |
4 | Standard output URI - Schema ist stdout und die Feeds werden in der Standardausgabe gespeichert. |
Speicher-URI-Parameter
Im Folgenden sind die Parameter der Speicher-URL aufgeführt, die beim Erstellen des Feeds ersetzt wird.
- % (Zeit) s: Dieser Parameter wird durch einen Zeitstempel ersetzt.
- % (Name) s: Dieser Parameter wird durch den Spinnennamen ersetzt.
die Einstellungen
Die folgende Tabelle zeigt die Einstellungen, mit denen Feed-Exporte konfiguriert werden können.
Sr.Nr. | Einstellung & Beschreibung |
---|---|
1 | FEED_URI Dies ist der URI des Export-Feeds, der zum Aktivieren des Feed-Exports verwendet wird. |
2 | FEED_FORMAT Es ist ein Serialisierungsformat, das für den Feed verwendet wird. |
3 | FEED_EXPORT_FIELDS Es wird zum Definieren von Feldern verwendet, die exportiert werden müssen. |
4 | FEED_STORE_EMPTY Es definiert, ob Feeds ohne Elemente exportiert werden sollen. |
5 | FEED_STORAGES Es ist ein Wörterbuch mit zusätzlichen Feed-Backends. |
6 | FEED_STORAGES_BASE Es ist ein Wörterbuch mit integrierten Feed-Backends. |
7 | FEED_EXPORTERS Es ist ein Wörterbuch mit zusätzlichen Futtermittelexporteuren. |
8 | FEED_EXPORTERS_BASE Es ist ein Wörterbuch mit integrierten Futtermittelexporteuren. |
Beschreibung
Scrapy kann Websites mit dem crawlen Request und ResponseObjekte. Die Anforderungsobjekte werden über das System übertragen, verwenden die Spider, um die Anforderung auszuführen und zur Anforderung zurückzukehren, wenn ein Antwortobjekt zurückgegeben wird.
Objekte anfordern
Das Anforderungsobjekt ist eine HTTP-Anforderung, die eine Antwort generiert. Es hat die folgende Klasse -
class scrapy.http.Request(url[, callback, method = 'GET', headers, body, cookies, meta,
encoding = 'utf-8', priority = 0, dont_filter = False, errback])
Die folgende Tabelle zeigt die Parameter von Anforderungsobjekten -
Sr.Nr. | Parameter & Beschreibung |
---|---|
1 | url Es ist eine Zeichenfolge, die die URL-Anforderung angibt. |
2 | callback Es ist eine aufrufbare Funktion, die die Antwort der Anfrage als ersten Parameter verwendet. |
3 | method Es ist eine Zeichenfolge, die die HTTP-Methodenanforderung angibt. |
4 | headers Es ist ein Wörterbuch mit Anforderungsheadern. |
5 | body Es ist eine Zeichenfolge oder ein Unicode mit einem Anforderungshauptteil. |
6 | cookies Es ist eine Liste mit Anforderungscookies. |
7 | meta Es ist ein Wörterbuch, das Werte für Metadaten der Anforderung enthält. |
8 | encoding Es ist eine Zeichenfolge mit der utf-8-Codierung, die zum Codieren der URL verwendet wird. |
9 | priority Es ist eine Ganzzahl, bei der der Scheduler die Priorität verwendet, um die Reihenfolge für die Verarbeitung von Anforderungen zu definieren. |
10 | dont_filter Es ist ein Boolescher Wert, der angibt, dass der Scheduler die Anforderung nicht filtern soll. |
11 | errback Es ist eine aufrufbare Funktion, die aufgerufen wird, wenn eine Ausnahme während der Verarbeitung einer Anforderung ausgelöst wird. |
Übergabe zusätzlicher Daten an Rückruffunktionen
Die Rückruffunktion einer Anfrage wird aufgerufen, wenn die Antwort als erster Parameter heruntergeladen wird.
Zum Beispiel -
def parse_page1(self, response):
return scrapy.Request("http://www.something.com/some_page.html",
callback = self.parse_page2)
def parse_page2(self, response):
self.logger.info("%s page visited", response.url)
Sie können verwenden Request.meta Attribut, wenn Sie Argumente an aufrufbare Funktionen übergeben und diese Argumente im zweiten Rückruf empfangen möchten, wie im folgenden Beispiel gezeigt -
def parse_page1(self, response):
item = DemoItem()
item['foremost_link'] = response.url
request = scrapy.Request("http://www.something.com/some_page.html",
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
Verwenden von Errbacks zum Abfangen von Ausnahmen bei der Anforderungsverarbeitung
Der Errback ist eine aufrufbare Funktion, die aufgerufen wird, wenn eine Ausnahme während der Verarbeitung einer Anforderung ausgelöst wird.
Das folgende Beispiel zeigt dies -
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 Spezialschlüssel
Die Spezialschlüssel request.meta sind eine Liste spezieller Metaschlüssel, die von Scrapy identifiziert wurden.
Die folgende Tabelle zeigt einige der Schlüssel von Request.meta -
Sr.Nr. | Schlüssel & Beschreibung |
---|---|
1 | dont_redirect Wenn dieser Wert auf true gesetzt ist, wird die Anforderung nicht basierend auf dem Status der Antwort umgeleitet. |
2 | dont_retry Es ist ein Schlüssel, wenn er auf true gesetzt ist, die fehlgeschlagenen Anforderungen nicht wiederholt und von der Middleware ignoriert wird. |
3 | handle_httpstatus_list Es ist ein Schlüssel, der definiert, welche Antwortcodes pro Anforderungsbasis zulässig sind. |
4 | handle_httpstatus_all Es ist ein Schlüssel, der verwendet wird, um einen Antwortcode für eine Anforderung zuzulassen, indem er auf true gesetzt wird . |
5 | dont_merge_cookies Es ist ein Schlüssel, der verwendet wird, um das Zusammenführen mit den vorhandenen Cookies zu vermeiden, indem er auf true gesetzt wird . |
6 | cookiejar Es ist ein Schlüssel, mit dem mehrere Cookie-Sitzungen pro Spinne gespeichert werden. |
7 | dont_cache Dieser Schlüssel wird verwendet, um das Zwischenspeichern von HTTP-Anforderungen und -Antworten für jede Richtlinie zu vermeiden. |
8 | redirect_urls Es ist ein Schlüssel, der URLs enthält, über die die Anforderungen weitergeleitet werden. |
9 | bindaddress Es ist die IP der ausgehenden IP-Adresse, die zum Ausführen der Anforderung verwendet werden kann. |
10 | dont_obey_robotstxt Wenn dieser Wert auf true gesetzt ist, werden die vom Ausschlussstandard robots.txt verbotenen Anforderungen nicht gefiltert, selbst wenn ROBOTSTXT_OBEY aktiviert ist. |
11 | download_timeout Es wird verwendet, um das Zeitlimit (in Sekunden) pro Spinne festzulegen, auf das der Downloader wartet, bevor das Zeitlimit überschritten wird. |
12 | download_maxsize Hiermit wird die maximale Größe (in Byte) pro Spinne festgelegt, die der Downloader herunterladen wird. |
13 | proxy Für Anforderungsobjekte kann ein Proxy festgelegt werden, um den HTTP-Proxy für die Verwendung von Anforderungen festzulegen. |
Unterklassen anfordern
Sie können Ihre eigenen benutzerdefinierten Funktionen implementieren, indem Sie die Anforderungsklasse unterordnen. Die integrierten Anforderungsunterklassen lauten wie folgt:
FormRequest-Objekte
Die FormRequest-Klasse behandelt HTML-Formulare, indem sie die Basisanforderung erweitert. Es hat die folgende Klasse -
class scrapy.http.FormRequest(url[,formdata, callback, method = 'GET', headers, body,
cookies, meta, encoding = 'utf-8', priority = 0, dont_filter = False, errback])
Es folgt der Parameter -
formdata - Es handelt sich um ein Wörterbuch mit HTML-Formulardaten, das dem Hauptteil der Anforderung zugewiesen ist.
Note - Die verbleibenden Parameter entsprechen denen der Anforderungsklasse und werden in erläutert Request Objects Sektion.
Die folgenden Klassenmethoden werden von unterstützt FormRequest Objekte zusätzlich zu Anforderungsmethoden -
classmethod from_response(response[, formname = None, formnumber = 0, formdata = None,
formxpath = None, formcss = None, clickdata = None, dont_click = False, ...])
Die folgende Tabelle zeigt die Parameter der obigen Klasse -
Sr.Nr. | Parameter & Beschreibung |
---|---|
1 | response Es ist ein Objekt, mit dem die Formularfelder mithilfe der HTML-Antwortform vorab ausgefüllt werden. |
2 | formname Es ist eine Zeichenfolge, in der das Formular mit dem Namensattribut verwendet wird, sofern angegeben. |
3 | formnumber Es ist eine Ganzzahl von Formularen, die verwendet werden sollen, wenn die Antwort mehrere Formulare enthält. |
4 | formdata Es ist ein Wörterbuch mit Feldern in den Formulardaten, die zum Überschreiben verwendet werden. |
5 | formxpath Wenn angegeben, handelt es sich um eine Zeichenfolge. Es wird das Formular verwendet, das dem xpath entspricht. |
6 | formcss Wenn angegeben, handelt es sich um eine Zeichenfolge. Es wird das Formular verwendet, das dem CSS-Selektor entspricht. |
7 | clickdata Es ist ein Wörterbuch mit Attributen, mit denen das angeklickte Steuerelement überwacht wird. |
8 | dont_click Die Daten aus dem Formular werden gesendet, ohne auf ein Element zu klicken, wenn true festgelegt ist. |
Beispiele
Im Folgenden finden Sie einige Beispiele für die Verwendung von Anforderungen:
Using FormRequest to send data via HTTP POST
Der folgende Code zeigt, wie Sie zurückkehren FormRequest Objekt, wenn Sie HTML-Formular POST in Ihrer Spinne duplizieren möchten -
return [FormRequest(url = "http://www.something.com/post/action",
formdata = {'firstname': 'John', 'lastname': 'dave'},
callback = self.after_post)]
Using FormRequest.from_response() to simulate a user login
Normalerweise verwenden Websites Elemente, über die vorab ausgefüllte Formularfelder bereitgestellt werden.
Das FormRequest.form_response() Die Methode kann verwendet werden, wenn diese Felder beim Scraping automatisch ausgefüllt werden sollen.
Das folgende Beispiel zeigt dies.
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
Antwortobjekte
Es ist ein Objekt, das eine HTTP-Antwort angibt, die den Spinnen zur Verarbeitung zugeführt wird. Es hat die folgende Klasse -
class scrapy.http.Response(url[, status = 200, headers, body, flags])
Die folgende Tabelle zeigt die Parameter von Antwortobjekten -
Sr.Nr. | Parameter & Beschreibung |
---|---|
1 | url Es ist eine Zeichenfolge, die die URL-Antwort angibt. |
2 | status Es ist eine Ganzzahl, die eine HTTP-Statusantwort enthält. |
3 | headers Es ist ein Wörterbuch, das Antwortheader enthält. |
4 | body Es ist eine Zeichenfolge mit Antworttext. |
5 | flags Es ist eine Liste mit Antwortflags. |
Antwortunterklassen
Sie können Ihre eigenen benutzerdefinierten Funktionen implementieren, indem Sie die Antwortklasse in Unterklassen unterteilen. Die integrierten Antwortunterklassen lauten wie folgt:
TextResponse objects
TextResponse-Objekte werden für Binärdaten wie Bilder, Töne usw. verwendet, mit denen die Basisantwortklasse codiert werden kann. Es hat die folgende Klasse -
class scrapy.http.TextResponse(url[, encoding[,status = 200, headers, body, flags]])
Es folgt der Parameter -
encoding - Es ist eine Zeichenfolge mit Codierung, die zum Codieren einer Antwort verwendet wird.
Note - Die verbleibenden Parameter entsprechen der Antwortklasse und werden in erläutert Response Objects Sektion.
Die folgende Tabelle zeigt die Attribute, die vom TextResponse-Objekt zusätzlich zu den Antwortmethoden unterstützt werden.
Sr.Nr. | Attribut & Beschreibung |
---|---|
1 | text Es ist ein Antworttext, auf den auf response.text mehrmals zugegriffen werden kann. |
2 | encoding Es ist eine Zeichenfolge, die eine Codierung für die Antwort enthält. |
3 | selector Es ist ein Attribut, das beim ersten Zugriff instanziiert wird und die Antwort als Ziel verwendet. |
Die folgende Tabelle zeigt die Methoden von unterstützten TextResponse Objekte zusätzlich zu Antwortverfahren -
Sr.Nr. | Methode & Beschreibung |
---|---|
1 | xpath (query) Es ist eine Verknüpfung zu TextResponse.selector.xpath (Abfrage). |
2 | css (query) Es ist eine Verknüpfung zu TextResponse.selector.css (Abfrage). |
3 | body_as_unicode() Es handelt sich um einen Antworttext, der als Methode verfügbar ist und auf den auf response.text mehrmals zugegriffen werden kann. |
HtmlResponse-Objekte
Es ist ein Objekt, das das Codieren und automatische Erkennen unterstützt, indem das Meta-httpequiv- Attribut von HTML betrachtet wird. Die Parameter entsprechen denen der Antwortklasse und werden im Abschnitt Antwortobjekte erläutert. Es hat die folgende Klasse -
class scrapy.http.HtmlResponse(url[,status = 200, headers, body, flags])
XmlResponse-Objekte
Es ist ein Objekt, das das Codieren und automatische Erkennen durch Betrachten der XML-Zeile unterstützt. Die Parameter entsprechen denen der Antwortklasse und werden im Abschnitt Antwortobjekte erläutert. Es hat die folgende Klasse -
class scrapy.http.XmlResponse(url[, status = 200, headers, body, flags])
Beschreibung
Wie der Name schon sagt, sind Link-Extraktoren die Objekte, mit denen Links von Webseiten mit extrahiert werden scrapy.http.ResponseObjekte. In Scrapy gibt es eingebaute Extraktoren wiescrapy.linkextractors importieren LinkExtractor. Sie können Ihren eigenen Link-Extraktor an Ihre Bedürfnisse anpassen, indem Sie eine einfache Schnittstelle implementieren.
Jeder Link-Extraktor hat eine öffentliche Methode namens extract_linksDies enthält ein Antwortobjekt und gibt eine Liste von Scrapy.link.Link-Objekten zurück. Sie können die Link-Extraktoren nur einmal instanziieren und die Methode extract_links mehrmals aufrufen, um Links mit unterschiedlichen Antworten zu extrahieren. Die CrawlSpider-Klasse verwendet Link-Extraktoren mit einer Reihe von Regeln, deren Hauptzweck darin besteht, Links zu extrahieren.
Referenz für den integrierten Link-Extraktor
Normalerweise werden Link-Extraktoren mit Scrapy gruppiert und im Scrapy.linkextractors-Modul bereitgestellt. Standardmäßig ist der Link-Extraktor LinkExtractor, dessen Funktionalität der von LxmlLinkExtractor entspricht.
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)
Der LxmlLinkExtractor ist ein sehr empfehlenswerter Link-Extraktor, da er über praktische Filteroptionen verfügt und mit dem robusten HTMLParser von lxml verwendet wird.
Sr.Nr. | Parameter & Beschreibung |
---|---|
1 | allow (ein regulärer Ausdruck (oder eine Liste von)) Es ermöglicht einen einzelnen Ausdruck oder eine Gruppe von Ausdrücken, die mit der zu extrahierenden URL übereinstimmen sollen. Wenn es nicht erwähnt wird, stimmt es mit allen Links überein. |
2 | deny (ein regulärer Ausdruck (oder eine Liste von)) Es blockiert oder schließt einen einzelnen Ausdruck oder eine Gruppe von Ausdrücken aus, die mit der URL übereinstimmen sollen, die nicht extrahiert werden soll. Wenn es nicht erwähnt oder leer gelassen wird, werden die unerwünschten Links nicht entfernt. |
3 | allow_domains (str oder Liste) Es ermöglicht eine einzelne Zeichenfolge oder Liste von Zeichenfolgen, die mit den Domänen übereinstimmen sollen, aus denen die Links extrahiert werden sollen. |
4 | deny_domains (str oder Liste) Es blockiert oder schließt eine einzelne Zeichenfolge oder Liste von Zeichenfolgen aus, die mit den Domänen übereinstimmen sollen, aus denen die Links nicht extrahiert werden sollen. |
5 | deny_extensions (Liste) Es blockiert die Liste der Zeichenfolgen mit den Erweiterungen beim Extrahieren der Links. Wenn es nicht festgelegt ist, wird es standardmäßig auf IGNORED_EXTENSIONS festgelegt, das eine vordefinierte Liste im Paketrapy.linkextractors enthält . |
6 | restrict_xpaths (str oder Liste) Es ist ein XPath-Listenbereich, aus dem die Links aus der Antwort extrahiert werden sollen. Wenn angegeben, werden die Links nur aus dem von XPath ausgewählten Text extrahiert. |
7 | restrict_css (str oder Liste) Es verhält sich ähnlich wie der Parameter Restrict_xpaths, der die Links aus den CSS-ausgewählten Regionen innerhalb der Antwort extrahiert. |
8 | tags (str oder Liste) Ein einzelnes Tag oder eine Liste von Tags, die beim Extrahieren der Links berücksichtigt werden sollten. Standardmäßig ist dies ('a', 'area'). |
9 | attrs (Liste) Beim Extrahieren von Links sollte ein einzelnes Attribut oder eine Liste von Attributen berücksichtigt werden. Standardmäßig ist es ('href',). |
10 | canonicalize (Boolescher Wert) Die extrahierte URL wird mithilfe vonrapy.utils.url.canonicalize_url in die Standardform gebracht . Standardmäßig ist es True. |
11 | unique (Boolescher Wert) Es wird verwendet, wenn die extrahierten Links wiederholt werden. |
12 | process_value (abrufbar) Es ist eine Funktion, die einen Wert von gescannten Tags und Attributen erhält. Der empfangene Wert kann geändert und zurückgegeben werden, oder es wird nichts zurückgegeben, um den Link abzulehnen. Wenn nicht verwendet, ist es standardmäßig Lambda x: x. |
Beispiel
Der folgende Code wird verwendet, um die Links zu extrahieren -
<a href = "javascript:goToPage('../other/page.html'); return false">Link text</a>
Die folgende Codefunktion kann in process_value verwendet werden -
def process_value(val):
m = re.search("javascript:goToPage\('(.*?)'", val)
if m:
return m.group(1)
Beschreibung
Das Verhalten von Scrapy-Komponenten kann mithilfe der Scrapy-Einstellungen geändert werden. Die Einstellungen können auch das aktuell aktive Scrapy-Projekt auswählen, falls Sie mehrere Scrapy-Projekte haben.
Einstellungen festlegen
Sie müssen Scrapy mitteilen, welche Einstellung Sie beim Verschrotten einer Website verwenden. Hierfür UmgebungsvariableSCRAPY_SETTINGS_MODULE sollte verwendet werden und sein Wert sollte in der Python-Pfadsyntax sein.
Auffüllen der Einstellungen
Die folgende Tabelle zeigt einige der Mechanismen, mit denen Sie die Einstellungen auffüllen können -
Sr.Nr. | Mechanismus & Beschreibung |
---|---|
1 | Command line options Hier haben die übergebenen Argumente höchste Priorität, indem andere Optionen überschrieben werden. Das -s wird verwendet, um eine oder mehrere Einstellungen zu überschreiben. |
2 | Settings per-spider Spinnen können ihre eigenen Einstellungen haben, die die Projekteinstellungen überschreiben, indem sie das Attribut custom_settings verwenden. |
3 | Project settings module Hier können Sie Ihre benutzerdefinierten Einstellungen wie das Hinzufügen oder Ändern der Einstellungen in der Datei settings.py auffüllen. |
4 | Default settings per-command Jeder Scrapy-Tool-Befehl definiert seine eigenen Einstellungen im Attribut default_settings, um die globalen Standardeinstellungen zu überschreiben. |
5 | Default global settings Diese Einstellungen finden Sie im Modulrapy.settings.default_settings. |
Zugriffseinstellungen
Sie sind über self.settings verfügbar und werden nach der Initialisierung in der Basisspinne festgelegt.
Das folgende Beispiel zeigt dies.
class DemoSpider(scrapy.Spider):
name = 'demo'
start_urls = ['http://example.com']
def parse(self, response):
print("Existing settings: %s" % self.settings.attributes.keys())
Um Einstellungen vor dem Initialisieren der Spinne zu verwenden, müssen Sie die Methode from_crawler in der Methode _init_ () Ihrer Spinne überschreiben . Sie können auf Einstellungen über das Attribut Scrapy.crawler.Crawler.settings zugreifen, das an die Methode from_crawler übergeben wird.
Das folgende Beispiel zeigt dies.
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'))
Begründung für das Festlegen von Namen
Einstellungsnamen werden der von ihnen konfigurierten Komponente als Präfix hinzugefügt. Für die Erweiterung robots.txt können die Einstellungsnamen beispielsweise ROBOTSTXT_ENABLED, ROBOTSTXT_OBEY, ROBOTSTXT_CACHEDIR usw. sein.
Referenz für integrierte Einstellungen
Die folgende Tabelle zeigt die integrierten Einstellungen von Scrapy -
Sr.Nr. | Einstellung & Beschreibung |
---|---|
1 | AWS_ACCESS_KEY_ID Es wird verwendet, um auf Amazon Web Services zuzugreifen. Standardwert: Keine |
2 | AWS_SECRET_ACCESS_KEY Es wird verwendet, um auf Amazon Web Services zuzugreifen. Standardwert: Keine |
3 | BOT_NAME Dies ist der Name des Bots, der zum Erstellen des User-Agent verwendet werden kann. Standardwert: 'Scrapybot' |
4 | CONCURRENT_ITEMS Maximale Anzahl vorhandener Elemente im Elementprozessor, die zur parallelen Verarbeitung verwendet werden. Standardwert: 100 |
5 | CONCURRENT_REQUESTS Maximale Anzahl vorhandener Anforderungen, die der Scrapy-Downloader ausführt. Standardwert: 16 |
6 | CONCURRENT_REQUESTS_PER_DOMAIN Maximale Anzahl vorhandener Anforderungen, die gleichzeitig für eine einzelne Domäne ausgeführt werden. Standardwert: 8 |
7 | CONCURRENT_REQUESTS_PER_IP Maximale Anzahl vorhandener Anforderungen, die gleichzeitig für eine einzelne IP ausgeführt werden. Standardwert: 0 |
8 | DEFAULT_ITEM_CLASS Es ist eine Klasse, die zur Darstellung von Elementen verwendet wird. Standardwert:'rapy.item.Item ' |
9 | DEFAULT_REQUEST_HEADERS Dies ist ein Standardheader, der für HTTP-Anforderungen von Scrapy verwendet wird. Standardwert - |
10 | DEPTH_LIMIT Die maximale Tiefe, in der eine Spinne eine Site crawlen kann. Standardwert: 0 |
11 | DEPTH_PRIORITY Es ist eine Ganzzahl, die verwendet wird, um die Priorität der Anforderung entsprechend der Tiefe zu ändern. Standardwert: 0 |
12 | DEPTH_STATS Es gibt an, ob Tiefenstatistiken gesammelt werden sollen oder nicht. Standardwert: True |
13 | DEPTH_STATS_VERBOSE Wenn diese Einstellung aktiviert ist, wird die Anzahl der Anforderungen in Statistiken für jede ausführliche Tiefe erfasst. Standardwert: False |
14 | DNSCACHE_ENABLED Es wird verwendet, um DNS im Speichercache zu aktivieren. Standardwert: True |
15 | DNSCACHE_SIZE Es definiert die Größe des DNS im Speichercache. Standardwert: 10000 |
16 | DNS_TIMEOUT Es wird verwendet, um das Zeitlimit für DNS festzulegen, um die Abfragen zu verarbeiten. Standardwert: 60 |
17 | DOWNLOADER Es ist ein Downloader, der für den Crawling-Prozess verwendet wird. Standardwert:'rapy.core.downloader.Downloader ' |
18 | DOWNLOADER_MIDDLEWARES Es ist ein Wörterbuch, das die Downloader-Middleware und ihre Bestellungen enthält. Standardwert: {} |
19 | DOWNLOADER_MIDDLEWARES_BASE Es ist ein Wörterbuch mit Downloader-Middleware, das standardmäßig aktiviert ist. Standardwert - |
20 | DOWNLOADER_STATS Diese Einstellung wird verwendet, um die Downloader-Statistiken zu aktivieren. Standardwert: True |
21 | DOWNLOAD_DELAY Es definiert die Gesamtzeit für den Downloader, bevor die Seiten von der Site heruntergeladen werden. Standardwert: 0 |
22 | DOWNLOAD_HANDLERS Es ist ein Wörterbuch mit Download-Handlern. Standardwert: {} |
23 | DOWNLOAD_HANDLERS_BASE Es ist ein Wörterbuch mit Download-Handlern, das standardmäßig aktiviert ist. Standardwert - |
24 | DOWNLOAD_TIMEOUT Es ist die Gesamtzeit, die der Downloader warten muss, bevor das Zeitlimit überschritten wird. Standardwert: 180 |
25 | DOWNLOAD_MAXSIZE Dies ist die maximale Antwortgröße, die der Downloader herunterladen kann. Standardwert: 1073741824 (1024 MB) |
26 | DOWNLOAD_WARNSIZE Es definiert die Größe der Antwort, die der Downloader warnen soll. Standardwert: 33554432 (32 MB) |
27 | DUPEFILTER_CLASS Diese Klasse wird zum Erkennen und Filtern von doppelten Anforderungen verwendet. Standardwert:'rapy.dupefilters.RFPDupeFilter ' |
28 | DUPEFILTER_DEBUG Diese Einstellung protokolliert alle doppelten Filter, wenn sie auf true gesetzt sind. Standardwert: False |
29 | EDITOR Es wird verwendet, um Spinnen mit dem Befehl edit zu bearbeiten. Standardwert: Abhängig von der Umgebung |
30 | EXTENSIONS Es ist ein Wörterbuch mit Erweiterungen, die im Projekt aktiviert sind. Standardwert: {} |
31 | EXTENSIONS_BASE Es ist ein Wörterbuch mit integrierten Erweiterungen. Standardwert: {'rapy.extensions.corestats.CoreStats ': 0,} |
32 | FEED_TEMPDIR In diesem Verzeichnis wird der benutzerdefinierte Ordner festgelegt, in dem temporäre Crawler-Dateien gespeichert werden können. |
33 | ITEM_PIPELINES Es ist ein Wörterbuch mit Pipelines. Standardwert: {} |
34 | LOG_ENABLED Es definiert, ob die Protokollierung aktiviert werden soll. Standardwert: True |
35 | LOG_ENCODING Es definiert die Art der Codierung, die für die Protokollierung verwendet werden soll. Standardwert: 'utf-8' |
36 | LOG_FILE Dies ist der Name der Datei, die für die Ausgabe der Protokollierung verwendet werden soll. Standardwert: Keine |
37 | LOG_FORMAT Es ist eine Zeichenfolge, mit der die Protokollnachrichten formatiert werden können. Standardwert: '% (asctime) s [% (name) s]% (levelname) s:% (message) s' |
38 | LOG_DATEFORMAT Es ist eine Zeichenfolge, mit der Datum und Uhrzeit formatiert werden können. Standardwert: '% Y-% m-% d% H:% M:% S' |
39 | LOG_LEVEL Es definiert die minimale Protokollstufe. Standardwert: 'DEBUG' |
40 | LOG_STDOUT Wenn diese Einstellung auf true gesetzt ist, werden alle Ihre Prozessausgaben im Protokoll angezeigt. Standardwert: False |
41 | MEMDEBUG_ENABLED Es definiert, ob das Speicher-Debugging aktiviert werden soll. Standardwert: False |
42 | MEMDEBUG_NOTIFY Es definiert den Speicherbericht, der an eine bestimmte Adresse gesendet wird, wenn das Speicher-Debugging aktiviert ist. Standardwert: [] |
43 | MEMUSAGE_ENABLED Es definiert, ob die Speichernutzung aktiviert werden soll, wenn ein Scrapy-Prozess ein Speicherlimit überschreitet. Standardwert: False |
44 | MEMUSAGE_LIMIT_MB Es definiert die maximale Grenze für den zulässigen Speicher (in Megabyte). Standardwert: 0 |
45 | MEMUSAGE_CHECK_INTERVAL_SECONDS Es wird verwendet, um die aktuelle Speichernutzung durch Einstellen der Länge der Intervalle zu überprüfen. Standardwert: 60.0 |
46 | MEMUSAGE_NOTIFY_MAIL Es wird verwendet, um mit einer Liste von E-Mails zu benachrichtigen, wenn der Speicher das Limit erreicht. Standardwert: False |
47 | MEMUSAGE_REPORT Es definiert, ob der Speicherauslastungsbericht beim Schließen jeder Spinne gesendet werden soll. Standardwert: False |
48 | MEMUSAGE_WARNING_MB Es definiert einen Gesamtspeicher, der zulässig sein soll, bevor eine Warnung gesendet wird. Standardwert: 0 |
49 | NEWSPIDER_MODULE Es ist ein Modul, in dem eine neue Spinne mit dem Befehl genspider erstellt wird. Standardwert: '' |
50 | RANDOMIZE_DOWNLOAD_DELAY Es definiert eine zufällige Wartezeit für einen Scrapy, während er die Anforderungen von der Site herunterlädt. Standardwert: True |
51 | REACTOR_THREADPOOL_MAXSIZE Es definiert eine maximale Größe für den Reaktor-Threadpool. Standardwert: 10 |
52 | REDIRECT_MAX_TIMES Es definiert, wie oft eine Anfrage umgeleitet werden kann. Standardwert: 20 |
53 | REDIRECT_PRIORITY_ADJUST Wenn diese Einstellung festgelegt ist, wird die Umleitungspriorität einer Anforderung angepasst. Standardwert: +2 |
54 | RETRY_PRIORITY_ADJUST Wenn diese Einstellung festgelegt ist, wird die Wiederholungspriorität einer Anforderung angepasst. Standardwert: -1 |
55 | ROBOTSTXT_OBEY Scrapy befolgt die Richtlinien von robots.txt, wenn true festgelegt ist . Standardwert: False |
56 | SCHEDULER Es definiert den Scheduler, der für Crawling-Zwecke verwendet werden soll. Standardwert:'rapy.core.scheduler.Scheduler ' |
57 | SPIDER_CONTRACTS Es ist ein Wörterbuch im Projekt mit Spinnenverträgen zum Testen der Spinnen. Standardwert: {} |
58 | SPIDER_CONTRACTS_BASE Es ist ein Wörterbuch mit Scrapy-Verträgen, das in Scrapy standardmäßig aktiviert ist. Standardwert - |
59 | SPIDER_LOADER_CLASS Es definiert eine Klasse, die die SpiderLoader-API implementiert, um Spider zu laden. Standardwert:'rapy.spiderloader.SpiderLoader ' |
60 | SPIDER_MIDDLEWARES Es ist ein Wörterbuch mit Spinnen-Middlewares. Standardwert: {} |
61 | SPIDER_MIDDLEWARES_BASE Es ist ein Wörterbuch mit Spider Middleware, das in Scrapy standardmäßig aktiviert ist. Standardwert - |
62 | SPIDER_MODULES Es ist eine Liste von Modulen mit Spinnen, nach denen Scrapy suchen wird. Standardwert: [] |
63 | STATS_CLASS Es ist eine Klasse, die die Stats Collector- API implementiert , um Statistiken zu sammeln. Standardwert:'rapy.statscollectors.MemoryStatsCollector ' |
64 | STATS_DUMP Wenn diese Einstellung auf true gesetzt ist, werden die Statistiken im Protokoll gespeichert. Standardwert: True |
65 | STATSMAILER_RCPTS Sobald die Spinnen mit dem Schaben fertig sind, verwendet Scrapy diese Einstellung, um die Statistiken zu senden. Standardwert: [] |
66 | TELNETCONSOLE_ENABLED Es definiert, ob die Telnetconsole aktiviert werden soll. Standardwert: True |
67 | TELNETCONSOLE_PORT Es definiert einen Port für die Telnet-Konsole. Standardwert: [6023, 6073] |
68 | TEMPLATES_DIR Es ist ein Verzeichnis mit Vorlagen, die beim Erstellen neuer Projekte verwendet werden können. Standardwert: Vorlagenverzeichnis im Scrapy-Modul |
69 | URLLENGTH_LIMIT Es definiert die maximale Länge der URL, die für gecrawlte URLs zulässig ist. Standardwert: 2083 |
70 | USER_AGENT Es definiert den Benutzeragenten, der beim Crawlen einer Site verwendet werden soll. Standardwert: "Scrapy / VERSION (+ http: //scrapy.org)" |
Weitere Scrapy-Einstellungen finden Sie unter diesem Link .
Beschreibung
Die unregelmäßigen Ereignisse werden als Ausnahmen bezeichnet. In Scrapy werden Ausnahmen aufgrund von Gründen wie fehlender Konfiguration, Löschen von Elementen aus der Elementpipeline usw. ausgelöst. Nachfolgend finden Sie eine Liste der in Scrapy genannten Ausnahmen und deren Anwendung.
Gegenstand fallen lassen
Item Pipeline verwendet diese Ausnahme, um die Verarbeitung des Elements zu jedem Zeitpunkt zu stoppen. Es kann geschrieben werden als -
exception (scrapy.exceptions.DropItem)
CloseSpider
Diese Ausnahme wird verwendet, um die Spinne mithilfe der Rückrufanforderung zu stoppen. Es kann geschrieben werden als -
exception (scrapy.exceptions.CloseSpider)(reason = 'cancelled')
Es enthält einen Parameter namens reason (str), der den Grund für das Schließen angibt.
Der folgende Code zeigt beispielsweise die Verwendung dieser Ausnahme:
def parse_page(self, response):
if 'Bandwidth exceeded' in response.body:
raise CloseSpider('bandwidth_exceeded')
IgnoreRequest
Diese Ausnahme wird von der Scheduler- oder Downloader-Middleware verwendet, um eine Anforderung zu ignorieren. Es kann geschrieben werden als -
exception (scrapy.exceptions.IgnoreRequest)
Nicht konfiguriert
Es weist auf eine fehlende Konfigurationssituation hin und sollte in einem Komponentenkonstruktor ausgelöst werden.
exception (scrapy.exceptions.NotConfigured)
Diese Ausnahme kann ausgelöst werden, wenn eine der folgenden Komponenten deaktiviert ist.
- Extensions
- Artikel-Pipelines
- Downloader Middleware
- Spinnen-Middleware
Nicht unterstützt
Diese Ausnahme wird ausgelöst, wenn eine Funktion oder Methode nicht unterstützt wird. Es kann geschrieben werden als -
exception (scrapy.exceptions.NotSupported)
Beschreibung
Um die Daten von Webseiten zu entfernen, müssen Sie zuerst das Scrapy-Projekt erstellen, in dem Sie den Code speichern. Führen Sie den folgenden Befehl aus, um ein neues Verzeichnis zu erstellen:
scrapy startproject first_scrapy
Der obige Code erstellt ein Verzeichnis mit dem Namen first_scrapy und enthält die folgende Struktur:
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
Beschreibung
Elemente sind die Container, die zum Sammeln der Daten verwendet werden, die von den Websites verschrottet werden. Sie müssen Ihre Spinne starten, indem Sie Ihren Gegenstand definieren. Bearbeiten Sie Elemente, um sie zu definierenitems.py Datei unter Verzeichnis gefunden first_scrapy(benutzerdefiniertes Verzeichnis). Die items.py sieht wie folgt aus:
import scrapy
class First_scrapyItem(scrapy.Item):
# define the fields for your item here like:
# name = scrapy.Field()
Die MyItem- Klasse erbt von Item, das eine Reihe vordefinierter Objekte enthält, die Scrapy bereits für uns erstellt hat. Wenn Sie beispielsweise den Namen, die URL und die Beschreibung aus den Sites extrahieren möchten, müssen Sie die Felder für jedes dieser drei Attribute definieren.
Fügen wir also die Gegenstände hinzu, die wir sammeln möchten -
from scrapy.item import Item, Field
class First_scrapyItem(scrapy.Item):
name = scrapy.Field()
url = scrapy.Field()
desc = scrapy.Field()
Beschreibung
Spider ist eine Klasse, die die anfängliche URL definiert, aus der die Daten extrahiert werden sollen, wie Paginierungslinks zu folgen sind und wie die in der Definition definierten Felder extrahiert und analysiert werden items.py. Scrapy bietet verschiedene Arten von Spinnen, von denen jede einen bestimmten Zweck erfüllt.
Erstellen Sie eine Datei mit dem Namen "first_spider.py"im Verzeichnis first_scrapy / spiders, wo wir Scrapy mitteilen können, wie die genauen Daten zu finden sind, nach denen wir suchen. Dazu müssen Sie einige Attribute definieren -
name - Es definiert den eindeutigen Namen für die Spinne.
allowed_domains - Es enthält die Basis-URLs, die die Spinne crawlen soll.
start-urls - Eine Liste von URLs, von denen aus die Spinne zu kriechen beginnt.
parse() - Es ist eine Methode, die die kratzenden Daten extrahiert und analysiert.
Der folgende Code zeigt, wie ein Spinnencode aussieht -
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] + '.html'
with open(filename, 'wb') as f:
f.write(response.body)
Beschreibung
Führen Sie den folgenden Befehl in Ihrem Verzeichnis first_scrapy aus, um Ihre Spinne auszuführen :
scrapy crawl first
Wo, first ist der Name der Spinne, die beim Erstellen der Spinne angegeben wurde.
Sobald die Spinne kriecht, sehen Sie die folgende Ausgabe:
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)
Wie Sie in der Ausgabe sehen können, gibt es für jede URL eine Protokollzeile, die (Verweis: Keine) angibt, dass die URLs Start-URLs sind und keine Verweise haben. Als Nächstes sollten zwei neue Dateien mit den Namen Books.html und Resources.html in Ihrem Verzeichnis first_scrapy erstellt werden .
Beschreibung
Zum Extrahieren von Daten von Webseiten verwendet Scrapy eine Technik namens Selektoren, die auf XPath- und CSS- Ausdrücken basiert . Im Folgenden finden Sie einige Beispiele für XPath-Ausdrücke:
/html/head/title - Dadurch wird das <title> -Element im <head> -Element eines HTML-Dokuments ausgewählt.
/html/head/title/text() - Dadurch wird der Text innerhalb desselben <title> -Elements ausgewählt.
//td - Dadurch werden alle Elemente aus <td> ausgewählt.
//div[@class = "slice"]- Dadurch werden alle Elemente aus div ausgewählt , die eine Attributklasse = "Slice" enthalten.
Selektoren haben vier grundlegende Methoden, wie in der folgenden Tabelle gezeigt -
Sr.Nr. | Methode & Beschreibung |
---|---|
1 | extract() Es gibt eine Unicode-Zeichenfolge zusammen mit den ausgewählten Daten zurück. |
2 | re() Es gibt eine Liste von Unicode-Zeichenfolgen zurück, die extrahiert wurden, als der reguläre Ausdruck als Argument angegeben wurde. |
3 | xpath() Es wird eine Liste von Selektoren zurückgegeben, die die Knoten darstellt, die durch den als Argument angegebenen xpath-Ausdruck ausgewählt wurden. |
4 | css() Es wird eine Liste von Selektoren zurückgegeben, die die Knoten darstellt, die durch den als Argument angegebenen CSS-Ausdruck ausgewählt wurden. |
Verwenden von Selektoren in der Shell
Um die Selektoren mit der integrierten Scrapy-Shell zu demonstrieren, muss IPython auf Ihrem System installiert sein. Wichtig hierbei ist, dass die URLs in die Anführungszeichen aufgenommen werden, während Scrapy ausgeführt wird. Andernfalls funktionieren die URLs mit den Zeichen '&' nicht. Sie können eine Shell mit dem folgenden Befehl im Verzeichnis der obersten Ebene des Projekts starten:
scrapy shell "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/"
Eine Shell sieht folgendermaßen aus:
[ ... 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]:
Wenn die Shell geladen wird, können Sie mithilfe von response.body bzw. response.header auf den Body oder den Header zugreifen . Ebenso können Sie Abfragen für die Antwort mit response.selector.xpath () oder response.selector.css () ausführen .
Zum Beispiel -
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']
Daten extrahieren
Um Daten von einer normalen HTML-Site zu extrahieren, müssen wir den Quellcode der Site überprüfen, um XPaths zu erhalten. Nach der Überprüfung können Sie sehen, dass sich die Daten in der befindenulEtikett. Wählen Sie die Elemente ausli Etikett.
Die folgenden Codezeilen zeigen die Extraktion verschiedener Datentypen -
Zur Auswahl von Daten innerhalb von li tag -
response.xpath('//ul/li')
Zur Auswahl von Beschreibungen -
response.xpath('//ul/li/text()').extract()
Zur Auswahl von Site-Titeln -
response.xpath('//ul/li/a/text()').extract()
Zur Auswahl von Site-Links -
response.xpath('//ul/li/a/@href').extract()
Der folgende Code demonstriert die Verwendung der oben genannten Extraktoren -
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
Beschreibung
ItemObjekte sind die regulären Diktate von Python. Wir können die folgende Syntax verwenden, um auf die Attribute der Klasse zuzugreifen:
>>> item = DmozItem()
>>> item['title'] = 'sample title'
>>> item['title']
'sample title'
Fügen Sie den obigen Code zum folgenden Beispiel hinzu:
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
Die Ausgabe der obigen Spinne wird -
[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']}
Beschreibung
In diesem Kapitel erfahren Sie, wie Sie die Links der Seiten unseres Interesses extrahieren, ihnen folgen und Daten von dieser Seite extrahieren. Dazu müssen wir die folgenden Änderungen in unserem vorherigen Code wie folgt vornehmen :
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
Der obige Code enthält die folgenden Methoden:
parse() - Es werden die Links von unserem Interesse extrahiert.
response.urljoin - Die parse () -Methode verwendet diese Methode, um eine neue URL zu erstellen und eine neue Anforderung bereitzustellen, die später an den Rückruf gesendet wird.
parse_dir_contents() - Dies ist ein Rückruf, der die interessierenden Daten tatsächlich abkratzt.
Hier verwendet Scrapy einen Rückrufmechanismus, um Links zu folgen. Mit diesem Mechanismus kann der größere Crawler entworfen werden und Links von Interesse folgen, um die gewünschten Daten von verschiedenen Seiten zu entfernen. Die reguläre Methode ist die Rückrufmethode, mit der die Elemente extrahiert, nach Links gesucht werden, die der nächsten Seite folgen, und dann eine Anforderung für denselben Rückruf bereitgestellt wird.
Das folgende Beispiel erzeugt eine Schleife, die den Links zur nächsten Seite folgt.
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)
Beschreibung
Der beste Weg zum Speichern von Scraped-Daten ist die Verwendung von Feed-Exporten, mit denen sichergestellt wird, dass Daten in mehreren Serialisierungsformaten ordnungsgemäß gespeichert werden. JSON, JSON-Zeilen, CSV, XML sind die Formate, die in Serialisierungsformaten problemlos unterstützt werden. Die Daten können mit dem folgenden Befehl gespeichert werden:
scrapy crawl dmoz -o data.json
Dieser Befehl erstellt eine data.jsonDatei mit Scraped-Daten in JSON. Diese Technik gilt für kleine Datenmengen. Wenn große Datenmengen verarbeitet werden müssen, können wir die Item-Pipeline verwenden. Genau wie bei der Datei data.json wird beim Erstellen des Projekts eine reservierte Datei eingerichtettutorial/pipelines.py.
Beschreibung
Loggingbedeutet die Verfolgung von Ereignissen, die ein integriertes Protokollierungssystem verwendet und Funktionen und Klassen zum Implementieren von Anwendungen und Bibliotheken definiert. Die Protokollierung ist ein gebrauchsfertiges Material, das mit den in den Protokollierungseinstellungen aufgeführten Scrapy-Einstellungen arbeiten kann.
Scrapy legt einige Standardeinstellungen fest und verarbeitet diese Einstellungen mithilfe von Scrapy.utils.log.configure_logging (), wenn Befehle ausgeführt werden.
Protokollebenen
In Python gibt es fünf verschiedene Schweregrade für eine Protokollnachricht. Die folgende Liste zeigt die Standardprotokollnachrichten in aufsteigender Reihenfolge -
logging.DEBUG - zum Debuggen von Nachrichten (niedrigster Schweregrad)
logging.INFO - für Informationsnachrichten
logging.WARNING - für Warnmeldungen
logging.ERROR - für regelmäßige Fehler
logging.CRITICAL - für kritische Fehler (höchste Schwere)
So protokollieren Sie Nachrichten
Der folgende Code zeigt das Protokollieren einer Nachricht mit logging.info Niveau.
import logging
logging.info("This is an information")
Die obige Protokollierungsnachricht kann mit als Argument übergeben werden logging.log wie folgt gezeigt -
import logging
logging.log(logging.INFO, "This is an information")
Jetzt können Sie auch Logger verwenden, um die Nachricht mithilfe der Protokollierungshilfe einzuschließen, um die Protokollierungsnachricht wie folgt deutlich anzuzeigen:
import logging
logger = logging.getLogger()
logger.info("This is an information")
Es können mehrere Logger vorhanden sein, auf die zugegriffen werden kann, indem ihre Namen mithilfe von abgerufen werden logging.getLogger Funktion wie folgt dargestellt.
import logging
logger = logging.getLogger('mycustomlogger')
logger.info("This is an information")
Ein angepasster Logger kann für jedes Modul verwendet werden, indem die Variable __name__ verwendet wird, die den folgenden Modulpfad enthält:
import logging
logger = logging.getLogger(__name__)
logger.info("This is an information")
Protokollierung von Spinnen
Jede Spinneninstanz hat eine logger darin und kann wie folgt verwendet werden -
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)
Im obigen Code wird der Logger unter Verwendung des Spider-Namens erstellt. Sie können jedoch jeden von Python bereitgestellten benutzerdefinierten Logger verwenden, wie im folgenden Code gezeigt.
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)
Protokollierungskonfiguration
Logger können von ihnen gesendete Nachrichten nicht selbst anzeigen. Daher benötigen sie "Handler" zum Anzeigen dieser Nachrichten, und Handler leiten diese Nachrichten an ihre jeweiligen Ziele wie Dateien, E-Mails und Standardausgaben um.
Abhängig von den folgenden Einstellungen konfiguriert Scrapy den Handler für den Logger.
Protokollierungseinstellungen
Die folgenden Einstellungen werden zum Konfigurieren der Protokollierung verwendet:
Das LOG_FILE und LOG_ENABLED Legen Sie das Ziel für Protokollnachrichten fest.
Wenn Sie die einstellen LOG_ENCODING Bei false werden die Protokollausgabemeldungen nicht angezeigt.
Das LOG_LEVELbestimmt die Schweregradreihenfolge der Nachricht; Nachrichten mit geringerem Schweregrad werden herausgefiltert.
Das LOG_FORMAT und LOG_DATEFORMAT werden verwendet, um die Layouts für alle Nachrichten anzugeben.
Wenn Sie die einstellen LOG_STDOUT Um wahr zu sein, werden alle Standardausgabe- und Fehlermeldungen Ihres Prozesses in das Protokoll umgeleitet.
Befehlszeilenoptionen
Scrapy-Einstellungen können überschrieben werden, indem Befehlszeilenargumente übergeben werden (siehe folgende Tabelle).
Sr.Nr. | Befehl & Beschreibung |
---|---|
1 | --logfile FILE Überschreibungen LOG_FILE |
2 | --loglevel/-L LEVEL Überschreibungen LOG_LEVEL |
3 | --nolog Setzt LOG_ENABLED auf False |
Scrapy.utils.log-Modul
Diese Funktion kann verwendet werden, um die Protokollierungsstandards für Scrapy zu initialisieren.
scrapy.utils.log.configure_logging(settings = None, install_root_handler = True)
Sr.Nr. | Parameter & Beschreibung |
---|---|
1 | settings (dict, None) Es erstellt und konfiguriert den Handler für den Root-Logger. Standardmäßig ist es Keine . |
2 | install_root_handler (bool) Es gibt an, dass der Root-Protokollierungshandler installiert werden soll. Standardmäßig ist es True . |
Die obige Funktion -
- Leitet Warnungen und verdrehte Protokollierungen über die Python-Standardprotokollierung weiter.
- Weist DEBUG den Scrapy- und ERROR-Level Twisted Loggern zu.
- Leitet stdout zum Protokollieren, wenn die Einstellung LOG_STDOUT wahr ist.
Standardoptionen können mit der Option überschrieben werden settingsStreit. Wenn keine Einstellungen angegeben sind, werden die Standardeinstellungen verwendet. Der Handler kann für den Root-Logger erstellt werden, wenn install_root_handler auf true gesetzt ist. Wenn false festgelegt ist, wird keine Protokollausgabe festgelegt. Bei Verwendung von Scrapy-Befehlen wird configure_logging automatisch aufgerufen und kann explizit ausgeführt werden, während die benutzerdefinierten Skripts ausgeführt werden.
Sie können die Protokollausgabe manuell konfigurieren logging.basicConfig() wie folgt gezeigt -
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
)
Beschreibung
Stats Collector ist eine von Scrapy bereitgestellte Funktion zum Sammeln der Statistiken in Form von Schlüsseln / Werten. Der Zugriff erfolgt über die Crawler-API (Crawler bietet Zugriff auf alle Scrapy-Kernkomponenten). Der Statistiksammler stellt eine Statistik-Tabelle pro Spinne bereit, in der der Statistiksammler automatisch geöffnet wird, wenn sich die Spinne öffnet, und den Statistiksammler schließt, wenn die Spinne geschlossen ist.
Allgemeine Verwendung für Statistiksammler
Der folgende Code greift mit auf den Statistikkollektor zu stats Attribut.
class ExtensionThatAccessStats(object):
def __init__(self, stats):
self.stats = stats
@classmethod
def from_crawler(cls, crawler):
return cls(crawler.stats)
Die folgende Tabelle zeigt verschiedene Optionen, die mit dem Statistiksammler verwendet werden können.
Sr.Nr. | Parameter | Beschreibung |
---|---|---|
1 | |
Es wird verwendet, um den Statistikwert festzulegen. |
2 | |
Es erhöht den stat-Wert. |
3 | |
Sie können den stat-Wert nur festlegen, wenn er größer als der vorherige Wert ist. |
4 | |
Sie können den stat-Wert nur einstellen, wenn er niedriger als der vorherige Wert ist. |
5 | |
Es ruft den stat-Wert ab. |
6 | |
Es ruft alle Statistiken ab |
Verfügbare Statistiksammler
Scrapy bietet verschiedene Arten von Statistiksammlern, auf die mit dem zugegriffen werden kann STATS_CLASS Rahmen.
MemoryStatsCollector
Es ist der Standard-Statistiksammler, der die Statistiken aller Spinnen verwaltet, die zum Scraping verwendet wurden, und die Daten werden im Speicher gespeichert.
class scrapy.statscollectors.MemoryStatsCollector
DummyStatsCollector
Dieser Statistiksammler ist sehr effizient und macht nichts. Dies kann mit der Einstellung STATS_CLASS festgelegt und zum Deaktivieren der Statistiksammlung verwendet werden, um die Leistung zu verbessern.
class scrapy.statscollectors.DummyStatsCollector
Beschreibung
Scrapy kann E-Mails über seine eigene Funktion senden, die als Twisted Non-Blocking IO bezeichnet wird und sich von nicht blockierenden IO des Crawlers fernhält. Sie können die wenigen Einstellungen für das Senden von E-Mails konfigurieren und eine einfache API zum Senden von Anhängen bereitstellen.
Es gibt zwei Möglichkeiten, den MailSender zu instanziieren, wie in der folgenden Tabelle gezeigt:
Sr.Nr. | Parameter | Methode |
---|---|---|
1 | aus Scrapy.mail importieren MailSender mailer = MailSender () | Mit einem Standardkonstruktor. |
2 | mailer = MailSender.from_settings (Einstellungen) | Durch Verwendung des Scrapy-Einstellungsobjekts. |
Die folgende Zeile sendet eine E-Mail ohne Anhänge -
mailer.send(to = ["[email protected]"], subject = "subject data", body = "body data",
cc = ["[email protected]"])
MailSender-Klassenreferenz
Die MailSender-Klasse verwendet Twisted Non-Blocking IO zum Senden von E-Mails von Scrapy.
class scrapy.mail.MailSender(smtphost = None, mailfrom = None, smtpuser = None,
smtppass = None, smtpport = None)
Die folgende Tabelle zeigt die in der MailSender- Klasse verwendeten Parameter -
Sr.Nr. | Parameter & Beschreibung |
---|---|
1 | smtphost (str) Der SMTP-Host wird zum Senden der E-Mails verwendet. Wenn nicht, wird die Einstellung MAIL_HOST verwendet. |
2 | mailfrom (str) Die Adresse des Empfängers wird zum Senden der E-Mails verwendet. Wenn nicht, wird die Einstellung MAIL_FROM verwendet. |
3 | smtpuser Es gibt den SMTP-Benutzer an. Wenn es nicht verwendet wird, wird die Einstellung MAIL_USER verwendet und es findet keine SMTP-Validierung statt, wenn dies nicht erwähnt wird. |
4 | smtppass (str) Es gibt den SMTP-Pass für die Validierung an. |
5 | smtpport (int) Es gibt den SMTP-Port für die Verbindung an. |
6 | smtptls (boolean) Es implementiert die Verwendung von SMTP STARTTLS. |
7 | smtpssl (boolean) Es wird über eine sichere SSL-Verbindung verwaltet. |
Die folgenden zwei Methoden sind in der angegebenen MailSender-Klassenreferenz enthalten. Erste Methode,
classmethod from_settings(settings)
Es wird mithilfe des Scrapy-Einstellungsobjekts integriert. Es enthält den folgenden Parameter -
settings (scrapy.settings.Settings object) - Es wird als E-Mail-Empfänger behandelt.
Eine andere Methode,
send(to, subject, body, cc = None, attachs = (), mimetype = 'text/plain', charset = None)
Die folgende Tabelle enthält die Parameter der obigen Methode -
Sr.Nr. | Parameter & Beschreibung |
---|---|
1 | to (list) Es bezieht sich auf den E-Mail-Empfänger. |
2 | subject (str) Es gibt den Betreff der E-Mail an. |
3 | cc (list) Es bezieht sich auf die Liste der Empfänger. |
4 | body (str) Es bezieht sich auf E-Mail-Körperdaten. |
5 | attachs (iterable) Es bezieht sich auf den Anhang der E-Mail, den Mimetyp des Anhangs und den Namen des Anhangs. |
6 | mimetype (str) Es repräsentiert den MIME-Typ der E-Mail. |
7 | charset (str) Es gibt die Zeichenkodierung an, die für E-Mail-Inhalte verwendet wird. |
Mail-Einstellungen
Die folgenden Einstellungen stellen sicher, dass wir ohne Schreiben von Code eine E-Mail mithilfe der MailSender-Klasse im Projekt konfigurieren können.
Sr.Nr. | Einstellungen & Beschreibung | Standardwert |
---|---|---|
1 | MAIL_FROM Es bezieht sich auf Absender-E-Mails zum Senden von E-Mails. |
'Scrapy @ Localhost' |
2 | MAIL_HOST Es bezieht sich auf den SMTP-Host, der zum Senden von E-Mails verwendet wird. |
'localhost' |
3 | MAIL_PORT Es gibt den SMTP-Port an, der zum Senden von E-Mails verwendet werden soll. |
25 |
4 | MAIL_USER Es bezieht sich auf die SMTP-Validierung. Es erfolgt keine Validierung, wenn diese Einstellung deaktiviert ist. |
Keiner |
5 | MAIL_PASS Es enthält das Kennwort für die SMTP-Validierung. |
Keiner |
6 | MAIL_TLS Es bietet die Möglichkeit, eine unsichere Verbindung mithilfe von SSL / TLS auf eine sichere Verbindung zu aktualisieren. |
Falsch |
7 | MAIL_SSL Es implementiert die Verbindung über eine SSL-verschlüsselte Verbindung. |
Falsch |
Beschreibung
Die Telnet-Konsole ist eine Python-Shell, die im Scrapy-Prozess ausgeführt wird und zur Überprüfung und Steuerung eines Scrapy-Ausführungsprozesses verwendet wird.
Greifen Sie auf die Telnet-Konsole zu
Auf die Telnet-Konsole kann mit dem folgenden Befehl zugegriffen werden:
telnet localhost 6023
Grundsätzlich ist die Telnet-Konsole im TCP-Port aufgeführt, der in beschrieben wird TELNETCONSOLE_PORT die Einstellungen.
Variablen
Einige der in der folgenden Tabelle angegebenen Standardvariablen werden als Verknüpfungen verwendet.
Sr.Nr. | Verknüpfung & Beschreibung |
---|---|
1 | crawler Dies bezieht sich auf das Objekt Scrapy Crawler (Scrapy.crawler.Crawler). |
2 | engine Dies bezieht sich auf das Crawler.engine-Attribut. |
3 | spider Dies bezieht sich auf die Spinne, die aktiv ist. |
4 | slot Dies bezieht sich auf den Motorschlitz. |
5 | extensions Dies bezieht sich auf das Attribut Extension Manager (Crawler.extensions). |
6 | stats Dies bezieht sich auf das Attribut Stats Collector (Crawler.stats). |
7 | setting Dies bezieht sich auf das Attribut Scrapy-Einstellungsobjekt (Crawler.settings). |
8 | est Dies bezieht sich auf das Drucken eines Berichts über den Motorstatus. |
9 | prefs Dies bezieht sich auf den Speicher zum Debuggen. |
10 | p Dies bezieht sich auf eine Verknüpfung zur Funktion pprint.pprint . |
11 | hpy Dies bezieht sich auf das Speicher-Debugging. |
Beispiele
Im Folgenden finden Sie einige Beispiele für die Verwendung der Telnet-Konsole.
Halten Sie die Scrapy Engine an, setzen Sie sie fort und stoppen Sie sie
Verwenden Sie den folgenden Befehl, um die Scrapy-Engine anzuhalten:
telnet localhost 6023
>>> engine.pause()
>>>
Verwenden Sie den folgenden Befehl, um die Scrapy-Engine fortzusetzen:
telnet localhost 6023
>>> engine.unpause()
>>>
Verwenden Sie den folgenden Befehl, um die Scrapy-Engine zu stoppen:
telnet localhost 6023
>>> engine.stop()
Connection closed by foreign host.
Motorstatus anzeigen
Telnet-Konsole verwendet est() Methode zum Überprüfen des Status der Scrapy-Engine wie im folgenden Code gezeigt -
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-Konsolensignale
Mit den Telnet-Konsolensignalen können Sie die Variablen im lokalen Telnet-Namespace hinzufügen, aktualisieren oder löschen. Um diese Aktion auszuführen, müssen Sie das Diktat telnet_vars in Ihrem Handler hinzufügen.
scrapy.extensions.telnet.update_telnet_vars(telnet_vars)
Parameter -
telnet_vars (dict)
Dabei ist dict ein Wörterbuch, das Telnet-Variablen enthält.
Telnet-Einstellungen
Die folgende Tabelle zeigt die Einstellungen, die das Verhalten der Telnet-Konsole steuern.
Sr.Nr. | Einstellungen & Beschreibung | Standardwert |
---|---|---|
1 | TELNETCONSOLE_PORT Dies bezieht sich auf den Portbereich für die Telnet-Konsole. Wenn es auf none gesetzt ist, wird der Port dynamisch zugewiesen. |
[6023, 6073] |
2 | TELNETCONSOLE_HOST Dies bezieht sich auf die Schnittstelle, über die die Telnet-Konsole lauschen soll. |
'127.0.0.1' |
Beschreibung
Ein laufender Scrapy-Webcrawler kann über gesteuert werden JSON-RPC. Es wird durch die Einstellung JSONRPC_ENABLED aktiviert. Dieser Dienst bietet über das JSON-RPC 2.0- Protokoll Zugriff auf das Haupt -Crawlerobjekt . Der Endpunkt für den Zugriff auf das Crawler-Objekt ist -
http://localhost:6080/crawler
Die folgende Tabelle enthält einige Einstellungen, die das Verhalten des Webdienstes anzeigen.
Sr.Nr. | Einstellung & Beschreibung | Standardwert |
---|---|---|
1 | JSONRPC_ENABLED Dies bezieht sich auf den Booleschen Wert, der entscheidet, ob der Webdienst zusammen mit seiner Erweiterung aktiviert wird oder nicht. |
Wahr |
2 | JSONRPC_LOGFILE Dies bezieht sich auf die Datei, die zum Protokollieren von HTTP-Anforderungen an den Webdienst verwendet wird. Wenn es nicht festgelegt ist, wird das Standard-Scrapy-Protokoll verwendet. |
Keiner |
3 | JSONRPC_PORT Dies bezieht sich auf den Portbereich für den Webdienst. Wenn es auf none gesetzt ist, wird der Port dynamisch zugewiesen. |
[6080, 7030] |
4 | JSONRPC_HOST Dies bezieht sich auf die Schnittstelle, die der Webdienst abhören soll. |
'127.0.0.1' |