Come importare dati JSON e HTML in pandas

Introduzione

Importare i dati è uno dei passaggi più essenziali e tra i primissimi in qualsiasi problema legato ai dati. Saper importare correttamente i dati è una competenza imprescindibile per chiunque aspiri a diventare data scientist.

I dati esistono in molte forme diverse, e non solo dovresti sapere come importare vari formati, ma anche come analizzarli e manipolarli per ricavarne insight utili.

pandas è una libreria Python open source, facile da usare, ad alte prestazioni, e uno strumento di analisi dei dati per vari formati.

Ti permette di leggere diversi tipi di formati come CSV, JSON, Excel, Pickle, ecc. Consente di rappresentare i dati in forma tabellare a righe e colonne, rendendoli leggibili e presentabili.

pandas rappresenta i dati come DataFrame e ti offre un uso esteso per analisi e manipolazione dei dati. Una volta che inizi a dare un senso ai dati utilizzando le varie funzionalità di pandas, puoi poi usare questi dati per analizzare, fare previsioni, classificare e molto altro!

pandas ha un'API di input e output con un set di funzioni di alto livello reader e writer. La funzione di lettura è accessibile con pandas.read_json() che restituisce un oggetto pandas, e la funzione di scrittura è accessibile con pandas.to_json(), che è un metodo dell'oggetto.

DataFrame ha una funzione Reader e una Writer. La funzione Reader ti consente di leggere i diversi formati di dati, mentre la funzione Writer ti permette di salvare i dati in un determinato formato.

Di seguito trovi i formati di dati supportati da DataFrame: se i tuoi dati sono in uno qualsiasi di questi formati, puoi usare pandas per caricarli e persino scriverli in un formato particolare.

Nell'esercitazione di oggi lavorerai su alcuni dei formati sopra citati come JSON, HTML e Pickle.

Nota: dai un'occhiata a questo tutorial per imparare a leggere file CSV con pandas.

Caricare dati JSON

JSON, noto anche come JavaScript Object Notation, è un formato di serializzazione testuale per lo scambio di dati. JSON è facile da leggere e scrivere. È basato su un sottoinsieme del linguaggio di programmazione JavaScript ma utilizza convenzioni di Python e molte altre lingue oltre Python.

JSON è usato soprattutto per memorizzare dati non strutturati, e i database SQL faticano a salvarli. JSON rende i dati accessibili alla lettura da parte delle macchine.

JSON è costruito principalmente su due strutture:

• Una raccolta di coppie chiave/valore. In Python, una coppia chiave/valore è chiamata Dictionary, e una chiave è un attributo univoco, mentre i valori non lo sono.

• Un elenco ordinato di valori. L'elenco ordinato può a volte essere una lista di liste. Le liste in Python sono un insieme di valori che possono essere stringhe, interi, ecc.

Vediamo quindi come puoi caricare i dati JSON in più modi.

Il primo dataset JSON proviene da questo link. I dati sono in formato dizionario chiave-valore. Ci sono in totale tre chiavi: cioè integer, datetime e category.

• Per prima cosa importerai la libreria pandas e poi passerai l'URL a pd.read_json(), che restituirà un dataframe. Le colonne del dataframe rappresentano le chiavi e le righe sono i valori del JSON.

import pandas as pd

json = pd.read_json('https://raw.githubusercontent.com/chrisalbon/simulated_datasets/master/data.json')

Stampiamo velocemente le ultime righe del JSON che hai letto usando la funzione .tail().

json.tail(6)

json.shape

(100, 3)

Dall'output sopra puoi vedere che ci sono in totale tre colonne: integer, datetime e category. Inoltre, ci sono 100 campioni nel dataset, come verificato dal metodo .shape che ha restituito un output 100 x 3.

• Scrivere un JSON

Scrivere i dati JSON è semplice quanto leggerli ed è una sola riga di codice. Invece di read_json() userai to_json() con un nome file, e il gioco è fatto!

