Di Nathan Rosidi, Data Scientists, fondatore di Strata Scratch

È necessario lavorare con le API per la scienza dei dati set di competenze per tutti i data scientist e dovrebbe essere incorporato nei tuoi progetti di scienza dei dati. Nel nostro blog precedente – idee per progetti di analisi dei dati, abbiamo delineato l'unico progetto di scienza dei dati di cui avrai mai bisogno e abbiamo parlato di quanto sia importante lavorare con le API per raccogliere i tuoi dati per il tuo progetto di scienza dei dati. Quindi, in questo articolo, vogliamo mostrarti come estrarre i dati da un'API in modo specifico usando Python per estrarre i dati dall'API di YouTube e dalla libreria di richieste che si trova in Python.

Vediamo quindi come lavorare con un'API per la scienza dei dati. Estrarremo i dati ed esamineremo la risposta JSON che otteniamo, quindi salveremo tutti questi dati in un Pandas DataFrame.

Faremo tutto questo in modo programmatico con buone capacità di ingegneria del software in modo che il tuo codice appaia pulito e conciso e non come l'hanno scritto circa 10 anni. Questo articolo non riguarda come lavorare con l'API di Youtube, ma come lavorare con le API in generale, quindi ci assicureremo di utilizzare le librerie e le tecniche che possono essere utilizzate per qualsiasi servizio API.

Perché raccogliere dati da un'API?

Potresti pensare che perché non utilizziamo solo un CSV o estraiamo dati da un database? Ci sono due ragioni per cui dovresti imparare le API:

1. Un'API è un settore molto comune, un modo professionale di raccogliere dati, quindi se lavori come data scientist, ti verrà richiesto di imparare come farlo.

2. È il modo più complicato e avanzato per raccogliere dati rispetto all'estrazione di dati da un database. Quindi, solo un altro motivo per imparare le API e per impressionare i tuoi colleghi e il responsabile delle assunzioni.
 

Strumenti e piattaforme

Piattaforma

Utilizzeremo Google Colabs che è fondamentalmente un notebook Jupyter. Puoi utilizzare i taccuini Jupyter se lo desideri, ma utilizzeremo Colabs perché è facile avviare e salvare il nostro lavoro su Google Drive.

Importazioni

Ora la prima cosa è importare e le librerie.

#import libraries
import requests
import pandas as pd
import time

La libreria delle richieste è una libreria che ci consentirà di effettuare chiamate API. Puoi utilizzare questa libreria per effettuare una richiesta a qualsiasi API, quindi a seconda dell'API da cui desideri acquisire i dati, le tecniche trattate qui saranno le stesse. Se vuoi saperne di più sulla libreria delle richieste, ecco un link – https://realpython.com/python-requests/. Poi abbiamo la libreria Pandas perché salveremo i nostri dati in un Pandas DataFrame e poi c'è una libreria del tempo.

API Key

Il passaggio successivo consiste nell'ottenere una chiave API. Prenderemo i dati dall'API di Youtube, in particolare, raccogliendo i dati dal nostro canale qui. Per accedere alle informazioni sui nostri canali tramite API, dobbiamo richiedere una chiave API. Puoi farlo andando a questo link – https://www.slickremix.com/docs/get-api-key-for-youtube/. Non vogliamo scrivere questo articolo in modo specifico su come lavorare con l'API di Youtube, quindi ti lasceremo a ottenere tu stesso la chiave API. Ma in generale, ogni volta che lavori con un'API, avrai sempre bisogno di una chiave. E il modo per ottenere una chiave è diverso per ogni servizio API. Quindi supponiamo che tu abbia eseguito il processo e ottenuto la tua chiave API.

Ora prenderemo tutti i video che abbiamo nel nostro canale e poi prenderemo le metriche da ogni video:

Elenco di video dal canale

• ID video
• Video Titolo
• Data di pubblicazione

Metriche video

• Visualizza conteggio
• Conteggio collegamenti
• Conte antipatia
• Conteggio commenti

Ora ciò di cui abbiamo bisogno è il nostro ID canale. Quindi questi due parametri verranno utilizzati per effettuare la nostra chiamata API.

