Web-Scraping mit Scrapy: Der einfache Weg

Mihai Maxim am 30. Januar 2023

Web-Scraping mit Scrapy

Scrapy ist eine leistungsstarke Python-Bibliothek zum Extrahieren von Daten aus Websites. Sie ist schnell, effizient und einfach zu benutzen - glauben Sie mir, ich habe es selbst erlebt. Egal, ob Sie ein Datenwissenschaftler, ein Entwickler oder jemand sind, der gerne mit Daten spielt, Scrapy hat Ihnen etwas zu bieten. Und das Beste ist, es ist kostenlos und Open Source.

Scrapy-Projekte werden mit einer Dateistruktur geliefert, die Ihnen hilft, Ihren Code und Ihre Daten zu organisieren. Das macht es einfacher, Web Scraper zu erstellen und zu pflegen. Es ist also definitiv eine Überlegung wert, wenn Sie ernsthaftes Web Scraping betreiben wollen. Web Scraping mit Scrapy Es ist, als hätten Sie einen hilfreichen Assistenten (wenn auch einen virtuellen) an Ihrer Seite, wenn Sie sich auf die Reise der Datenextraktion begeben.

Was wir bauen werden

Wenn man eine neue Fähigkeit erlernt, ist es eine Sache, darüber zu lesen, und eine andere, sie tatsächlich zu tun. Deshalb haben wir beschlossen, gemeinsam einen Scraper zu bauen, während wir diesen Leitfaden durchgehen. Das ist der beste Weg, um ein praktisches Verständnis dafür zu bekommen, wie Web Scraping mit Scrapy funktioniert.

Was werden wir also genau bauen? Wir werden einen Scraper bauen, der Wortdefinitionen von der Urban Dictionary-Website abgreift. Das ist ein lustiges Ziel für Scraper und wird helfen, den Lernprozess angenehmer zu gestalten. Unser Scraper wird einfach sein - er wird die Definitionen für verschiedene Wörter zurückgeben, die auf der Urban Dictionary Website gefunden wurden. Wir werden die in Scrapy eingebaute Unterstützung für das Auswählen und Extrahieren von Daten aus HTML-Dokumenten verwenden, um die benötigten Definitionen herauszuziehen.

Fangen wir also an! Im nächsten Abschnitt gehen wir auf die Voraussetzungen ein, die Sie für die Teilnahme an diesem Lernprogramm benötigen. Wir sehen uns dort!

Voraussetzungen

Bevor wir mit dem Aufbau unseres Scrapers beginnen, müssen Sie einige Dinge einrichten. In diesem Abschnitt wird beschrieben, wie man Scrapy installiert und eine virtuelle Umgebung für unser Projekt einrichtet. In der Scrapy-Dokumentation wird empfohlen, Scrapy in einer eigenen virtuellen Umgebung zu installieren. Auf diese Weise vermeiden Sie Konflikte mit Ihren Systempaketen.

Ich bin mit Scrapy auf Ubuntu 22.04.1 WSL (Windows Subsystem für Linux), so werde ich eine virtuelle Umgebung für meine Maschine zu konfigurieren.

Ich empfehle Ihnen, das Kapitel "Verstehen der Ordnerstruktur" durchzuarbeiten, um die Werkzeuge, mit denen wir arbeiten, vollständig zu verstehen. Werfen Sie auch einen Blick auf das Kapitel "Scrapy Shell", es wird Ihre Entwicklungserfahrung um einiges erleichtern.

Einrichten einer virtuellen Python-Umgebung

Um eine virtuelle Umgebung für Python in Ubuntu einzurichten, können Sie den Befehl mkvirtualenv verwenden. Stellen Sie zunächst sicher, dass Sie virtualenv und virtualenvwrapper installiert haben:

$ sudo apt-get install virtualenv virtualenvwrapper

Fügen Sie diese Zeilen am Ende Ihrer .bashrc-Datei hinzu:

export WORKON_HOME=$HOME/.virtualenvs

export PROJECT_HOME=$HOME/Deve

export VIRTUALENVWRAPPER_PYTHON='/usr/bin/python3'

source /usr/local/bin/virtualenvwrapper.sh