json.to_json('dataframe.json')

• Parsing di un JSON annidato come stringa

Ora userai un altro tipo di dataset JSON, non così semplice. Si tratta di una struttura JSON annidata. Struttura JSON annidata significa che ogni chiave può avere associate altre chiavi.

Vediamo il dataset di esempio per capirlo meglio.

nested_json = """{
   "article": [

      {
         "id":"01",
         "language": "JSON",
         "edition": "first",
         "author": "Allen"
      },

      {
         "id":"02",
         "language": "Python",
         "edition": "second",
         "author": "Aditya Sharma"
      }
   ],

   "blog":[
   {
       "name": "Datacamp",
       "URL":"datacamp.com"
   }
   ]
}"""

Nel dataset sopra, puoi osservare che article e blog sono due chiavi primarie sotto le quali ci sono i valori di queste chiavi. Questi valori hanno la loro combinazione di chiave-valore.

Nota che il dataset sopra è racchiuso tra doppi apici ed è sotto forma di stringa.

La lettura di un JSON annidato può essere fatta in più modi.

Per prima cosa userai la funzione json.loads per leggere una stringa JSON passando la variabile dei dati come parametro. Poi userai la funzione json_normalize per appiattire i dati JSON annidati in una tabella.

Importerai la funzione json_normalize dalla libreria pandas.io.json.

import json  
from pandas.io.json import json_normalize  

nested = json.loads(nested_json)

nested

{'article': [{'id': '01',
   'language': 'JSON',
   'edition': 'first',
   'author': 'Allen'},
  {'id': '02',
   'language': 'Python',
   'edition': 'second',
   'author': 'Aditya Sharma'}],
 'blog': [{'name': 'Datacamp', 'URL': 'datacamp.com'}]}

Successivamente, appiattirai il JSON usando la funzione normalize. Per ora passerai l'intero dato e vedrai come appare.

nested_full = json_normalize(nested)

nested_full

Ottimo! Come puoi vedere dall'output sopra, le chiavi primarie sono le colonne del dataframe, mentre le chiavi rappresentano la riga.

Tuttavia, l'output sembra un po' confusionario, giusto? Vediamo come puoi suddividerlo ulteriormente in più dataframe.

Passerai di nuovo l'output di json.loads a json_normalize, ma questa volta specificherai un elemento extra chiamato record_path.

blog = json_normalize(nested,record_path ='blog')

blog

article = json_normalize(nested,record_path ='article')

article

Dagli output sopra, puoi osservare che le chiavi primarie sono ora divise in due dataframe diversi, in cui i nomi delle colonne sono diventati le chiavi che erano annidate dentro le chiavi primarie come coppie chiave-valore. Fantastico, no?

Infine, per chiudere la parte sul caricamento dei dati JSON, vediamo rapidamente come puoi leggere JSON come file e non come stringa.

• Lettura di un JSON come file

nested_json = {
   "article": [

      {
         "id":"01",
         "language": "JSON",
         "edition": "first",
         "author": "Allen"
      },

      {
         "id":"02",
         "language": "Python",
         "edition": "second",
         "author": "Aditya Sharma"
      }
   ],

   "blog":[
   {
       "name": "Datacamp",
       "URL":"datacamp.com"
   }
   ]
}

Se noti nella cella sopra, non ci sono doppi apici all'inizio e alla fine dei dati, il che significa che tratterai questi dati come un file e li leggerai.

Puoi riuscirci con una sola riga di codice. Vediamo come!

json_file = pd.DataFrame.from_dict(json_normalize(nested_json))

json_file

Dall'output sopra, puoi vedere che il risultato è simile a quando leggi JSON come stringa. L'unica differenza qui è che usi pandas sia per effettuare il parsing sia per appiattire il JSON. Poiché il JSON è un dizionario, usi la funzione .from_dict().

Caricare dati HTML