#keys
API_KEY = "AIXXXXXXXX"
CHANNEL_ID = "UCW8Ews7tdKKkBT6GdtQaXvQ"

Test con la libreria delle richieste

 
Proviamo rapidamente una chiamata API. Usando la libreria delle richieste, puoi effettuare una chiamata semplicemente inserendo l'URL dell'API nel metodo get().

#make API call
response = requests.get('https://api.github.com').json()

Per acquisire alcuni dati, stiamo usando il metodo get(). I dati si trovano su api.github.com. Stiamo passando l'URL al metodo get() e aggiungiamo il metodo json() che restituirà un oggetto JSON nella risposta.

Che cos'è un file JSON?

È un file di dati popolare inviato come oggetto JS e contiene i tuoi dati di solito come coppie attributo-valore o in un array. E salva i dati in una variabile chiamata response.

Ora vediamo i dati:

response

Come puoi vedere nell'output, l'intero risultato è racchiuso tra parentesi graffe e ogni riga ha un attributo o una chiave e ogni chiave ha un valore. Questo è un elenco di URL a cui puoi accedere per informazioni specifiche da Github.

Ad esempio, se desideri trovare le email degli utenti, utilizzerai email_url nel tuo metodo get().

emails_url': 'https://api.github.com/user/emails'

Stavamo solo testando la libreria delle richieste e testando rapidamente la sua funzionalità. Ora facciamo una chiamata all'API di Youtube e prendiamo alcuni dati.

Lavorare con l'API di YouTube

Quindi la parte più difficile dell'effettuare una chiamata API è capire come strutturare l'URL, principalmente quali parametri aggiungere nell'URL. Al momento abbiamo un URL radice

url = "https://www.googleapis.com/youtube/v3/

Questa è la posizione dei nostri dati. Dobbiamo solo definire che tipo di dati vogliamo raccogliere. Per fare ciò, ora dobbiamo aggiungere parametri all'URL per ottenere informazioni video specifiche dal nostro canale specifico.

La parte più difficile è capire quali parametri e proprietà aggiungere all'URL? Come fai a capirlo? Il modo migliore è leggere la documentazione ufficiale. https://developers.google.com/youtube/v3/docs/search

Faremo una "ricerca" e includeremo diversi parametri come "parte", "channelID" e la mia chiave API. E all'interno del parametro "parti", aggiungeremo le proprietà id e snippet per acquisire dati ID che includono ID video e informazioni sul video stesso come vedi qui nell'elenco.

Ora scriveremo l'intero URL con i parametri che ci forniranno tutti i dati che vogliamo raccogliere. Ancora una volta, questo articolo non riguarda specificamente YouTube, quindi non approfondiremo come abbiamo capito quali parametri utilizzare e tutto il resto. Molti erano tentativi ed errori. Ma lascia che ti guidiamo su come stiamo strutturando questo URL.

url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&
channelId="+CHANNEL_ID+"&part=snippet,id&order=date&maxResults=10000"
+pageToken

Stiamo eseguendo una "ricerca" tramite l'API di YouTube. Tutto a destra del '?' sono parametri che aggiungiamo per richiedere informazioni specifiche.

• Innanzitutto, aggiungiamo la nostra chiave API che è memorizzata nella variabile API_KEY in questo parametro chiave.
• Specifichiamo l'ID canale da cui vogliamo raccogliere le informazioni.
• Il prossimo è il parametro della parte in cui stiamo specificando che vogliamo i dati snippet e ID. Dalla documentazione, ci dice quali dati possiamo aspettarci di ottenere quando chiediamo snippet e dati ID.
• Ordina i dati per data e quindi vogliamo i maxResults di 10000 video nella nostra chiamata API.
• Infine, il pageToken è un token, che è un codice, necessario per arrivare alla pagina successiva dei risultati della ricerca. Ci occuperemo di questo in seguito quando proveremo a estrarre tutti i dati.

Costruire questo può essere difficile ed è un sacco di tentativi ed errori. Ma una volta che ci giochi e ottieni i dati che desideri, non dovrai più preoccupartene. Quindi questo intero URL viene salvato nella nostra variabile URL.

Risposta dall'esecuzione di una chiamata API

 
Effettuiamo la chiamata API esattamente nello stesso modo in cui l'abbiamo fatto per l'esempio Github.