Ich habe Vim zum Bearbeiten der Datei verwendet, aber Sie können jeden beliebigen Editor verwenden:

vim ~/.bashrc

// Verwenden Sie ctr + i, um in den Einfügemodus zu gelangen, verwenden Sie den Pfeil nach unten, um zum Ende der Datei zu scrollen.

// Fügen Sie die Zeilen am Ende der Datei ein.

// Drücken Sie escape, um den Einfügemodus zu verlassen, geben Sie wq ein und drücken Sie enter, um die Änderungen zu speichern und Vim zu beenden.

Erstellen Sie dann eine neue virtuelle Umgebung mit mkvirtualenv:

$ mkvirtualenv scrapy_env

Jetzt sollten Sie ein (scrapy_env) am Anfang Ihrer Terminalzeile sehen.

Um die virtuelle Umgebung zu verlassen, geben Sie $ deactivate ein

Um zur virtuellen Umgebung scrappy_env zurückzukehren, geben Sie $ workon scrapy_env ein

Installieren von Scrapy

Sie können Scrapy mit dem Pip-Paketmanager installieren:

$ pip install scrapy

Dadurch wird die neueste Version von Scrapy installiert.

Sie können ein neues Projekt mit dem Befehl scrapy startproject erstellen:

$ scrapy startproject myproject

Dadurch wird ein neues Scrapy-Projekt mit dem Namen "myproject" initialisiert. Es sollte die Standard-Projektstruktur enthalten.

Verstehen der Ordnerstruktur

Dies ist die Standard-Projektstruktur:

myproject

├── myproject

│ ├── __init__.py

│ ├── items.py

│ ├── middlewares.py

│ ├── pipelines.py

│ ├── settings.py

│ └── spiders

│ └── __init__.py

└── scrapy.cfg

artikel.py

items.py ist ein Modell für die extrahierten Daten. Dieses Modell wird verwendet, um die Daten zu speichern, die Sie von der Website extrahieren.

Beispiel:

import scrapy

class Product(scrapy.Item):

 name = scrapy.Field()

 price = scrapy.Field()

 description = scrapy.Field()

Hier haben wir ein Element namens Produkt definiert. Es kann von einem Spider (siehe /spiders) verwendet werden, um Informationen über den Namen, den Preis und die Beschreibung eines Produkts zu speichern.

/Spinnen

/spiders ist ein Ordner, der Spider-Klassen enthält. In Scrapy sind Spider Klassen, die definieren, wie eine Website gescannt werden soll.

Beispiel:

import scrapy

from myproject.items import Product

class MySpider(scrapy.Spider):

    name = 'myspider'

    start_urls = ['<example_website_url>']

    

    def parse(self, response):

        # Extract the data for each product

        for product_div in response.css('div.product'):

            product = Product()

            product['name'] = product_div.css('h3.name::text').get()

            product['price'] = product_div.css('span.price::text').get()

            product['description'] = product_div.css('p.description::text').get()

            yield product

Der "Spider" durchläuft die start_urls, extrahiert den Namen, den Preis und die Beschreibung aller auf den Seiten gefundenen Produkte (unter Verwendung von css-Selektoren) und speichert die Daten in der Datei Product Item (siehe items.py). Anschließend werden diese Elemente "ausgegeben", was Scrapy veranlasst, sie an die nächste Komponente in der Pipeline weiterzuleiten (siehe pipelines.py).

Yield ist ein Schlüsselwort in Python, mit dem eine Funktion einen Wert zurückgeben kann, ohne die Funktion zu beenden. Stattdessen erzeugt es den Wert und unterbricht die Ausführung der Funktion, bis der nächste Wert angefordert wird.

Zum Beispiel:

def count_up_to(max):

    count = 1

    while count <= max:

        yield count

        count += 1

for number in count_up_to(5):

    print(number)

// returns 1 2 3 4 5 (each on a new line)  

pipelines.py

Pipelines sind für die Verarbeitung der Elemente (siehe items.py und /spiders) zuständig, die von den Spidern extrahiert werden. Sie können sie verwenden, um den HTML-Code zu bereinigen, die Daten zu validieren und sie in ein benutzerdefiniertes Format zu exportieren oder in einer Datenbank zu speichern.

