Wie man einen Web Crawler mit Python erstellt - Anleitung für Anfänger

Ștefan Răcila am 11. April 2023

Beim Web-Crawling werden Webseiten automatisch besucht und nützliche Informationen aus ihnen extrahiert. Ein Web-Crawler, auch bekannt als Spider oder Bot, ist ein Programm, das diese Aufgabe übernimmt. In diesem Artikel besprechen wir, wie man einen Web-Crawler mit der Programmiersprache Python erstellt. Konkret werden wir zwei Web-Crawler erstellen.

Wir werden einen einfachen Web-Crawler von Grund auf in Python erstellen und dabei die Bibliotheken Requests und BeautifulSoup verwenden. Danach werden wir über die Vorteile der Verwendung eines Web-Crawling-Frameworks wie Scrapy sprechen. Und schließlich werden wir einen Beispiel-Crawler mit Scrapy bauen, um Daten von allen Babyprodukten von Amazon zu sammeln. Wir werden auch sehen, wie Scrapy auf Websites mit mehreren Millionen Seiten skaliert.

Voraussetzungen

Bevor Sie diesen Artikel lesen, sollten Sie ein Grundverständnis von Python haben und es auf Ihrem Computer installiert haben. Außerdem müssen Sie die Module Requests und BeautifulSoup installieren. Dies können Sie tun, indem Sie den folgenden Befehl in Ihrer Eingabeaufforderung oder Ihrem Terminal ausführen:

$ pip install requests bs4

Für den zweiten Teil dieses Artikels, in dem wir einen Beispiel-Webcrawler mit Scrapy erstellen, müssen Sie das Scrapy-Framework installieren. Die Entwickler dieses Frameworks empfehlen dringend, Scrapy in einer eigenen virtuellen Umgebung zu installieren, um Konflikte mit Ihren Systempaketen zu vermeiden.

Ich empfehle Ihnen, virtualenv und virtualenvwrapper zu installieren, um eine isolierte Python-Umgebung zu schaffen. Bitte beachten Sie, dass es eine Version von virtualenvwrapper für Windows namens virtualenvwrapper-win gibt.

Sie müssen auch pipx über pip installieren, um virtualenv zu installieren.

$ python -m pip install --user pipx

$ python -m pipx ensurepath

Nachdem Sie eine isolierte Python-Umgebung erstellt haben, können Sie Scrapy mit dem folgenden Befehl installieren.

$ pip install Scrapy

Die Installationsanleitung für Scrapy finden Sie hier.

Was ist ein Webcrawler?

Web Crawling und Web Scraping sind verwandte, aber unterschiedliche Konzepte. Web Scraping ist der allgemeine Prozess der Extraktion von Daten aus einer Website. Web Crawling ist die spezifische Aufgabe, automatisch durch Webseiten zu navigieren, um die URLs zu finden, die gescraped werden müssen.

Ein Web-Crawler beginnt mit einer Liste von URLs, die er ansteuert, dem so genannten Seed. Beim Durchlaufen der einzelnen URLs durchsucht er den HTML-Code nach Links und filtert sie nach bestimmten Kriterien. Alle neu gefundenen Links werden zur weiteren Verarbeitung in eine Warteschlange gestellt. Das extrahierte HTML oder die angegebenen Informationen werden dann zur weiteren Verarbeitung an eine andere Pipeline weitergegeben.

Bei der Erstellung eines Web-Crawlers ist es wichtig zu bedenken, dass nicht alle Seiten einer Website besucht werden. Die Anzahl der besuchten Seiten hängt vom Budget des Crawlers, von der Tiefe des Crawlings oder von der für die Ausführung vorgesehenen Zeit ab.

Viele Websites haben eine robots.txt-Datei, die angibt, welche Teile der Website gecrawlt werden können und welche vermieden werden sollten. Zusätzlich haben einige Websites eine sitemap.xml, die expliziter ist als die robots.txt und Bots ausdrücklich anweist, welche Seiten gecrawlt werden sollen, und zusätzliche Metadaten für jede URL liefert.

Web-Crawler werden in der Regel für eine Vielzahl von Zwecken eingesetzt:

• SEO-Analysetools erfassen Metadaten wie Antwortzeit und Antwortstatus sowie HTML, um fehlerhafte Seiten und Links zwischen verschiedenen Domains zu erkennen und Backlinks zu sammeln.
• Preisüberwachungsprogramme durchforsten E-Commerce-Websites, um Produktseiten zu finden und Metadaten, insbesondere Preise, zu extrahieren. Die Produktseiten werden dann in regelmäßigen Abständen überprüft.
• Suchmaschinen wie Googlebot, Bingbot und Yandex Bot sammeln den gesamten HTML-Code für einen großen Teil des Internets und verwenden die Daten, um ihn durchsuchbar zu machen.

Im weiteren Verlauf dieses Artikels werden wir zwei verschiedene Ansätze zur Erstellung eines Web-Crawlers in Python vergleichen. Der erste Ansatz ist die Verwendung der Requests-Bibliothek für HTTP-Anfragen und BeautifulSoup für das Parsen von HTML-Inhalten. Der zweite Ansatz ist die Verwendung eines Web-Crawling-Frameworks. Wir werden Scrapy verwenden.

Verwendung von Requests und BeautifulSoup-Bibliotheken

Das Modul requests in Python ist ein leistungsfähiges Werkzeug für HTTP-Anfragen. Um es für das Web-Crawling zu verwenden, können Sie damit beginnen, das Modul zu importieren und eine Anfrage an eine bestimmte URL zu stellen. Zum Beispiel:

url = 'https://amazon.com/s?k=baby+Produkte'

response = requests.get(url)

Sobald Sie die Antwort haben, können Sie mit BeautifulSoup alle Links aus dem HTML-Inhalt extrahieren. Zum Beispiel:

import json

from urllib.parse import urljoin

from bs4 import BeautifulSoup

html = response.text

links = []

soup = BeautifulSoup(html, 'html.parser')

for link in soup.find_all('a'):

 path = link.get('href')

 if path and path.startswith('/'):

 path = urljoin(url, path)

   

 links.append(path)

print(json.dumps(links, sort_keys = True, indent = 2))

Sie können dann die Links durchgehen und Anfragen an sie stellen, bis Sie alle Seiten besucht haben, die Sie crawlen wollen. Dies ist eine rekursive Funktion, die genau so funktioniert:

import requests

from urllib.parse import urljoin

from bs4 import BeautifulSoup

import logging

logging.basicConfig(

    format='%(asctime)s %(levelname)s:%(message)s',

    level=logging.INFO)

url = 'https://amazon.com/s?k=baby+products'

visited = []

def crawl(url):

    logging.info(f'Crawling: {url}')

    visited.append(url)

    html = ''

    try:

        html = requests.get(url).text

    except Exception:

        logging.exception(f'Failed to crawl: {url}')

        return

        

    soup = BeautifulSoup(html, 'html.parser')

    # here you can extract and store useful data from the page

    for link in soup.find_all('a'):

        path = link.get('href')

        if path and path.startswith('/'):

            path = urljoin(url, path)

        

        if path not in visited:

            crawl(path)

crawl(url)

Die Funktion protokolliert eine Zeile für jede besuchte URL.

2023-01-16 09:20:51,681 INFO:Crawling: https://amazon.com/s?k=baby+products

2023-01-16 09:20:53,053 INFO:Crawling: https://amazon.com/ref=cs_503_logo

2023-01-16 09:20:54,195 INFO:Crawling: https://amazon.com/ref=cs_503_link

2023-01-16 09:20:55,131 INFO:Crawling: https://amazon.com/dogsofamazon/ref=cs_503_d

2023-01-16 09:20:56,549 INFO:Crawling: https://www.amazon.com/ref=nodl_?nodl_android

2023-01-16 09:20:57,071 INFO:Crawling: https://www.amazon.com/ref=cs_503_logo

2023-01-16 09:20:57,690 INFO:Crawling: https://www.amazon.com/ref=cs_503_link

2023-01-16 09:20:57,943 INFO:Crawling: https://www.amazon.com/dogsofamazon/ref=cs_503_d

2023-01-16 09:20:58,413 INFO:Crawling: https://www.amazon.com.au/ref=nodl_&nodl_android

2023-01-16 09:20:59,555 INFO:Crawling: None

2023-01-16 09:20:59,557 ERROR:Crawling fehlgeschlagen: Keine

Während der Code für einen einfachen Web-Crawler einfach erscheinen mag, gibt es viele Herausforderungen, die überwunden werden müssen, um eine ganze Website erfolgreich zu crawlen. Dazu gehören Themen wie:

• Der Download-URL-Logik fehlt ein Wiederholungsmechanismus, und die URL-Warteschlange ist bei einer großen Anzahl von URLs nicht sehr effizient.
• Der Crawler identifiziert sich nicht und ignoriert die robots.txt-Datei.
• Der Crawler ist langsam und unterstützt keine Parallelität. Jede URL braucht etwa eine Sekunde zum Crawlen, und der Crawler wartet auf eine Antwort, bevor er mit der nächsten URL fortfährt.
• Die Link-Extraktionslogik unterstützt nicht die Standardisierung von URLs durch Entfernen von Query-String-Parametern, behandelt keine relativen Anker-/Fragment-URLs (wie z. B. href="#anchor") und unterstützt nicht das Filtern von URLs nach Domäne oder das Herausfiltern von Anfragen an statische Dateien.

Im nächsten Abschnitt werden wir sehen, wie Scrapy diese Probleme löst und es einfach macht, die Funktionalität des Web-Crawlers für eigene Anwendungsfälle zu erweitern.

Wie man einen Web-Crawler in Python mit dem Scrapy-Framework erstellt

Scrapy ist ein leistungsfähiges Framework zur Erstellung von Webcrawlern in Python. Es bietet eine integrierte Möglichkeit, Links zu verfolgen und Informationen aus Webseiten zu extrahieren. Sie müssen ein neues Scrapy-Projekt und einen Spider erstellen, um das Verhalten Ihres Crawlers zu definieren.

Bevor Sie damit beginnen, eine Website wie Amazon zu crawlen, ist es wichtig, die robots.txt-Datei der Website zu überprüfen, um zu sehen, welche URL-Pfade erlaubt sind. Scrapy liest diese Datei automatisch und folgt ihr, wenn die Einstellung ROBOTSTXT_OBEY auf true gesetzt ist, was die Standardeinstellung für Projekte ist, die mit dem Scrapy-Befehl `startproject` erstellt wurden.

Um ein neues Scrapy-Projekt zu erstellen, müssen Sie den folgenden Befehl ausführen:

$ scrapy startproject amazon_crawler

Mit diesem Befehl wird ein Projekt mit der folgenden Struktur erzeugt:

amazon_crawler/

├── scrapy.cfg

└── amazon_crawler

 ├── __init__.py

 ├── items.py

 ├── middlewares.py

 ├── pipelines.py

 ├── settings.py

 └── spiders

 ├── __init__.py

Um einen Spider zu erstellen, verwenden Sie den Befehl `genspider` aus dem Scrapy CLI. Der Befehl hat die folgende Definition:

$ scrapy genspider [options] <name> <domain>

Um einen Spider für diesen Crawler zu erzeugen, können wir ihn ausführen:

$ cd amazon_crawler

$ scrapy genspider baby_products amazon.de

Es sollte eine Datei mit dem Namen `baby_products.py` im Ordner `spiders` erstellen und diesen Code generieren lassen:

import scrapy

class BabyProductsSpider(scrapy.Spider):

 name = 'wikipedia'

 allowed_domains = ['en.wikipedia.com']

 start_urls = ['http://en.wikipedia.com/']

 def parse(self, response):

 pass

Scrapy bietet auch eine Vielzahl von vorgefertigten Spider-Klassen, wie CrawlSpider, XMLFeedSpider, CSVFeedSpider und SitemapSpider. Die CrawlSpider-Klasse, die auf der Spider-Basisklasse aufbaut, enthält ein zusätzliches "rules"-Attribut, um zu definieren, wie durch eine Website navigiert werden soll. Jede Regel verwendet einen LinkExtractor, um zu bestimmen, welche Links von jeder Seite extrahiert werden sollen.

Für unseren Anwendungsfall sollten wir unsere Spider-Klasse von CrawlSpider erben. Wir müssen auch eine LinkExtractor-Regel erstellen, die den Crawler anweist, nur Links aus der Amazon-Paginierung zu extrahieren. Denken Sie daran, dass unser Ziel war, Daten von allen Babyprodukten von Amazon zu sammeln, also wollen wir nicht wirklich allen Links folgen, die wir auf der Seite finden.

Dann müssen wir zwei weitere Methoden in unserer Klasse erstellen, "parse_item" und "parse_product". parse_item" wird als Callback-Funktion an unsere LinkExtractor-Regel übergeben und wird bei jedem extrahierten Link aufgerufen. `parse_product` analysiert jedes Produkt... ¯\_(ツ)_/¯

from scrapy.spiders import CrawlSpider, Rule