pageToken = ""
response = requests.get(url).json()

Ed ecco l'output della chiamata API.

Come puoi vedere, abbiamo lo stesso oggetto JSON salvato nella variabile di risposta. Vedrai tutte le proprietà per id e snippet.

Analisi dei dati

 
Come fai a ottenere testa o croce da questi dati? Per prima cosa, identifichiamo cosa ci interessa? Vediamo la chiave etag in alto e quindi la chiave degli elementi come seconda chiave nella risposta. La chiave degli elementi inizia con una parentesi quadra e quindi in pratica elenca tutti i video nel nostro canale. Se andiamo alla fine della risposta, vediamo finalmente l'ultimo video nel nostro canale e la parentesi quadra di chiusura per la chiave degli articoli. Quindi vediamo gli altri tipi di chiavi, nextPageToken e così via.

Puoi anche vedere che abbiamo 95 risultati ma ne abbiamo recuperati solo 50. La chiave nextPageToken ci aiuterà a ottenere i video nella pagina successiva della ricerca. Ma lo tratteremo più tardi.

Quindi la nostra chiamata API ci ha fornito un risultato di ricerca di tutti i nostri video e alcune informazioni sul video. Tutte queste informazioni sono memorizzate nella chiave degli articoli. Quindi prendiamo quei dati e filtriamo il resto.

Puoi farlo facilmente specificando solo la chiave degli elementi.

response['items']

Vedi che l'output inizia con le parentesi quadre ed elenca tutti i video che abbiamo sul nostro canale. Per isolare un video, possiamo specificare la posizione.

response['items'][0]

Quindi, questo è il nostro ultimo video.

Analisi dell'output e salvataggio in variabili

È ovvio che ciò che dobbiamo fare è scorrere tutti i video nella chiave degli elementi e salvare informazioni specifiche. Salviamo prima le informazioni nelle variabili e costruiamo il ciclo per ultimo.

Salviamo l'ID video. Per fare ciò, dobbiamo chiamare la variabile di risposta, la chiave dell'elemento e la 1a posizione. Quindi, una volta che lo abbiamo, stiamo selezionando la chiave id e quindi la chiave ID video. Possiamo salvare quel valore nella variabile video_id. Questo è fondamentalmente il modo in cui navigherai nell'array e salverai i dati desiderati.

video_id = response['items'][0]['id']['videoId']

Facciamo lo stesso con il titolo del video. Qui stiamo anche sostituendo tutti i simboli & (e commerciale) con uno spazio vuoto)

video_title = response['items'][0]['snippet']['title']
video_title = str(video_title).replace("&","")

Quindi prendiamo la data di caricamento

upload_date = response['items'][0]['snippet']['publishedAt']

Vogliamo prendere solo la data e omettere il timestamp.

Per fare ciò possiamo dividere sulla T e afferrare il lato sinistro dell'output.

upload_date = str(upload_date).split("T")[0]

Quindi è così che salvi tutte le informazioni.

Creazione del ciclo

 
Creiamo un Loop per scorrere tutti i video raccolti nella chiamata API e salvare le informazioni.

Esamineremo l'array response['items'] in modo che il nostro "for Loop" inizi con

for video in response['items']:

Successivamente, dobbiamo aggiungere una logica che assicuri che raccoglieremo solo informazioni sui video. Quindi, per garantire questa logica, dobbiamo assicurarci di guardare solo i video. Se controlli la risposta, vedrai

'kind': 'youtube#video',

Quindi aggiungeremo un'istruzione if solo per assicurarci di salvare le informazioni sul video. Come puoi vedere anche al posto di response['items'] stiamo usando la variabile video perché siamo nel 'ciclo for'.

if video['id']['kind'] == "youtube#video":

E infine, tutte le variabili che abbiamo costruito per raccogliere le informazioni dalla risposta, le useremo di nuovo ma dovremo solo cambiare il nome della variabile in video. Il tuo risultato finale sarà simile a questo.

for video in response['items']: if video['id']['kind'] == "youtube#video": video_id = video['id']['videoId'] video_title = video['snippet']['title'] video_title = str(video_title).replace("&","") upload_date = video['snippet']['publishedAt'] upload_date = str(upload_date).split("T")[0]

