Hoe je met Python Amazon scrapt

In een tijd waarin het internet bomvol data staat en data het nieuwe goud lijkt te zijn, is webscraping belangrijker en praktischer geworden voor allerlei toepassingen. Webscraping draait om het extraheren of "scrapen" van informatie van websites. Webscraping wordt ook wel web harvesting of web data extraction genoemd. Tekst van een website kopiëren en plakken op je lokale systeem is óók webscraping, maar dan handmatig. Meestal gaat webscraping over het automatisch extraheren van data met behulp van webcrawlers. Webcrawlers zijn scripts die verbinding maken met het world wide web via het HTTP-protocol en je in staat stellen data geautomatiseerd op te halen.

Of je nu data scientist, engineer of iemand bent die grote datasets analyseert: data van het web kunnen scrapen is een nuttige vaardigheid. Stel, je vindt data op het web en er is geen directe manier om die te downloaden, dan kun je met Python webscraping de data extraheren naar een bruikbare vorm die je daarna op allerlei manieren kunt importeren en gebruiken.

Enkele praktische toepassingen van webscraping zijn:

• Cv's verzamelen van kandidaten met een specifieke vaardigheid,
• Tweets met specifieke hashtags van Twitter extraheren,
• Leadgeneratie in marketing,
• Productdetails en reviews scrapen van e-commercewebsites zoals Amazon, de focus van deze tutorial

Naast bovenstaande usecases wordt webscraping veel gebruikt in natural language processing om tekst van websites te halen voor het trainen van een deep learning-model.

Houd er voordat je verdergaat rekening mee dat websites zoals Amazon hun specifieke servicevoorwaarden kunnen bijwerken of nieuwe technische beperkingen kunnen toevoegen die beïnvloeden hoe hun content kan worden benaderd of hergebruikt. Het is jouw verantwoordelijkheid om de Servicevoorwaarden en het robots.txt-bestand van de site te controleren om ervoor te zorgen dat jouw specifieke usecase compliant is. Beleid kan veranderen en toestemmingen kunnen variëren.

Mogelijke uitdagingen bij webscraping

• Een van de uitdagingen bij het scrapen van informatie van websites is de variatie in websitestructuren. Met andere woorden: websites gebruiken verschillende en unieke templates; generaliseren over websites heen kan dus lastig zijn.

• Een andere uitdaging is duurzaamheid. Omdat webdevelopers hun websites blijven updaten, kun je niet te lang op één scraper vertrouwen. Zelfs kleine aanpassingen kunnen het ophalen van data al verstoren.

Om bovenstaande uitdagingen aan te pakken zijn er verschillende oplossingen. Een daarvan is continuous integration & development (CI/CD) toepassen en constante onderhoud, aangezien de wijzigingen op websites dynamisch zijn.

Een realistischer aanpak is het gebruik van Application Programming Interfaces (API's) die door verschillende websites en platforms worden aangeboden. Facebook en Twitter bieden bijvoorbeeld API's die speciaal zijn ontworpen voor developers die met hun data willen experimenteren of informatie willen extraheren, bijvoorbeeld over alle vrienden en gemeenschappelijke vrienden om daar een connectiegrafiek van te maken. Het dataformaat bij gebruik van API's verschilt van gewone webscraping, namelijk JSON of XML, terwijl je bij standaard webscraping vooral met data in HTML-formaat werkt.

Wat is Beautiful Soup?

Beautiful Soup is een pure Python-bibliotheek voor het extraheren van gestructureerde data van een website. Je kunt er data mee parsen uit HTML- en XML-bestanden. Het fungeert als hulpmodule en werkt met HTML op een vergelijkbare, maar vaak prettigere manier dan hoe je met andere ontwikkelaarstools met een webpagina zou werken.

• Het bespaart programmeurs doorgaans uren of dagen werk omdat het samenwerkt met je favoriete parsers zoals lxml en html5lib en zo natuurlijke Python-manieren biedt om door de parsetree te navigeren, te zoeken en die te wijzigen.

• Een andere krachtige en nuttige functie van Beautiful Soup is de intelligentie om binnenkomende documenten om te zetten naar Unicode en uitgaande documenten naar UTF-8. Als developer hoef je je daar niet druk om te maken, tenzij het document zelf geen encoding specificeert of Beautiful Soup er geen kan detecteren.

• Het wordt ook als sneller beschouwd vergeleken met andere algemene parse- of scrapingtechnieken.

Typen parsers

Lees er gerust meer over hier.

Genoeg theorie, toch? Laten we Beautiful Soup installeren en aan de slag gaan met de functies en mogelijkheden in Python.

Als eerste stap installeer je de Beautiful Soup-bibliotheek via je terminal of Jupyter Lab. De beste manier om Beautiful Soup te installeren is via pip, dus zorg dat de module pip al is geïnstalleerd.

!pip3 install beautifulsoup4

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)