Beispiel:

import pymongo

class MongoPipeline(object):

 def __init__(self):

 self.conn = pymongo.MongoClient('localhost', 27017)

 self.db = self.conn['mydatabase']

 self.product_collection = self.db['products']

 self.other_collection = self.db['other']

        

 def process_item(self, item, spider):

 if spider.name == 'product_spider':

           //Eintrag in die product_collection

 elif spider.name == 'other_spider':

           //Eintrag in die andere_Kollektion

 return item

Wir haben eine Pipeline namens MongoPipeline erstellt. Sie stellt eine Verbindung zu zwei MongoDB-Sammlungen her (product_collection und other_collection). Die Pipeline empfängt Elemente (siehe items.py) von Spidern (siehe /spiders) und verarbeitet sie mit der Funktion process_item. In diesem Beispiel fügt die Funktion process_item die Elemente zu den entsprechenden Sammlungen hinzu.

einstellungen.py

settings.py speichert eine Vielzahl von Einstellungen, die das Verhalten des Scrapy-Projekts steuern, wie z.B. die Pipelines, Middlewares und Erweiterungen, die verwendet werden sollen, sowie Einstellungen, die sich darauf beziehen, wie das Projekt Anfragen und Antworten behandeln soll.

Sie können damit zum Beispiel die Reihenfolge der Ausführung der Pipelines festlegen (siehe pipelines.py):

ITEM_PIPELINES = {

    'myproject.pipelines.MongoPipeline': 300,

    'myproject.pipelines.JsonPipeline': 302,

}

// MongoPipeline will execute before JsonPipeline, because it has a lower order number(300)

Oder setzen Sie einen Exportcontainer:

FEEDS = {

    'items': {'uri': 'file:///tmp/items.json', 'format': 'json'},

}

// this will save the scraped data to a items.json

scrappy.cfg

scrapy.cfg ist die Konfigurationsdatei für die wichtigsten Einstellungen des Projekts.

[settings] 

default = [Name des Projekts].settings 

[deploy] 

#url = http://localhost:6800/ 

project = [Name des Projekts]

middlewares.py

Es gibt zwei Arten von Middlewares in Scrapy: Downloader-Middlewares und Spider-Middlewares.

Downloader-Middlewares sind Komponenten, die verwendet werden können, um Anfragen und Antworten zu modifizieren, Fehler zu behandeln und eine eigene Download-Logik zu implementieren. Sie befinden sich zwischen dem Spider und dem Scrapy-Downloader.

Spider-Middlewares sind Komponenten, die zur Implementierung benutzerdefinierter Verarbeitungslogik verwendet werden können. Sie befinden sich zwischen der Engine und dem Spider.

Die Schrottschalen

Bevor wir uns auf die spannende Reise der Implementierung unseres Urban Dictionary Scrapers begeben, sollten wir uns zunächst mit der Scrapy Shell vertraut machen. Diese interaktive Konsole ermöglicht es uns, unsere Scraping-Logik zu testen und die Ergebnisse in Echtzeit zu sehen. Es ist wie ein virtueller Sandkasten, in dem wir herumspielen und unseren Ansatz verfeinern können, bevor wir unseren Spider auf das Web loslassen. Glauben Sie mir, das spart Ihnen auf lange Sicht viel Zeit und Kopfschmerzen. Lassen Sie uns also etwas Spaß haben und die Scrapy Shell kennenlernen.

Öffnen der Schale

Um die Scrapy-Shell zu öffnen, müssen Sie zunächst in Ihrem Terminal in das Verzeichnis Ihres Scrapy-Projekts navigieren. Dann können Sie einfach den folgenden Befehl ausführen:

Schrottkiste

Dadurch wird die Scrapy-Shell geöffnet und Sie erhalten eine Eingabeaufforderung, in der Sie Scrapy-Befehle eingeben und ausführen können. Sie können auch eine URL als Argument an den Shell-Befehl übergeben, um direkt eine Webseite zu scrapen, etwa so:

scrapy shell <url>

Zum Beispiel:

scrapy shell https://www.urbandictionary.com/define.php?term=YOLO