HTML è un linguaggio di markup (Hypertext Markup Language) usato principalmente per creare applicazioni e pagine web. Cerca di descrivere semanticamente la struttura della pagina web. Il browser riceve un documento HTML da un server web e lo rende in una pagina multimediale.

Per le applicazioni web, HTML è usato con i fogli di stile a cascata (CSS), mentre lato server collabora con vari framework come Flask, Django, ecc.

HTML usa i tag per definire ogni blocco di codice, come il tag <p></p> per l'inizio e la fine di un paragrafo, il tag <image></image> per aggiungere contenuti come immagine alla pagina web e così via: ci sono molti tag che insieme compongono una pagina HTML.

Per leggere un file HTML, il dataframe di pandas cerca un tag. Quel tag è chiamato <td></td>. Questo tag è usato per definire una tabella in HTML.

pandas usa read_html() per leggere il documento HTML.

Quindi, ogni volta che passi un HTML a pandas e ti aspetti che restituisca un bel dataframe, assicurati che la pagina HTML contenga una tabella!

• Informazioni sui dati: userai un sito di Cryptocurrency come dataset HTML che contiene varie crypto e diversi dettagli su ciascuna, come:
  • Ultimo prezzo della coin (Last price)
  • Se il prezzo è aumentato o diminuito (in percentuale %)
  • Il volume delle 24 ore (quante coin sono state scambiate 24 volume)
  • Numero totale di coin (# Coins)

Iniziamo!

Per prima cosa importerai la libreria requests, che ti aiuterà a inviare una richiesta all'URL da cui vuoi recuperare il contenuto HTML.

import requests

url = 'https://www.worldcoinindex.com/'

crypto_url = requests.get(url)

crypto_url

<Response [200]>

Finora hai definito l'URL e, utilizzando requests.get(), hai inviato una richiesta a quell'URL e ricevuto una risposta come acknowledgement [200] OK, il che significa che sei riuscito a connetterti a quel server web.

Ora, per leggere il contenuto della pagina HTML, ti basta chiamare crypto_url.text, che ti darà il codice HTML di quella pagina di cryptocurrency.

Sentiti libero di eseguire il comando crypto_url.text per vedere l'output.

Infine, passerai crypto_url.text alla funzione pd.read_html(), che ti restituirà una lista di dataframe in cui ogni elemento è una tabella (dataframe) presente nella pagina di cryptocurrency.

crypto_data = pd.read_html(crypto_url.text)

Stampiamo la lunghezza e il tipo del dataframe. Il tipo dovrebbe essere una lista.

len(crypto_data), type(crypto_data)

(1, list)

Dall'output sopra è chiaro che c'è una sola tabella con tipo list.

crypto_data = crypto_data[0]

Rimuoviamo la prima e la seconda colonna, dato che non contengono informazioni utili, e teniamo tutte le righe.

crypto_final = crypto_data.iloc[:,2:]

Finalmente è il momento di stampare il dataframe di cryptocurrency!

crypto_final.head()

Dalla tabella sopra, puoi osservare che Bitcoin ha la Market Cap più alta.

Eliminare NaN (Not a Number)

Ci sono alcuni valori nel dataframe che non sono reali, quindi rimuoviamoli rapidamente dalla tabella.

Prima, però, eliminiamo del tutto la colonna Price Charts 7d dato che è interamente NaN e non contiene alcuna informazione.

del crypto_final['Price Charts 7d']

crypto_final.head()

Ora rimuoviamo i NaN.

crypto_final = crypto_final.dropna()

Visualizzare le crypto (Ticker) vs. variazione percentuale del prezzo (%)

Importiamo prima matplotlib per tracciare il grafico.

import matplotlib.pyplot as plt
%matplotlib inline

La colonna % è di tipo string e devi convertirla in float. Per prima cosa rimuoverai il simbolo % dalla colonna e poi convertirai il tipo della colonna % in float.

crypto_final['%'] = crypto_final['%'].apply(lambda x: x.strip('%'))

crypto_final['%'] = crypto_final['%'].astype('float')

Ora tracciamo i dati.

plt.figure()
plt.figure(figsize=(16,10))
x = crypto_final.iloc[:20]['Ticker']
y = crypto_final.iloc[:20]['%']
plt.xticks(fontsize=12)
plt.yticks(fontsize=14)
plt.xlabel('Percentage Increase/Decrease in Price',fontsize=20)
plt.ylabel('Ticker',fontsize=20)

plt.plot(x,y,label='% Increase/Decrease in Price')
plt.legend(loc='lower left',prop={'size': 15})

<matplotlib.legend.Legend at 0x1298a9630>

<Figure size 432x288 with 0 Axes>

Dal grafico sopra, puoi osservare che Litecoin (LTC) e Huobitoken (HT) hanno l'aumento massimo del prezzo e, dall'altra parte, Maticnetwork (MATIC) e Waves hanno la diminuzione massima del prezzo delle crypto.

Caricare dati Pickle

Pickle è un formato di serializzazione binaria specifico di Python che, a differenza di JSON, non è leggibile dall'uomo. È usato per serializzare e deserializzare una struttura di oggetti di Python. Serializza l'oggetto e lo "pickle" per salvarlo su disco. Converte oggetti come DataFrame, liste, dizionari, ecc. in un flusso di caratteri.

La cosa migliore di Pickle è che può memorizzare vari tipi di dati Python.

Pickle è ampiamente usato per memorizzare istanze di algoritmi di machine learning addestrati. Come JSON, Pickle ha anche funzioni comode come pickle.load() per caricare un file in formato Pickle e pickle.dump() per salvare un oggetto Pickle o qualsiasi altro formato in formato Pickle.

Un altro importante vantaggio dell'uso di Pickle è che salvare il dataframe come file Pickle richiede meno spazio su disco e mantiene intatto il tipo dei dati al momento del ricaricamento.

Quindi, facciamo rapidamente il pickle del dataframe delle criptovalute che hai costruito in precedenza e poi leggerai quell'oggetto pickled usando pandas.

import pickle

Userai pickle.dump per salvare il dataframe come oggetto Pickle e utilizzerai il protocol HIGHEST_PROTOCOL, che è anche retrocompatibile con Python 2.

with open('crypto_final.pickle', 'wb') as sub_data:
    pickle.dump(crypto_final, sub_data, protocol=pickle.HIGHEST_PROTOCOL)

Infine, userai la funzione read_pickle di pandas per convertire l'oggetto pickle in un dataframe.

crypto_final = pd.read_pickle('crypto_final.pickle')

crypto_final.head()

Wow! Non è fantastico? Quanto è stato semplice. Inoltre, con Pickle non devi preoccuparti degli errori di conversione dei tipi di dato, perché la serializzazione pickle può gestirli per te!

Approfondisci

Congratulazioni per aver completato il tutorial.

Questo tutorial è stato un buon punto di partenza su come caricare diversi formati di dati in Python con l'aiuto di pandas.

Ci sono ancora molti formati di dati come Excel, SQL, HDF5, ecc., che rientrano nell'ombrello dell'import dei dati in pandas. Dovresti far pratica con essi trovando dataset pubblici interessanti in questi formati e provando a sperimentarli.

Se vuoi saperne di più sui DataFrame in pandas, segui il corso interattivo di DataCamp data manipulation with pandas. DataCamp ha anche diversi utili tutorial su pandas che coprono unire i dataframe, implementare le medie mobili e usare il metodo apply. Oppure, se sei completamente nuovo a pandas, inizia con questa guida per principianti a pandas. 

Riferimenti:

• Dati JSON in Python
• Tutorial su pandas: importare dati con read_csv()

Per favore, sentiti libero di fare qualsiasi domanda relativa a questo tutorial nella sezione commenti qui sotto.