Effettuare una seconda chiamata API

 
Raccogliere queste informazioni è fantastico ma non è interessante. Vogliamo anche raccogliere il numero di visualizzazioni, Mi piace e Non mi piace per ciascuno dei nostri video. Non è nella prima chiamata API. Quello che dobbiamo fare ora è effettuare una seconda chiamata API per raccogliere queste informazioni perché dobbiamo utilizzare il video_id che abbiamo raccolto dalla prima chiamata API per quindi effettuare una seconda chiamata API per acquisire la visualizzazione, i conteggi di Mi piace, Non mi piace e commenti .

Poiché ti abbiamo mostrato esattamente come effettuare una chiamata API, ti suggeriamo di trovare un modo per effettuare tu stesso questa seconda chiamata API. E se riesci a effettuare la seconda chiamata API, dovrebbe assomigliare a questo:

url_video_stats = "https://www.googleapis.com/youtube/v3/videos?id=" +video_id+"&part=statistics&key="+API_KEY
response_video_stats = requests.get(url_video_stats).json() view_count = response_video_stats['items'][0]['statistics']['viewCount']
like_count = response_video_stats['items'][0]['statistics']['likeCount']
dislike_count = response_video_stats['items'][0]['statistics'] ['dislikeCount']
comment_count = response_video_stats['items'][0]['statistics'] ['commentCount']

Ora, dobbiamo aggiungerlo al "ciclo for". E otterremo qualcosa del genere:

for video in response['items']: if video['id']['kind'] == "youtube#video": video_id = video['id']['videoId'] video_title = video['snippet']['title'] video_title = str(video_title).replace("&","") upload_date = video['snippet']['publishedAt'] upload_date = str(upload_date).split("T")[0] #colleccting view, like, dislike, comment counts url_video_stats = "https://www.googleapis.com/youtube/v3/videos?id=" +video_id+"&part=statistics&key="+API_KEY response_video_stats = requests.get(url_video_stats).json() view_count = response_video_stats['items'][0]['statistics'] ['viewCount'] like_count = response_video_stats['items'][0]['statistics'] ['likeCount'] dislike_count = response_video_stats['items'][0]['statistics'] ['dislikeCount'] comment_count = response_video_stats['items'][0]['statistics'] ['commentCount']

Salvataggio su un DataFrame Pandas

 
Ora costruiamo un DataFrame Pandas in modo da poter salvare tutte queste informazioni. Poiché conosciamo già tutte le informazioni che vogliamo salvare, creeremo un Pandas DataFrame vuoto con le intestazioni delle colonne sopra il "ciclo for".

df = pd.DataFrame(columns=["video_id","video_title","upload_date", "view_count","like_count","dislike_count","comment_count"])

Successivamente, aggiungeremo i dati che abbiamo salvato nelle variabili nel "ciclo for" a quel Pandas DataFrame. Usiamo il metodo append() per farlo all'interno del 'ciclo for'.

df = df.append({'video_id':video_id,'video_title':video_title, 'upload_date':upload_date,'view_count':view_count, 'like_count':like_count,'dislike_count':dislike_count, 'comment_count':comment_count},ignore_index=True)

L'intero "ciclo for" sarà simile a questo:

for video in response['items']: if video['id']['kind'] == "youtube#video": video_id = video['id']['videoId'] video_title = video['snippet']['title'] video_title = str(video_title).replace("&","") upload_date = video['snippet']['publishedAt'] upload_date = str(upload_date).split("T")[0] #collecting view, like, dislike, comment counts url_video_stats = "https://www.googleapis.com/youtube/v3/videos?id=" +video_id+"&part=statistics&key="+API_KEY response_video_stats = requests.get(url_video_stats).json() view_count = response_video_stats['items'][0]['statistics'] ['viewCount'] like_count = response_video_stats['items'][0]['statistics'] ['likeCount'] dislike_count = response_video_stats['items'][0]['statistics'] ['dislikeCount'] comment_count = response_video_stats['items'][0]['statistics'] ['commentCount'] df = df.append({'video_id':video_id,'video_title':video_title, 'upload_date':upload_date,'view_count':view_count, 'like_count':like_count,'dislike_count':dislike_count, 'comment_count':comment_count},ignore_index=True)