Gibt (im Antwortobjekt) die HTML-Datei der Webseite zurück, die die Definition des Wortes YOLO (im Urban Dictionary) enthält.

Alternativ können Sie nach dem Aufrufen der Shell auch den Befehl fetch verwenden, um eine Webseite abzurufen.

fetch('https://www.urbandictionary.com/define.php?term=YOLO')

Sie können die Shell auch mit dem Parameter nolog starten, damit sie keine Protokolle anzeigt:

scrapy shell --nolog

Arbeiten mit der Shell

In diesem Beispiel habe ich die URL "https://www.urbandictionary.com/define.php?term=YOLO" abgerufen und die HTML-Datei in der Datei test_output.html gespeichert.

(scrapy_env) mihai@DESKTOP-0RN92KH:~/myproject$ scrapy shell --nolog

[s] Available Scrapy objects:

[s]   scrapy     scrapy module (contains scrapy.Request, scrapy.Selector, etc)

[s]   crawler    <scrapy.crawler.Crawler object at 0x7f1eef80f6a0>

[s]   item       {}

[s]   settings   <scrapy.settings.Settings object at 0x7f1eef80f4c0>

[s] Useful shortcuts:

[s]   fetch(url[, redirect=True]) Fetch URL and update local objects (by default, redirects are followed)

[s]   fetch(req)                  Fetch a scrapy.Request and update local objects

[s]   shelp()           Shell help (print this help)

[s]   view(response)    View response in a browser

>>> response // response is empty

>>> fetch('https://www.urbandictionary.com/define.php?term=YOLO')

>>> response

<200 https://www.urbandictionary.com/define.php?term=Yolo>

>>> with open('test_output.html', 'w') as f:

...      f.write(response.text)

...

118260

Schauen wir uns nun test_output.html an und identifizieren die Selektoren, die wir benötigen, um die Daten für unseren Urban Dictionary Scraper zu extrahieren.

Das können wir beobachten:

• Jeder Wortdefinitionscontainer hat die Klasse "Definition".
• Die Bedeutung des Wortes befindet sich innerhalb des div mit der Klasse "meaning".
• Beispiele für das Wort finden sich innerhalb des div mit der Klasse "example".
• Die Informationen über den Autor und das Datum des Beitrags befinden sich in einem Div mit der Klasse "contributor".

Nun wollen wir einige Selektoren in der Scrapy Shell testen:

Um Verweise auf jeden Definitionscontainer zu erhalten, können wir CSS- oder XPath-Selektoren verwenden:

Mehr über XPath-Selektoren können Sie hier erfahren: https://www.webscrapingapi.com/the-ultimate-xpath-cheat-sheet

Definitionen = response.css('div.definition')

Definitionen = response.xpath('//div[enthält(@class, "Definition")]')

Wir sollten die Bedeutung, das Beispiel und die Post-Informationen aus jedem Definitionscontainer extrahieren. Lassen Sie uns einige Selektoren mit dem ersten Container testen:

>>> first_def = definitions[0]

>>> meaning = first_def.css('div.meaning').xpath(".//text()").extract()

>>> meaning

['Yolo ', 'bedeutet', ', '', 'Man lebt nur einmal', ''.']

>>> meaning = "".join(meaning)

>>> meaning

'Yolo bedeutet, 'Man lebt nur einmal'.'

>>> example = first_def.css('div.example').xpath(".//text()").extract()

>>> example = "".join(example)

>>> example

'"Legen Sie Ihren Sicherheitsgurt an." Jessica sagte.\r "HAH, YOLO!" Antwortet Anna.\r(Dann haben sie einen Autounfall. Lange Rede kurzer Sinn...Schnall dich an.)'

>>> post_data = first_def.css('div.contributor').xpath(".//text()").extract()

>>> post_data

['by ', 'Soy ugly', ' April 24, 2019']

Durch die Verwendung der Scrapy-Shell konnten wir schnell einen allgemeinen Selektor finden, der unseren Anforderungen entspricht.

definition.css('div.<meaning|example|contributor>').xpath(".//text()").extract() 

// returns an array with all the text found inside the <meaning|example|contributor>

ex: ['Yolo ', 'means', ', '', 'You Only Live Once', ''.']

