Come usare Python per fare scraping su Amazon

In un'epoca in cui Internet è ricchissimo di dati e, a quanto pare, i dati sono il nuovo petrolio, il web scraping è diventato ancora più importante e pratico da usare in molte applicazioni. Il web scraping consiste nell'estrarre informazioni da un sito web. A volte viene anche chiamato web harvesting o estrazione di dati dal web. Copiare il testo da un sito e incollarlo sul tuo sistema locale è comunque web scraping, anche se manuale. In generale, però, il web scraping consiste nell'estrarre dati in modo automatico con l'aiuto di web crawler. I web crawler sono script che si connettono al World Wide Web tramite il protocollo HTTP e ti permettono di recuperare dati in modo automatizzato.

Che tu sia data scientist, ingegnere o chiunque analizzi grandi quantità di dati, saper estrarre dati dal web è una competenza utile. Mettiamo che tu trovi dei dati online e non ci sia un modo diretto per scaricarli: lo scraping con Python è l'abilità che ti permette di estrarli in una forma utile, da importare e usare in vari modi.

Alcune applicazioni pratiche del web scraping sono:

• Raccogliere i CV di candidati con una specifica competenza,
• Estrarre tweet da Twitter con determinati hashtag,
• Lead generation in ambito marketing,
• Estrarre dettagli di prodotto e recensioni da siti e-commerce come Amazon, il focus di questo tutorial

Oltre ai casi d'uso sopra, il web scraping è ampiamente usato nell'elaborazione del linguaggio naturale per estrarre testo dai siti e addestrare modelli di deep learning.

Prima di procedere, tieni presente che siti come Amazon possono aggiornare i propri termini di servizio o introdurre nuove restrizioni tecniche che influiscono su come è possibile accedere o riutilizzare i contenuti. È tua responsabilità consultare i Termini di servizio del sito e il file robots.txt per assicurarti che il tuo caso d’uso sia conforme. Le policy possono cambiare e i permessi variano.

Possibili sfide del web scraping

• Una delle difficoltà nello scraping di informazioni dai siti è la varietà delle loro strutture. In altre parole, i template dei siti differiscono e sono unici; di conseguenza, generalizzare tra siti può essere una sfida.

• Un'altra difficoltà può essere la longevità. Poiché gli sviluppatori aggiornano spesso i loro siti, non puoi fare affidamento a lungo sullo stesso scraper. Anche se le modifiche fossero minime, potrebbero comunque ostacolarti nel recupero dei dati.

Per affrontare queste sfide, esistono varie soluzioni possibili. Una è seguire l'integrazione e distribuzione continue (CI/CD) e la manutenzione costante, dato che le modifiche ai siti sono dinamiche.

Un approccio più realistico è usare le API (Application Programming Interfaces) offerte da vari siti e piattaforme. Ad esempio, Facebook e Twitter forniscono API pensate per gli sviluppatori che vogliono sperimentare con i loro dati o estrarre informazioni, per esempio, relative a tutti gli amici e amici in comune e tracciarne un grafo di connessioni. Il formato dei dati quando usi le API è diverso dal normale web scraping, cioè JSON o XML, mentre nello scraping standard ti trovi principalmente a gestire dati in formato HTML.

Che cos'è Beautiful Soup?

Beautiful Soup è una libreria Python pura per estrarre dati strutturati da un sito web. Ti permette di effettuare il parsing di dati da file HTML e XML. Funziona come un modulo di supporto e interagisce con l’HTML in modo simile, ma migliore, rispetto a come interagiresti con una pagina web usando altri strumenti per sviluppatori.

• Di solito fa risparmiare ore o giorni di lavoro agli sviluppatori, perché funziona con i tuoi parser preferiti come lxml e html5lib per offrire modi “pythonic” di navigare, cercare e modificare l’albero di parsing.

• Un’altra funzionalità potente e utile di Beautiful Soup è l’intelligenza nel convertire i documenti in ingresso in Unicode e quelli in uscita in UTF-8. Come sviluppatore, non devi occupartene, a meno che il documento non specifichi un’encoding intrinseca o Beautiful Soup non riesca a rilevarne una.

• È anche considerata più veloce rispetto ad altre tecniche generiche di parsing o scraping.

Tipi di parser

Se vuoi, puoi approfondire qui.

Basta teoria, giusto? Allora installiamo Beautiful Soup e iniziamo a scoprire le sue funzioni e capacità con Python.

Come primo passo, devi installare la libreria Beautiful Soup dal terminale o da Jupyter Lab. Il modo migliore è tramite pip, quindi assicurati di aver già installato il modulo pip.

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

Importare le librerie necessarie

Importiamo i pacchetti richiesti che userai per fare scraping dei dati dal sito e visualizzarli con l’aiuto di seaborn, matplotlib e 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

Scraping dei libri più venduti su Amazon

L’URL che andrai a estrarre è il seguente: https://www.amazon.in/gp/bestsellers/books/. Il parametro della pagina può essere modificato per accedere ai dati di ogni pagina. Quindi, per accedere a tutte le pagine dovrai ciclare su tutte per ottenere il dataset necessario, ma prima devi scoprire il numero di pagine dal sito.

Per connetterti all’URL e recuperare il contenuto HTML sono necessarie le seguenti cose:

• Definire una funzione get_data che prenda in input il numero di pagina come argomento,
• Definire un user-agent che aiuti ad aggirare il rilevamento come scraper,
• Specificare l’URL a requests.get e passare l’header con lo user-agent come argomento,
• Estrarre il contenuto da requests.get,
• Fare lo scraping della pagina specificata e assegnarla alla variabile soup,

