Mit Python Amazon scrapen: So geht’s

Im Zeitalter des Internets, in dem Daten im Überfluss vorhanden sind und oft als das neue Öl gelten, ist Web Scraping wichtiger denn je und in vielen Anwendungen äußerst nützlich. Beim Web Scraping werden Informationen automatisiert von Websites extrahiert. Es wird auch als Web Harvesting oder Web Data Extraction bezeichnet. Selbst das Kopieren von Text einer Website in dein lokales System ist Web Scraping — allerdings manuell. In der Regel meint Web Scraping jedoch die automatische Extraktion mithilfe von Webcrawlern. Webcrawler sind Skripte, die über das HTTP-Protokoll auf das World Wide Web zugreifen und Daten automatisiert abrufen.

Egal ob Data Scientist, Engineer oder Analyst großer Datensätze: Die Fähigkeit, Daten aus dem Web zu extrahieren, ist Gold wert. Angenommen, du findest interessante Daten im Web, es gibt aber keinen direkten Download — dann kannst du mit Python scrapen, die Daten in ein brauchbares Format bringen und sie anschließend vielseitig weiterverwenden.

Praxisnahe Anwendungsfälle für Web Scraping sind zum Beispiel:

• Lebensläufe von Kandidat:innen mit bestimmten Kompetenzen sammeln,
• Tweets mit bestimmten Hashtags von Twitter extrahieren,
• Leadgenerierung im Marketing,
• Produktdetails und Rezensionen von E‑Commerce‑Seiten wie Amazon scrapen — der Schwerpunkt dieses Tutorials

Darüber hinaus wird Web Scraping in der Verarbeitung natürlicher Sprache (NLP) häufig eingesetzt, um Trainingsdaten für Deep‑Learning‑Modelle aus Webseiten zu gewinnen.

Bevor du loslegst: Websites wie Amazon können ihre Nutzungsbedingungen anpassen oder neue technische Beschränkungen einführen, die den Zugriff oder die Weiternutzung ihrer Inhalte betreffen. Du bist selbst dafür verantwortlich, die Nutzungsbedingungen der Website sowie die robots.txt zu prüfen, damit dein konkreter Anwendungsfall compliant ist. Richtlinien können sich ändern und Berechtigungen variieren.

Mögliche Herausforderungen beim Web Scraping

• Eine der größten Hürden sind die unterschiedlichen Seitenstrukturen. Templates variieren stark und sind oft einzigartig — dadurch ist ein generalisierbarer Ansatz über viele Websites hinweg schwierig.

• Ein weiteres Thema ist die Langlebigkeit. Da Webentwickler ihre Seiten regelmäßig überarbeiten, kannst du dich nicht dauerhaft auf einen einzigen Scraper verlassen. Selbst kleine Änderungen können das automatische Auslesen beeinträchtigen.

Um diese Herausforderungen zu adressieren, gibt es mehrere Ansätze. Einer ist, mit Continuous Integration und Delivery (CI/CD) sowie laufender Wartung zu arbeiten, da Änderungen an Websites dynamisch erfolgen.

Pragmatischer ist oft die Nutzung von Application Programming Interfaces (APIs), die viele Plattformen bereitstellen. Facebook und Twitter etwa bieten APIs speziell für Entwickler, die mit ihren Daten experimentieren oder Informationen extrahieren wollen, z. B. zu Freundesnetzwerken, um Graphen zu erstellen. Die Datenformate bei der API‑Nutzung unterscheiden sich vom klassischen Web Scraping, typischerweise JSON oder XML; beim Standard‑Scraping arbeitest du hauptsächlich mit HTML.

Was ist Beautiful Soup?

Beautiful Soup ist eine reine Python‑Bibliothek zum Extrahieren strukturierter Daten aus Websites. Sie ermöglicht das Parsen von HTML- und XML‑Dateien. Als Helfermodul interagiert sie mit HTML ähnlich wie die gängigen Developer Tools — nur oft bequemer.

• Sie spart Entwickler:innen meist Stunden oder Tage, weil sie mit beliebten Parsern wie lxml und html5lib zusammenarbeitet und idiomatische Python‑Wege zum Navigieren, Suchen und Modifizieren des Parse‑Baums bietet.

• Ein weiteres starkes Feature: Beautiful Soup konvertiert eingehende Dokumente intelligent nach Unicode und ausgehende nach UTF‑8. Du musst dich nur dann selbst um Encodings kümmern, wenn das Dokument kein Encoding angibt oder Beautiful Soup es nicht erkennen kann.

• Im Vergleich zu anderen allgemeinen Parsing- oder Scraping‑Techniken gilt es zudem als performant.

Arten von Parsern

Mehr dazu findest du hier.