Um mehr über Scrapy-Selektoren zu erfahren, lesen Sie die Dokumentation. https://docs.scrapy.org/en/latest/topics/selectors.html

Implementierung des Urban Dictionary Scrapers

Gute Arbeit! Nun, da Sie den Dreh mit der Scrapy Shell raus haben und das Innenleben eines Scrapy-Projekts verstehen, ist es an der Zeit, in die Implementierung unseres Urban Dictionary Scrapers einzutauchen. Inzwischen sollten Sie sich sicher fühlen und bereit sein, die Aufgabe zu übernehmen, all diese lustigen (und manchmal fragwürdigen) Wortdefinitionen aus dem Web zu extrahieren. Fangen wir also ohne Umschweife an, unseren Scraper zu bauen!

Definieren eines Artikels

Zuerst werden wir ein Item implementieren: (siehe items.py)

class UrbanDictionaryItem(scrapy.Item):

 Bedeutung = scrapy.Feld()

 Autor = scrapy.Feld()

 Datum = scrapy.Feld()

 Beispiel = scrapy.Feld()

Diese Struktur enthält die aus dem Spider ausgelesenen Daten.

Definieren einer Spinne

So werden wir unseren Spider definieren (siehe /spiders):

importieren scrapy

from ..items import UrbanDictionaryItem

Klasse UrbanDictionarySpider(scrapy.Spider):

name = 'urban_dictionary'

start_urls = ['https://www.urbandictionary.com/define.php?term=Yolo']

def parse(self, response):

Definitionen = response.css('div.definition')

für Definition in Definitionen:

item = UrbanDictionaryItem()

item['Bedeutung'] = definition.css('div.Bedeutung').xpath(".//text()").extract()

item['example'] = definition.css('div.example').xpath(".//text()").extract()

author = definition.css('div.contributor').xpath(".//text()").extract()

item['date'] = author[2]

item['autor'] = autor[1]

Ertragsposition

Um den urban_dictionary spider auszuführen, verwenden Sie den folgenden Befehl:

scrapy crawl urban_dictionary

// die Ergebnisse sollten in der Konsole erscheinen (höchstwahrscheinlich am Anfang der Protokolle)

Erstellen einer Pipeline

Zu diesem Zeitpunkt sind die Daten unsaniert.

{'author': 'Soy ugly',

 'date': ' April 24, 2019',

 'example': ['“Put your ',

             'seatbelt',

             ' on.” Jessica said.\n',

             '“HAH, YOLO!” Replies Anna.\n',

             '(They then proceed to have a ',

             'car crash',

             '. ',

             'Long story short',

             '...Wear a seatbelt.)'],

 'meaning': ['Yolo ', 'means', ', ‘', 'You Only Live Once', '’.']}

Wir wollen die Felder "Beispiel" und "Bedeutung" so ändern, dass sie Strings und keine Arrays enthalten. Dazu schreiben wir eine Pipeline (siehe pipelines.py), die die Arrays durch Verkettung der Wörter in Strings umwandelt.

class SanitizePipeline:

 def process_item(self, item, spider):

       # Das Feld 'Bedeutung' bereinigen

 item['Bedeutung'] = "".join(item['Bedeutung'])

 # Das Feld 'Beispiel' bereinigen

 item['Beispiel'] = "".join(item['example'])

       

 # Das Feld 'Datum' bereinigen

 item['date'] = item['date'].strip() 

 return item

 //ex: ['Yolo ', 'bedeutet', ', '', 'Man lebt nur einmal', ''.'] wird zu 

 'Yolo bedeutet, 'Man lebt nur einmal'.'

Freigabe der Pipeline

Nachdem wir die Pipeline definiert haben, müssen wir sie aktivieren. Wenn wir das nicht tun, werden unsere UrbanDictionaryItem-Objekte nicht bereinigt. Fügen Sie dazu die Pipeline zu Ihrer Datei settings.py (siehe settings.py) hinzu:

 ITEM_PIPELINES = {

     'myproject.pipelines.SanitizePipeline': 1,

 }