Benodigde libraries importeren

Laten we de pakketten importeren die je gebruikt om data van de website te scrapen en te visualiseren met behulp van seaborn, matplotlib en bokeh.

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

De bestsellers op Amazon scrapen

De URL die je gaat scrapen is de volgende: https://www.amazon.in/gp/bestsellers/books/. De pagina-parameter kan worden aangepast om data per pagina op te halen. Om alle pagina's te benaderen, moet je dus door alle pagina's loopen om de benodigde dataset te krijgen, maar eerst moet je op de website het aantal pagina's achterhalen.

Om verbinding te maken met de URL en de HTML-content op te halen, heb je het volgende nodig:

• Definieer een functie get_data die paginanummers als argument krijgt,
• Definieer een user-agent die helpt om detectie als scraper te omzeilen,
• Geef de URL door aan requests.get en voeg de user-agent-header toe als argument,
• Extraheer de content uit requests.get,
• Scrape de opgegeven pagina en wijs die toe aan de variabele soup,

De volgende en belangrijke stap is het identificeren van de parent tag waaronder alle benodigde data staat. De data die je gaat extraheren is:

• Boektitel
• Auteur
• Beoordeling
• Aantal beoordelingen
• Prijs

De onderstaande afbeelding laat zien waar de parent tag zich bevindt; als je eroverheen hovert, worden alle vereiste elementen gemarkeerd.

Net als bij de parent tag moet je de attributen vinden voor boektitel, auteur, beoordeling, aantal beoordelingen en prijs. Ga naar de webpagina die je wilt scrapen, selecteer het attribuut, klik met de rechtermuisknop en kies Inspecteren. Zo vind je de specifieke informatievelden die je uit de ruwe HTML-pagina wilt halen, zoals in de onderstaande figuur:

Let op: sommige auteursnamen zijn niet bij Amazon geregistreerd, dus voor die auteurs moet je een extra find toepassen. In de onderstaande cel vind je geneste if-else-voorwaarden voor auteursnamen om de auteurs-/uitgeversnamen te extraheren.

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

De onderstaande codecel voert het volgende uit:

• Roep de functie get_data aan binnen een for-loop,
• De for-loop itereert over deze functie vanaf 1 tot en met het aantal pagina's+1.
• Aangezien de output een geneste lijst is, vlakken we de lijst eerst af en geven die daarna door aan de DataFrame.
• Sla de DataFrame ten slotte op als een CSV-bestand.

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')

CSV-bestand inlezen

Laad nu het CSV-bestand dat je hierboven hebt gemaakt en opgeslagen. Dit is een optionele stap; je kunt ook direct de dataframe df gebruiken en de onderstaande stap overslaan.

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

df.shape

(100, 5)

De shape van de DataFrame laat zien dat je CSV-bestand 100 rijen en 5 kolommen heeft.

Laten we de eerste 5 rijen van de dataset printen.

df.head(61)

Laten we wat preprocessing doen op de kolommen Ratings, Customers_Rated en Price.