Genug Theorie, oder? Installieren wir Beautiful Soup und schauen uns seine Funktionen in Python an.

Als ersten Schritt installierst du die Beautiful‑Soup‑Bibliothek im Terminal oder in JupyterLab. Am einfachsten geht das über pip — stelle also sicher, dass das pip‑Modul vorhanden ist.

!pip3 install beautifulsoup4
Bereitgestellt von

Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.7/site-packages (4.7.1)
Requirement already satisfied: soupsieve>=1.2 in /usr/local/lib/python3.7/site-packages (from beautifulsoup4) (1.9.5)
Bereitgestellt von

Benötigte Bibliotheken importieren

Importieren wir die Pakete, mit denen du Daten von der Website scrapest und anschließend mit seaborn, matplotlib und bokeh visualisierst.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
import re
import time
from datetime import datetime
import matplotlib.dates as mdates
import matplotlib.ticker as ticker
from urllib.request import urlopen
from bs4 import BeautifulSoup
import requests
Bereitgestellt von

Die Amazon-Bestseller-Bücher scrapen

Die zu scrapende URL ist: https://www.amazon.in/gp/bestsellers/books/. Den Page‑Parameter kannst du anpassen, um die Daten pro Seite abzurufen. Um alle Seiten zu erfassen, musst du zunächst die Gesamtseitenzahl ermitteln und dann über alle Seiten iterieren.

Für die Verbindung zur URL und das Abrufen des HTML‑Contents brauchst du Folgendes:

• Definiere eine get_data-Funktion, die die Seitennummer als Argument annimmt,
• Setze einen user-agent, um nicht als Scraper erkannt zu werden,
• Übergib die URL an requests.get und reiche den User‑Agent im Header mit,
• Extrahiere den Content aus requests.get,
• Scrape die gewünschte Seite und weise sie der Variable soup zu,

Als Nächstes identifizierst du den Parent-Tag, unter dem alle benötigten Daten liegen. Extrahiert werden:

• Buchtitel
• Autor
• Bewertung
• Anzahl Bewertungen
• Preis

Das folgende Bild zeigt, wo sich der Parent‑Tag befindet. Beim Hover werden alle relevanten Elemente markiert.

Analog zum Parent‑Tag musst du die Attribute für Titel, Autor, Bewertung, Anzahl Bewertungen und Preis finden. Öffne dazu die zu scrapende Seite, wähle das Element, klicke mit Rechtsklick und wähle "Inspect". So findest du gezielt die benötigten Felder im HTML, wie unten gezeigt:

Beachte: Manche Autorennamen sind bei Amazon nicht verlinkt. Dafür brauchst du einen zusätzlichen find-Aufruf. Im folgenden Code findest du verschachtelte If‑Else‑Bedingungen, um Autoren- bzw. Verlagsnamen zu extrahieren.

no_pages = 2

def get_data(pageNo):  
    headers = {"User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:66.0) Gecko/20100101 Firefox/66.0", "Accept-Encoding":"gzip, deflate", "Accept":"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", "DNT":"1","Connection":"close", "Upgrade-Insecure-Requests":"1"}

    r = requests.get('https://www.amazon.in/gp/bestsellers/books/ref=zg_bs_pg_'+str(pageNo)+'?ie=UTF8&pg='+str(pageNo), headers=headers)#, proxies=proxies)
    content = r.content
    soup = BeautifulSoup(content)
    #print(soup)

    alls = []
    for d in soup.findAll('div', attrs={'class':'a-section a-spacing-none aok-relative'}):
        #print(d)
        name = d.find('span', attrs={'class':'zg-text-center-align'})
        n = name.find_all('img', alt=True)
        #print(n[0]['alt'])
        author = d.find('a', attrs={'class':'a-size-small a-link-child'})
        rating = d.find('span', attrs={'class':'a-icon-alt'})
        users_rated = d.find('a', attrs={'class':'a-size-small a-link-normal'})
        price = d.find('span', attrs={'class':'p13n-sc-price'})

        all1=[]

        if name is not None:
            #print(n[0]['alt'])
            all1.append(n[0]['alt'])
        else:
            all1.append("unknown-product")

        if author is not None:
            #print(author.text)
            all1.append(author.text)
        elif author is None:
            author = d.find('span', attrs={'class':'a-size-small a-color-base'})
            if author is not None:
                all1.append(author.text)
            else:    
                all1.append('0')

        if rating is not None:
            #print(rating.text)
            all1.append(rating.text)
        else:
            all1.append('-1')

        if users_rated is not None:
            #print(price.text)
            all1.append(users_rated.text)
        else:
            all1.append('0')     

        if price is not None:
            #print(price.text)
            all1.append(price.text)
        else:
            all1.append('0')
        alls.append(all1)    
    return alls