Wenn Sie schon dabei sind, können Sie auch eine Ausgabedatei angeben, in der die gescrapten Daten abgelegt werden sollen.

 FEEDS = {

     'items': {'uri': 'file:///tmp/items.json', 'format': 'json'},

 }

  // this will put the scraped data in an items.json file.

Optional: Implementierung einer Proxy-Middleware

Web Scraping kann ein bisschen mühsam sein. Eines der Hauptprobleme, auf das wir häufig stoßen, ist die Tatsache, dass viele Websites Javascript benötigen, um ihren Inhalt vollständig anzuzeigen. Dies kann uns als Web-Scrapern große Probleme bereiten, da unsere Tools oft nicht in der Lage sind, Javascript auszuführen, wie es ein normaler Webbrowser tut. Dies kann dazu führen, dass unvollständige Daten extrahiert werden, oder schlimmer noch, dass unsere IP-Adresse von der Website gesperrt wird, weil wir zu viele Anfragen in kurzer Zeit gestellt haben.

Unsere Lösung für dieses Problem ist WebScrapingApi. Mit unserem Service können Sie einfach Anfragen an die API stellen, und sie übernimmt die ganze Arbeit für Sie. Er führt JavaScript aus, rotiert Proxys und verarbeitet sogar CAPTCHAs, sodass Sie selbst die hartnäckigsten Websites problemlos scrapen können.

Eine Proxy-Middleware leitet jede von Scrapy gestellte Abrufanfrage an den Proxy-Server weiter. Der Proxy-Server stellt dann die Anfrage für uns und gibt das Ergebnis zurück.

Zunächst definieren wir eine ProxyMiddleware-Klasse in der Datei middlewares.py.

import base64

class ProxyMiddleware:

    def process_request(self, request, spider):

        # Set the proxy for the request

        request.meta['proxy'] = "http://proxy.webscrapingapi.com:80"

        request.meta['verify'] = False

        # Set the proxy authentication for the request

        proxy_user_pass =  "webscrapingapi.proxy_type=residential.render_js=1:<API_KEY>"

        encoded_user_pass = base64.b64encode(proxy_user_pass.encode()).decode()

        request.headers['Proxy-Authorization'] = f'Basic {encoded_user_pass}'

In diesem Beispiel haben wir den WebScrapingApi-Proxyserver verwendet.

webscrapingapi.proxy_type=residential.render_js=1 is the proxy authentication username, <API_KEY> the password.

Sie können einen kostenlosen API_KEY erhalten, indem Sie ein neues Konto auf https://www.webscrapingapi.com/ erstellen.

Nachdem wir die ProxyMiddleware definiert haben, müssen wir sie nur noch als DOWNLOAD_MIDDLEWARE in der Datei settings.py aktivieren.

DOWNLOADER_MIDDLEWARES = {

    'myproject.middlewares.ProxyMiddleware': 1,

}

Und, das war's. Wie Sie sehen, kann Web-Scraping mit Scrapy eine Menge unserer Arbeit vereinfachen.

Einpacken

Wir haben es geschafft! Wir haben einen Scraper gebaut, der Definitionen aus Urban Dictionary extrahieren kann, und wir haben dabei viel über Scrapy gelernt. Von der Erstellung benutzerdefinierter Elemente bis zur Verwendung von Middlewares und Pipelines haben wir bewiesen, wie leistungsfähig und vielseitig Web-Scraping mit Scrapy sein kann. Und das Beste daran? Es gibt noch so viel mehr zu entdecken.

Herzlichen Glückwunsch, dass Sie es bis zum Ende dieser Reise mit mir geschafft haben. Sie sollten nun zuversichtlich sein, dass Sie jedes Web-Scraping-Projekt, das auf Sie zukommt, in Angriff nehmen können. Denken Sie einfach daran, dass Web Scraping nicht entmutigend oder überwältigend sein muss. Mit den richtigen Werkzeugen und Kenntnissen kann es zu einer unterhaltsamen und lohnenden Erfahrung werden. Wenn Sie jemals eine helfende Hand benötigen, zögern Sie nicht, sich an uns zu wenden: https: //www.webscrapingapi.com/. Wir wissen alles über Web Scraping und sind mehr als glücklich, Ihnen auf jede Weise zu helfen.