Cómo importar datos JSON y HTML en pandas

Introducción

Importar datos es uno de los pasos más esenciales y, a la vez, de los primeros en cualquier problema relacionado con datos. Saber importar los datos correctamente es una habilidad imprescindible para toda persona que aspire a ser data scientist.

Los datos existen en muchos formatos distintos; no solo debes saber cómo importarlos, sino también analizarlos y manipularlos para extraer conclusiones útiles.

pandas es una librería de Python de código abierto, fácil de usar y de alto rendimiento, pensada para el análisis de datos en varios formatos.

Te permite leer distintos tipos de formatos como CSV, JSON, Excel, Pickle, etc. Representa los datos en una tabla de filas y columnas, lo que facilita su lectura y presentación.

pandas representa los datos en forma de DataFrame y te ofrece un amplio abanico de posibilidades para el análisis y la manipulación de datos. Cuando empieces a dar sentido a tus datos con las distintas funcionalidades de pandas, podrás usarlos para analizar, predecir, clasificar ¡y mucho más!

pandas cuenta con una API de entrada y salida con un conjunto de funciones de alto nivel de lectura y escritura. La función de lectura se accede con pandas.read_json(), que devuelve un objeto de pandas, y la de escritura con pandas.to_json(), que es un método de objeto.

DataFrame dispone de funciones de lectura y escritura. La función de lectura permite abrir distintos formatos de datos, mientras que la de escritura te permite guardarlos en un formato concreto.

Estos son los formatos de datos que admite DataFrame; si tus datos están en cualquiera de ellos, puedes usar pandas para cargarlos e incluso guardarlos en un formato específico.

En el tutorial de hoy, trabajarás con algunos de los tipos anteriores como JSON, HTML y Pickle.

Nota: Echa un vistazo a este tutorial para aprender a leer archivos CSV con pandas.

Cargar datos JSON

JSON, también conocido como JavaScript Object Notation, es un formato de serialización de texto para el intercambio de datos. JSON es fácil de leer y escribir. Se basa en un subconjunto del lenguaje de programación JavaScript, pero usa convenciones de Python y de muchos otros lenguajes.

JSON se usa sobre todo para almacenar datos no estructurados, y a las bases de datos SQL les cuesta manejarlo. JSON hace que los datos sean accesibles para las máquinas.

JSON se construye principalmente sobre dos estructuras:

• Una colección de pares clave/valor. En Python, un par clave/valor se denomina Dictionary; una clave es un atributo único, mientras que los valores no tienen por qué serlo.

• Una lista ordenada de valores. La lista ordenada puede ser, a su vez, una lista de listas. En Python, las listas son un conjunto de valores que pueden ser cadenas, enteros, etc.

Veamos ahora cómo puedes cargar datos JSON de varias formas.

El primer conjunto de datos JSON está en este enlace. Los datos siguen un formato de diccionario clave-valor. Hay un total de tres claves: integer, datetime y category.

• Primero importa la librería pandas y pasa la URL a pd.read_json(), que devolverá un dataframe. Las columnas del dataframe representan las claves, y las filas son los valores del JSON.

import pandas as pd

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

Imprimamos rápidamente las últimas filas del JSON que leíste con la función .tail().

json.tail(6)

json.shape

(100, 3)

Como ves en la salida, hay tres columnas: integer, datetime y category. Además, el conjunto de datos tiene 100 muestras, como confirma el método .shape, que devuelve 100 x 3.

• Escribir un JSON

Guardar datos en JSON es tan sencillo como leerlos y se hace con una sola línea. En lugar de read_json() usarás to_json() con un nombre de archivo y ¡listo!

json.to_json('dataframe.json')

• Analizar un JSON anidado como cadena

Ahora usarás otro tipo de conjunto de datos JSON, que no es tan simple: una estructura de JSON anidado. En un JSON anidado, cada key puede tener asociadas más keys.