Ora abbiamo tutti i nostri dati in questo Pandas DataFrame e l'output dovrebbe essere un Pandas DataFrame con tutte le statistiche video.

Creazione delle funzioni

 
Il codice che abbiamo scritto finora funziona perfettamente ma ci sono alcune cose che possono essere migliorate. La parte principale da migliorare è separare la chiamata API che acquisisce le informazioni video dalla parte principale perché la logica per la seconda chiamata API non deve essere mescolata nella logica di salvataggio dei dati.

Quindi possiamo separare la seconda chiamata API nella sua funzione e passare semplicemente il video_id che abbiamo raccolto dalla prima chiamata API.

def get_video_details(video_id): url = "https://www.googleapis.com/youtube/v3/videos?id="+video_id+"& part=statistics&key="+API_KEY response = requests.get(url).json() return response['items'][0]['statistics']['viewCount'], response['items'][0]['statistics']['likeCount'], response['items'][0]['statistics']['dislikeCount'], response['items'][0]['statistics']['commentCount']

Possiamo quindi avvolgere il lavoro principale nella sua funzione.

def get_videos(df): pageToken = "" while 1: url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"
&channelId="+CHANNEL_ID+"&part=snippet,id&order=date&maxResults=10000&"
+pageToken response = requests.get(url).json() time.sleep(1) #give it a second before starting the for loop for video in response['items']: if video['id']['kind'] == "youtube#video": video_id = video['id']['videoId'] video_title = video['snippet']['title'] video_title = str(video_title).replace("&","") upload_date = video['snippet']['publishedAt'] upload_date = str(upload_date).split("T")[0] print(upload_date) view_count, like_count, dislike_count, comment_count = get_ video_details(video_id) df = df.append({'Video_id':video_id,'Video_title': video_title, "Upload_date":upload_date,"View_count": view_count, "Like_count":like_count,"Dislike_count": dislike_count, "Comment_count":comment_count},ignore_index= True) try: if response['nextPageToken'] != None: #if none, it means it reached the last page and break out of it pageToken = "pageToken=" + response['nextPageToken'] except: break

Infine, possiamo chiamare le funzioni in questo modo.

df = pd.DataFrame(columns=["Video_id","Video_title","Upload_date", "View_count","Like_count","Dislike_count","Comment_count"]) #build our dataframe df = get_videos(df) print(df)

Vediamo il nostro output finale, dove otteniamo un Pandas DataFrame, video_id, video_title, upload_date, view_count, like_count, dislike_count e comment_count.

Conclusione

 
Ecco come puoi lavorare con l'API Python per il tuo progetto di data science e acquisire dati da un'API e salvarli in un Pandas DataFrame. In qualità di data scientist, dovrai sapere come acquisire dati dalle API. Analizziamo i passaggi che abbiamo eseguito:

• Appreso la libreria delle richieste per effettuare una chiamata API
• Chiamata API effettuata all'API di YouTube: abbiamo passato un URL all'API che specificava i dati desiderati. Abbiamo dovuto leggere attentamente la documentazione per creare l'URL.
• Dati raccolti come JSON: abbiamo raccolto i dati come oggetto JSON e analizzati i dati salvandoli prima come variabili.
• Salvato i dati come Pandas DataFrame
• Infine, abbiamo appena aggiunto una logica di gestione degli errori e ripulito il codice

 
Trova qualcosa di eccitante Domande di intervista Python per la posizione di data scientist che sono per principianti o qualcuno che è alla ricerca di compiti più impegnativi.

 
Biografia: Nathan Rosidi (@StrataScratch) è un data scientist e una strategia di prodotto. È anche un professore a contratto che insegna analisi ed è il fondatore di Strata Scratch, una piattaforma che aiuta i data scientist a prepararsi per le loro interviste con domande di interviste reali delle migliori aziende.

Correlato:

• API NLP di Machine Learning pronta per la produzione con FastAPI e spaCy
• Creazione di API RESTful utilizzando Flask
• Crea la tua prima applicazione per la scienza dei dati