Bereitgestellt von

Der folgende Code übernimmt diese Schritte:

• Ruft die Funktion get_data in einer For‑Schleife auf,
• Iteriert von 1 bis einschließlich Anzahl Seiten,
• Flacht die verschachtelte Liste auf und übergibt sie an ein DataFrame,
• Speichert das DataFrame als CSV.

results = []
for i in range(1, no_pages+1):
    results.append(get_data(i))
flatten = lambda l: [item for sublist in l for item in sublist]
df = pd.DataFrame(flatten(results),columns=['Book Name','Author','Rating','Customers_Rated', 'Price'])
df.to_csv('amazon_products.csv', index=False, encoding='utf-8')
Bereitgestellt von

CSV-Datei einlesen

Laden wir nun die eben erstellte CSV. Dieser Schritt ist optional — du kannst auch direkt mit dem DataFrame df weiterarbeiten.

df = pd.read_csv("amazon_products.csv")
Bereitgestellt von

df.shape
Bereitgestellt von

(100, 5)
Bereitgestellt von

Die Form des DataFrames zeigt: 100 Zeilen und 5 Spalten.

Lass dir die ersten 5 Zeilen des Datensatzes ausgeben.

df.head(61)
Bereitgestellt von

Lass uns etwas Vorverarbeitung für die Spalten Rating, Customers_Rated und Price machen.

• Da die Bewertungen bis 5 gehen, behältst du nur den Zahlenwert und entfernst den Rest.
• Entferne das Komma aus Customers_Rated.
• Entferne aus Price das Rupien‑Symbol und Kommata und schneide den Dezimalteil ab.
• Wandle alle drei Spalten anschließend in Integer oder Float um.

df['Rating'] = df['Rating'].apply(lambda x: x.split()[0])
Bereitgestellt von

df['Rating'] = pd.to_numeric(df['Rating'])
Bereitgestellt von

df["Price"] = df["Price"].str.replace('₹', '')
Bereitgestellt von

df["Price"] = df["Price"].str.replace(',', '')
Bereitgestellt von

df['Price'] = df['Price'].apply(lambda x: x.split('.')[0])
Bereitgestellt von

df['Price'] = df['Price'].astype(int)
Bereitgestellt von

df["Customers_Rated"] = df["Customers_Rated"].str.replace(',', '')
Bereitgestellt von

df['Customers_Rated'] = pd.to_numeric(df['Customers_Rated'], errors='ignore')
Bereitgestellt von

df.head()
Bereitgestellt von

Prüfen wir die Datentypen im DataFrame.

df.dtypes
Bereitgestellt von

Book Name           object
Author              object
Rating             float64
Customers_Rated      int64
Price                int64
dtype: object
Bereitgestellt von

Ersetze Nullwerte im DataFrame durch NaN.

df.replace(str(0), np.nan, inplace=True)
df.replace(0, np.nan, inplace=True)
Bereitgestellt von

Anzahl der NaNs im DataFrame zählen

count_nan = len(df) - df.count()
Bereitgestellt von

count_nan
Bereitgestellt von

Book Name          0
Author             6
Rating             0
Customers_Rated    0
Price              1
dtype: int64
Bereitgestellt von

Wie du siehst, fehlen bei sechs Büchern die Autorennamen, und bei einem Buch ist kein Preis angegeben. Solche Informationen sind für Autor:innen wichtig, die ihre Bücher verkaufen wollen, und sollten nicht fehlen.

Lass uns diese NaNs entfernen.

df = df.dropna()
Bereitgestellt von

Teuerstes Buch je Autor:in auf Amazon

Finden wir heraus, welche Autor:innen die teuersten Bücher haben. Visualisiert werden die Top 20.

data = df.sort_values(["Price"], axis=0, ascending=False)[:15]
Bereitgestellt von

data
Bereitgestellt von

from bokeh.models import ColumnDataSource
from bokeh.transform import dodge
import math
from bokeh.io import curdoc
curdoc().clear()
from bokeh.io import push_notebook, show, output_notebook
from bokeh.layouts import row
from bokeh.plotting import figure
from bokeh.transform import factor_cmap
from bokeh.models import Legend
output_notebook()
Bereitgestellt von

p = figure(x_range=data.iloc[:,1], plot_width=800, plot_height=550, title="Authors Highest Priced Book", toolbar_location=None, tools="")

p.vbar(x=data.iloc[:,1], top=data.iloc[:,4], width=0.9)

p.xgrid.grid_line_color = None
p.y_range.start = 0
p.xaxis.major_label_orientation = math.pi/2
Bereitgestellt von

show(p)
Bereitgestellt von

Aus dem Diagramm geht hervor, dass die beiden teuersten Bücher von Mecmillan und P L Dhingra stammen.