Veamos el ejemplo para entenderlo mejor.

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"
   }
   ]
}"""

En el conjunto de datos anterior, puedes observar que article y blog son dos claves principales bajo las que aparecen los valores correspondientes. Esos valores tienen a su vez su propia combinación de clave-valor.

Ten en cuenta que el conjunto de datos anterior está encerrado entre comillas dobles y tiene forma de cadena.

Leer un JSON anidado puede hacerse de varias formas.

Primero usarás la función json.loads para leer una cadena JSON pasando la variable con los datos como parámetro. Después, usarás la función json_normalize para aplanar el JSON anidado en una tabla.

Importarás la función json_normalize de la librería 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'}]}

A continuación, aplanarás el JSON con la función normalize. Por ahora, pasarás todos los datos y verás cómo queda.

nested_full = json_normalize(nested)

nested_full

¡Genial! Como ves en la salida, las claves principales son las columnas del dataframe, mientras que las claves internas quedan como valores en las filas.

Sin embargo, el resultado se ve un poco tosco, ¿verdad? Veamos cómo dividirlo en varios dataframes.

De nuevo pasarás la salida de json.loads a json_normalize, pero esta vez especificando un elemento adicional llamado record_path.

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

blog

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

article

Como puedes ver, las claves principales ahora se han dividido en dos dataframes distintos, donde los nombres de columna pasan a ser las claves que estaban anidadas dentro de las claves principales como pares clave-valor. Increíble, ¿verdad?

Para terminar con la carga de datos JSON, veamos rápidamente cómo leer JSON como archivo y no como cadena.

• Leer un JSON como archivo

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"
   }
   ]
}

Si te fijas, en la celda anterior no hay comillas dobles al principio y al final, lo que significa que trataremos estos datos como un archivo y los leeremos así.

Puedes conseguirlo con solo una línea de código. ¡Veamos cómo!

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

json_file

Como ves, la salida es similar a cuando lees JSON como cadena. La única diferencia es que aquí usas pandas tanto para analizar como para aplanar el JSON. Como el JSON es un diccionario, utilizas la función .from_dict().

Cargar datos HTML

HTML es el Lenguaje de Marcado de Hipertexto que se usa principalmente para crear páginas y aplicaciones web. Describe la estructura de la página de forma semántica. El navegador recibe un documento HTML desde un servidor web y lo renderiza como una página multimedia.

En aplicaciones web, HTML se usa junto con las hojas de estilo en cascada (CSS), mientras que en el lado del servidor colabora con distintos frameworks como Flask, Django, etc.

HTML utiliza etiquetas para definir cada bloque de código, como la etiqueta <p></p> para el inicio y el fin de un párrafo, la etiqueta <image></image> para añadir una imagen a la página, y así con muchas otras que, en conjunto, forman una página HTML.

Para leer un archivo HTML, el dataframe de pandas busca una etiqueta. Esa etiqueta es <td></td>, usada para definir una tabla en HTML.

pandas utiliza read_html() para leer el documento HTML.

Así que, cuando pases HTML a pandas y esperes un dataframe bien formateado, asegúrate de que la página HTML contenga una tabla.

• Sobre los datos: vas a usar una web de Cryptocurrency como conjunto HTML que lista varias criptomonedas y detalles de cada una, como:
  • Último precio de la moneda (Last price)
  • Si el precio ha subido o bajado (en porcentaje %)
  • Volumen de 24 horas (cuántas monedas se negociaron, 24 volume)
  • Número total de monedas (# Coins)

¡Vamos allá!

Primero importarás la librería requests, que te ayudará a enviar una petición a la URL desde la que quieres obtener el contenido HTML.

import requests

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

crypto_url = requests.get(url)

crypto_url

<Response [200]>

Hasta ahora, has definido la URL y, con requests.get(), has enviado una petición a esa URL y recibido una respuesta de acknowledgement [200] OK, lo que significa que has podido conectar con ese servidor web.

Para leer el contenido de la página HTML, basta con llamar a crypto_url.text, que te devolverá el código HTML de esa página de cryptocurrency.

Si quieres, ejecuta el comando crypto_url.text para ver la salida.

Por último, pasarás crypto_url.text a la función pd.read_html(), que te devolverá una lista de dataframes en la que cada elemento es una tabla (dataframe) presente en la página de cryptocurrency.

crypto_data = pd.read_html(crypto_url.text)

Imprimamos la longitud y el tipo del objeto. El tipo debería ser una lista.

len(crypto_data), type(crypto_data)

(1, list)

Por la salida, queda claro que solo hay 1 tabla y que el tipo es lista.

crypto_data = crypto_data[0]

Eliminemos la primera y la segunda columna, ya que no aportan información útil, y conservemos todas las filas.

crypto_final = crypto_data.iloc[:,2:]

¡Hora de imprimir el dataframe de cryptocurrency!

crypto_final.head()

En la tabla anterior puedes observar que Bitcoin tiene la mayor Market Cap.

Eliminar NaN (Not a Number)

Hay algunos valores en el dataframe que no son valores reales, así que vamos a quitarlos de la tabla.

Primero, eliminemos por completo la columna Price Charts 7d, ya que es totalmente NaN y no aporta nada.

del crypto_final['Price Charts 7d']

crypto_final.head()

Ahora quitemos los NaN.

crypto_final = crypto_final.dropna()

Visualizar las criptomonedas (Ticker) vs. variación porcentual del precio (%)

Primero importa matplotlib para trazar el gráfico.

import matplotlib.pyplot as plt
%matplotlib inline

La columna % es de tipo string y necesitas convertirla a float. Primero eliminarás el signo % de la columna y luego convertirás el tipo de % a float.

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

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

Ahora, tracemos los datos.

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>

En el gráfico puedes observar que Litecoin (LTC) y Huobitoken (HT) tienen el mayor incremento de precio y, por otro lado, Maticnetwork (MATIC) y Waves muestran la mayor caída.

Cargar datos Pickle

Pickle es un formato de serialización binaria específico de Python que, a diferencia de JSON, no es legible para humanos. Se usa para serializar y deserializar estructuras de objetos de Python. Serializa el objeto y lo guarda (lo "picklea") en disco. Convierte objetos como DataFrame, listas, diccionarios, etc., en un flujo de bytes.

La gran ventaja de Pickle es que puede almacenar muchos tipos de datos de Python.

Pickle se usa ampliamente para guardar instancias de algoritmos de machine learning entrenados. Igual que JSON, Pickle tiene funciones muy útiles como pickle.load() para cargar un archivo en formato Pickle y pickle.dump() para guardar en formato Pickle.

Otra ventaja importante de usar Pickle es que guardar el dataframe como archivo Pickle ocupa menos espacio en disco y mantiene el tipo de los datos intacto al recargarlo.

Así que, vamos a pickle rápidamente el dataframe de criptomonedas que creaste antes y luego leeremos ese objeto pickled con pandas.

import pickle

Usarás pickle.dump para guardar el dataframe como objeto Pickle y el protocol será HIGHEST_PROTOCOL, que también es compatible con Python 2.

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

Por último, usarás la función read_pickle de pandas para convertir el objeto pickle en un dataframe.

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

crypto_final.head()

¡Guau! ¿A que es estupendo? Ha sido muy directo. Además, con Pickle no tienes que preocuparte por errores de conversión de tipos, ya que la serialización pickle se encarga de ello.

Sigue aprendiendo

Enhorabuena por completar el tutorial.

Este tutorial es un buen punto de partida para aprender a cargar distintos formatos de datos en Python con la ayuda de pandas.

Todavía hay muchos formatos de datos como Excel, SQL, HDF5, etc., que entran bajo el paraguas de importación de datos de pandas. Te animamos a practicar con ellos buscando conjuntos de datos públicos interesantes en esos formatos y haciendo pruebas.

Si te gustaría aprender más sobre DataFrames en pandas, haz el curso interactivo de DataCamp data manipulation with pandas. DataCamp también tiene otros tutoriales prácticos sobre pandas que cubren unión de dataframes, medias móviles y uso del método apply. O, si eres completamente nuevo en pandas, empieza con esta guía para principiantes.

Referencias:

• JSON Data in Python
• pandas Tutorial: Importing Data with read_csv()

No dudes en dejar cualquier pregunta relacionada con este tutorial en la sección de comentarios de abajo.