• Aangezien je weet dat de ratings uit 5 bestaan, kun je alleen de score behouden en de rest verwijderen.
• Verwijder de komma uit de kolom customers_rated.
• Verwijder uit de kolom price het rupesymbool, de komma en splits op de punt.
• Zet tenslotte alle drie de kolommen om naar integer of float.

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

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

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

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

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

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

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

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

df.head()

Laten we de datatypes van de DataFrame controleren.

df.dtypes

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

Vervang de nullen in de DataFrame door NaN.

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

Het aantal NaN's in de DataFrame tellen

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

count_nan

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

Uit bovenstaande output blijkt dat er in totaal zes boeken zijn zonder auteursnaam, terwijl één boek geen prijs heeft. Deze informatie is cruciaal voor een auteur die zijn of haar boeken wil verkopen en zou niet vergeten mogen worden.

Laten we deze NaN's verwijderen.

df = df.dropna()

Hoogst geprijsde boek per auteur op Amazon

Laten we uitzoeken welke auteurs het hoogst geprijsde boek hadden. We visualiseren de resultaten voor de top 20 auteurs.

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

data

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()

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

show(p)

Uit de bovenstaande grafiek blijkt dat de twee hoogst geprijsde boeken van de auteurs Mecmillan en P L Dhingra zijn.

Hoogst beoordeelde boeken per auteur

Laten we uitzoeken welke auteurs de hoogst beoordeelde boeken hebben en welke boeken dat zijn. Daarbij filter je auteurs weg met minder dan 1000 klantbeoordelingen.

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

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

data

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

show(p)

Uit bovenstaande output blijkt dat de drie hoogst beoordeelde boeken met meer dan 1000 klantbeoordelingen zijn: Inner Engineering: A Yogi’s Guide to Joy, Bhagavad-Gita (Hindi) en 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

show(p)

De bovenstaande grafiek toont in aflopende volgorde de top 10 auteurs met de hoogst beoordeelde boeken met meer dan 1000 klantbeoordelingen: Sadhguru, A. C. Bhaktivedanta en Paulo Coelho.

Meest beoordeelde auteurs en boeken

Je hebt de hoogst beoordeelde boeken en auteurs al gezien, maar het is overtuigender en betrouwbaarder om de beste auteur en het beste boek te bepalen op basis van het aantal klanten dat heeft beoordeeld.

Laten we dat snel uitzoeken.

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

data

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]

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

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'

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

show(p)

De bovenstaande grafiek is een scatterplot van auteurs met het aantal klantbeoordelingen versus de daadwerkelijke beoordeling. De volgende conclusies kun je trekken:

• Onbetwist is The Alchemist van Paulo Coelho het bestverkochte boek, omdat zowel de beoordeling als het aantal klanten dat heeft beoordeeld hoog en in lijn is.
• Het boek Ram - Scion of Ikshvaku (Ram Chandra) van Amish Tripathi heeft een beoordeling van 4,2 met 5766 klantbeoordelingen. Het boek The Richest Man in Babylon van George S. Clason heeft bijna evenveel klantbeoordelingen, maar een totaalscore van 4,5. Je kunt dus concluderen dat meer klanten The Richest Man in Babylon een hoge beoordeling gaven.

Conclusie

Gefeliciteerd met het afronden van de tutorial.

Deze tutorial was een basisintroductie in het scrapen van Amazon met Beautiful Soup en hoe je de geëxtraheerde informatie inzichtelijk kunt maken met de Bokeh-plotbibliotheek. Een goede oefening om een stap verder te gaan in webscraping leren met Beautiful Soup is om data van andere websites te scrapen en te kijken welke inzichten je eruit kunt halen. We hebben ook een tutorial over het scrapen van Reddit als je meer begeleiding wilt bij het scrapen van populaire websites.

Ben je net begonnen met Python en wil je meer leren? Volg dan de cursus Introduction to Data Science in Python van DataCamp.