Top-bewertete Bücher nach Autor:innen

Schauen wir, welche Autor:innen die am besten bewerteten Bücher haben und welche Titel das sind. Dabei filtern wir nur Bücher mit mindestens 1.000 Kundenbewertungen.

data = df[df['Customers_Rated'] > 1000]
Bereitgestellt von

data = data.sort_values(['Rating'],axis=0, ascending=False)[:15]
Bereitgestellt von

data
Bereitgestellt von

p = figure(x_range=data.iloc[:,0], plot_width=800, plot_height=600, title="Top Rated Books with more than 1000 Customers Rating", toolbar_location=None, tools="")

p.vbar(x=data.iloc[:,0], top=data.iloc[:,2], width=0.9)

p.xgrid.grid_line_color = None
p.y_range.start = 0
p.xaxis.major_label_orientation = math.pi/2
Bereitgestellt von

show(p)
Bereitgestellt von

Hier siehst du die drei bestbewerteten Bücher mit mehr als 1.000 Bewertungen: Inner Engineering: A Yogi’s Guide to Joy, Bhagavad‑Gita (Hindi) und The Alchemist.

p = figure(x_range=data.iloc[:,1], plot_width=800, plot_height=600, title="Top Rated Books with more than 1000 Customers Rating", toolbar_location=None, tools="")

p.vbar(x=data.iloc[:,1], top=data.iloc[:,2], width=0.9)

p.xgrid.grid_line_color = None
p.y_range.start = 0
p.xaxis.major_label_orientation = math.pi/2
Bereitgestellt von

show(p)
Bereitgestellt von

Das Diagramm zeigt die Top 10 Autor:innen mit den bestbewerteten Büchern (mehr als 1.000 Bewertungen) in absteigender Reihenfolge — unter anderem Sadhguru, A. C. Bhaktivedanta und Paulo Coelho.

Autor:innen und Bücher mit den meisten Bewertungen

Du hast dir bereits die bestbewerteten Bücher und Autor:innen angesehen. Noch überzeugender ist oft der Blick auf die Anzahl der Kund:innen, die überhaupt bewertet haben.

Finden wir das schnell heraus.

data = df.sort_values(["Customers_Rated"], axis=0, ascending=False)[:20]
Bereitgestellt von

data
Bereitgestellt von

from bokeh.transform import factor_cmap
from bokeh.models import Legend
from bokeh.palettes import Dark2_5 as palette
import itertools
from bokeh.palettes import d3
#colors has a list of colors which can be used in plots
colors = itertools.cycle(palette)

palette = d3['Category20'][20]
Bereitgestellt von

index_cmap = factor_cmap('Author', palette=palette,
                         factors=data["Author"])
Bereitgestellt von

p = figure(plot_width=700, plot_height=700, title = "Top Authors: Rating vs. Customers Rated")
p.scatter('Rating','Customers_Rated',source=data,fill_alpha=0.6, fill_color=index_cmap,size=20,legend='Author')
p.xaxis.axis_label = 'RATING'
p.yaxis.axis_label = 'CUSTOMERS RATED'
p.legend.location = 'top_left'
Bereitgestellt von

BokehDeprecationWarning: 'legend' keyword is deprecated, use explicit 'legend_label', 'legend_field', or 'legend_group' keywords instead
Bereitgestellt von

show(p)
Bereitgestellt von

Das Streudiagramm zeigt Autor:innen im Verhältnis von Kundenanzahl zu Bewertung. Folgende Punkte lassen sich ableiten:

• Paulo Coelhos The Alchemist ist klar der Bestseller: Hohe Bewertung und sehr viele Rezensionen gehen hier Hand in Hand.
• Amish Tripathis Ram - Scion of Ikshvaku (Ram Chandra) hat eine Bewertung von 4,2 bei 5.766 Rezensionen. George S. Clasons The Richest Man in Babylon hat ähnlich viele Rezensionen, aber eine Gesamtbewertung von 4,5. Mehr Kund:innen vergaben also eine höhere Bewertung an The Richest Man in Babylon.

Fazit

Glückwunsch, du hast das Tutorial abgeschlossen.

Du hast eine grundlegende Einführung ins Amazon‑Scraping mit Beautiful Soup gesehen und gelernt, wie du die extrahierten Informationen mit der Bokeh‑Bibliothek visualisierst. Eine gute Übung, um weiterzukommen: Scrape andere Websites und schau, welche Insights du daraus gewinnst. Wenn du weitere Anleitung für populäre Seiten möchtest, wir haben auch ein Tutorial zum Scrapen von Reddit.

Wenn du gerade erst mit Python startest und mehr lernen willst, schau dir den DataCamp‑Kurs Introduction to Data Science in Python an.