Il passo successivo e importante è identificare il tag padre sotto il quale risiedono tutti i dati di cui hai bisogno. I dati che andrai a estrarre sono:

• Nome del libro
• Autore
• Valutazione
• Clienti che hanno valutato
• Prezzo

L’immagine sotto mostra dove si trova il tag padre e, quando ci passi sopra, evidenzia tutti gli elementi richiesti.

Analogamente al tag padre, devi trovare gli attributi per nome del libro, autore, valutazione, clienti che hanno valutato e prezzo. Vai sulla pagina che vuoi estrarre, seleziona l’attributo, fai clic destro e scegli “Ispeziona elemento”. Questo ti aiuterà a trovare i campi informativi specifici da estrarre dalla pagina HTML, come mostrato nella figura seguente:

Nota che alcuni nomi di autori non sono registrati su Amazon, quindi devi applicare un find aggiuntivo per quegli autori. Nel blocco di codice qui sotto trovi condizioni if-else annidate per i nomi degli autori, necessarie per estrarre i nomi di autore/pubblicazione.

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

Il blocco di codice seguente eseguirà le seguenti funzioni:

• Chiama la funzione get_data all’interno di un ciclo for,
• Il ciclo for itera su questa funzione da 1 fino al numero di pagine+1.
• Poiché l’output sarà una lista annidata, prima la appiattirai e poi la passerai al DataFrame.
• Infine, salva il DataFrame come file 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')

Lettura del file CSV

Ora carichiamo il file CSV che hai creato e salvato nel blocco sopra. Anche questo è uno step opzionale; potresti usare direttamente il DataFrame df e ignorare il passaggio seguente.

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

df.shape

(100, 5)

La forma del DataFrame indica che nel tuo file CSV ci sono 100 righe e 5 colonne.

Stampiamo le prime 5 righe del dataset.

df.head(61)

Facciamo un po’ di preprocessing sulle colonne Ratings, Customers_Rated e Price.

• Dal momento che le valutazioni sono su 5, puoi tenere solo il numero e rimuovere la parte extra.
• Dalla colonna customers_rated, rimuovi le virgole.
• Dalla colonna price, rimuovi il simbolo della rupia, la virgola e fai lo split sul punto.
• Infine, converti tutte e tre le colonne in intero o 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()

Verifichiamo i tipi di dato del DataFrame.

df.dtypes

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

Sostituisci i valori zero nel DataFrame con NaN.

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

Conteggio del numero di NaN nel DataFrame

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

count_nan

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

Dall’output sopra, puoi notare che ci sono in totale sei libri senza nome dell’autore, mentre uno non ha un prezzo associato. Queste informazioni sono cruciali per un autore che vuole vendere i propri libri e non andrebbero trascurate.

Eliminiamo questi NaN.

df = df.dropna()

Libro al prezzo più alto su Amazon per autore

Scopriamo quali autori hanno avuto il libro con il prezzo più alto. Visualizzerai i risultati per i primi 20 autori.

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)

Dal grafico sopra, puoi osservare che i due libri con il prezzo più alto sono degli autori Mecmillan e P L Dhingra.

Libri più votati per autore

Scopriamo quali autori hanno i libri con le valutazioni più alte e quali sono quei libri. Tuttavia, mentre lo determini, escluderai gli autori con meno di 1000 valutazioni clienti.

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)

Dall’output sopra, puoi osservare che i tre libri più votati con oltre 1000 valutazioni clienti sono Inner Engineering: A Yogi’s Guide to Joy, Bhagavad-Gita (Hindi) e 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)

Il grafico sopra mostra i 10 autori, in ordine decrescente, che hanno i libri con valutazioni più alte e oltre 1000 valutazioni clienti: tra questi Sadhguru, A. C. Bhaktivedanta e Paulo Coelho.

Autori e libri con più valutazioni dei clienti

Dopo aver visto i libri e gli autori più votati, è ancora più convincente e credibile concludere quale sia il miglior autore e libro in base al numero di clienti che hanno lasciato una valutazione.

Scopriamolo rapidamente.

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)

Il grafico sopra è uno scatter plot degli autori che mettono a confronto numero di valutazioni dei clienti e valutazione effettiva. Dal grafico si possono trarre le seguenti conclusioni.

• Senza dubbio, The Alchemist di Paulo Coelho è il libro più venduto, dato che valutazione e numero di clienti che hanno votato sono entrambi allineati.
• Il libro Ram - Scion of Ikshvaku (Ram Chandra) di Amish Tripathi ha una valutazione di 4,2 con 5766 valutazioni clienti. Tuttavia, The Richest Man in Babylon di George S. Clason ha un numero di valutazioni quasi simile, ma una valutazione complessiva di 4,5. Quindi si può concludere che più clienti hanno assegnato un voto alto a The Richest Man in Babylon.

Conclusione

Congratulazioni per aver terminato il tutorial.

Questo tutorial è stata un’introduzione di base allo scraping di Amazon con Beautiful Soup e a come dare senso alle informazioni estratte visualizzandole con la libreria di plotting bokeh. Un buon esercizio per fare un passo avanti nell’imparare il web scraping con Beautiful Soup è estrarre dati da altri siti e vedere quali insight puoi ricavare. Abbiamo anche un tutorial sullo scraping di Reddit se vuoi altre indicazioni per lo scraping di siti popolari.

Se stai iniziando con Python e vuoi saperne di più, segui il corso di DataCamp Introduzione alla Data Science in Python.