from scrapy.linkextractors import LinkExtractor

from bs4 import BeautifulSoup

class BabyProductsSpider(CrawlSpider):

    name = 'baby_products'

    allowed_domains = ['amazon.com']

    start_urls = ['https://amazon.com/s?k=baby+products']

    rules = (

        Rule(

            LinkExtractor(

                restrict_css='.s-pagination-strip'

            ),

            callback='parse_item',

            follow=True),

        )

    def parse_item(self, response):

        soup = BeautifulSoup(response.text, 'html.parser')

        products = soup.select('div[data-component-type="s-search-result"]')

        data = []

        for product in products:

            parsed_product = self.parse_product(product)

            if (parsed_product != 'error'):

                data.append(parsed_product)

        return {

            'url': response.url,

            'data': data

        }

    def parse_product(self, product):

        try:

            link = product.select_one('a.a-text-normal')

            price = product.select_one('span.a-price > span.a-offscreen').text

            return {

                'product_url': link['href'],

                'name': link.text,

                'price': price

            }

        except:

            return 'error'

Um den Crawler zu starten, können Sie ihn ausführen:

$ scrapy crawl baby_products

Sie werden viele Protokolle in der Konsole sehen (Sie können eine Protokolldatei mit `--logfile [log_file_name]` angeben).

Ich habe Amazon Search als Beispiel verwendet, um die Grundlagen der Erstellung eines Web-Crawlers in Python zu demonstrieren. Der Crawler findet jedoch nicht viele Links, denen er folgen kann, und ist nicht auf einen bestimmten Anwendungsfall für die Daten zugeschnitten. Wenn Sie spezifische Daten aus der Amazon-Suche extrahieren möchten, können Sie unsere Amazon Product Data API verwenden. Wir haben benutzerdefinierte Parser für die Amazon-Suche, die Produkt- und die Kategorieseite erstellt, die Daten im JSON-Format zurückliefern, damit Sie sie in Ihrer Anwendung verwenden können.

Warum ist es besser, einen professionellen Scraping-Dienst zu beauftragen als einen Crawler zu verwenden?

Web-Crawling kann zwar ein nützliches Instrument für die Extraktion von Daten aus dem Internet sein, aber es kann auch zeitaufwändig und komplex in der Einrichtung sein. Außerdem kann Web Scraping gegen die Nutzungsbedingungen einiger Websites verstoßen und dazu führen, dass Ihre IP-Adresse gesperrt wird oder sogar rechtliche Schritte gegen Sie eingeleitet werden.

Professionelle Scraping-Dienste hingegen verwenden fortschrittliche Techniken und Technologien, um Anti-Scraping-Maßnahmen zu umgehen und Daten zu extrahieren, ohne entdeckt zu werden. Sie übernehmen auch die Wartung und Skalierung der Scraping-Infrastruktur, so dass Sie sich auf die Analyse und Nutzung der Daten konzentrieren können. Außerdem bieten sie ein höheres Maß an Datengenauigkeit und -vollständigkeit, da sie in der Lage sind, fortschrittlichere Anwendungsfälle der Datenextraktion zu bewältigen und Scraping-Aufträge in großem Umfang durchzuführen.

Zusammenfassung

Zusammenfassend lässt sich sagen, dass Web-Crawling zwar ein nützliches Instrument für die Extraktion von Daten aus dem Internet sein kann, aber auch zeitaufwändig und komplex in der Einrichtung sein kann. Außerdem kann Web-Crawling gegen die Nutzungsbedingungen einiger Websites verstoßen und dazu führen, dass Ihre IP-Adresse gesperrt wird oder sogar rechtliche Schritte gegen Sie eingeleitet werden. Für fortgeschrittene und umfangreiche Scraping-Aufträge ist es daher besser, einen professionellen Scraping-Dienst zu beauftragen.

Wenn Sie auf der Suche nach einer Alternative zum eigenen Crawling sind, sollten Sie WebScrapingAPI verwenden. WebScrapingAPI ist ein professioneller Web-Scraping-Service, mit dem Sie auf einfache Weise Daten aus Websites extrahieren können, ohne dass Sie einen eigenen Web-Scraper erstellen und pflegen müssen.

Es ist eine schnelle, zuverlässige und kostengünstige Lösung, die für Unternehmen jeder Größe geeignet ist.

Warum probieren Sie es nicht heute aus! Es ist kostenlos und wir haben eine 14-tägige Testversion ohne Karte.