Como importar dados JSON e HTML no pandas

Introdução

Importar dados é um dos passos mais essenciais — e geralmente o primeiro — em qualquer projeto de dados. Saber trazer as informações corretamente é uma habilidade indispensável para todo aspirante a cientista de dados.

Os dados existem em muitos formatos diferentes e, além de saber como importá-los, você também precisa entender como analisá-los e manipulá-los para extrair insights úteis.

pandas é uma biblioteca open source de Python, fácil de usar, com alta performance e que oferece ferramentas de análise para diversos formatos de dados.

Ela permite ler vários tipos de formatos como CSV, JSON, Excel, Pickle etc. Com o pandas, você representa seus dados em uma estrutura tabular de linhas e colunas, o que torna tudo mais legível e apresentável.

O pandas representa os dados como um DataFrame e oferece recursos amplos para análise e manipulação. Quando você começa a extrair sentido dos dados usando as funcionalidades do pandas, pode então partir para análises, previsões, classificações e muito mais!

O pandas tem uma API de entrada e saída com um conjunto de funções de alto nível: reader e writer. A função de leitura é acessada com pandas.read_json(), que retorna um objeto pandas, e a de escrita com pandas.to_json(), que é um método de objeto.

O DataFrame tem funções de Reader e Writer. A função Reader permite ler diferentes formatos de dados, enquanto a Writer salva os dados em um formato específico.

Abaixo estão os formatos suportados pelo DataFrame. Se seus dados estiverem em qualquer um deles, você pode usar o pandas para carregar e até gravar nesse formato.

No tutorial de hoje, vamos trabalhar com alguns desses formatos: JSON, HTML e Pickle.

Observação: confira este tutorial para aprender a ler arquivos CSV com pandas.

Carregando dados JSON

JSON, também conhecido como JavaScript Object Notation, é um formato de serialização de texto para intercâmbio de dados. JSON é fácil de ler e escrever. Ele é baseado em um subconjunto da linguagem JavaScript, mas usa convenções familiares a Python e muitas outras linguagens.

JSON é usado principalmente para armazenar dados não estruturados, o que pode dificultar o salvamento em bancos SQL. Por outro lado, o JSON torna os dados acessíveis para leitura por máquinas.

JSON é construído principalmente sobre duas estruturas:

• Uma coleção de pares chave/valor. Em Python, um par chave/valor é um Dictionary; a key é um atributo único, enquanto os valores não precisam ser.

• Uma lista ordenada de valores, que às vezes pode ser uma lista de listas. Listas em Python são conjuntos de valores como strings, inteiros etc.

Vamos ver agora como carregar dados em JSON de várias maneiras.

O primeiro conjunto de dados em JSON está neste link. Os dados estão no formato dicionário de chave-valor. Existem três chaves: integer, datetime e category.

• Primeiro, importe a biblioteca pandas e passe a URL para pd.read_json(), que vai retornar um dataframe. As colunas representam as chaves e as linhas são os valores do JSON.

import pandas as pd

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

Vamos imprimir rapidamente as últimas linhas do JSON que você leu usando a função .tail().

json.tail(6)

json.shape

(100, 3)

Pelo resultado acima, dá para ver que há três colunas: integer, datetime e category. Também existem 100 amostras no dataset, como confirma o método .shape, que retornou 100 x 3.

• Escrevendo um JSON

Gravar dados em JSON é tão simples quanto ler — é uma linha de código. Em vez de read_json(), use to_json() com um nome de arquivo e pronto!

json.to_json('dataframe.json')

• Fazendo o parsing de JSON aninhado como string

Agora vamos usar outro tipo de dataset em JSON, menos trivial: um nested JSON (JSON aninhado). Isso significa que cada key pode ter outras keys associadas a ela.

Veja o exemplo para entender melhor.

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

No dataset acima, repare que article e blog são duas chaves primárias sob as quais existem valores. Esses valores têm seus próprios pares chave-valor.

Note que o dataset está entre aspas duplas e no formato de string.

Há várias formas de ler um JSON aninhado.

Primeiro, use a função json.loads para ler uma string JSON passando a variável como parâmetro. Em seguida, use json_normalize para “achatar” o JSON aninhado em uma tabela.

Você vai importar a função json_normalize da biblioteca 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'}]}

Agora, vamos achatar o JSON usando a função normalize. Por enquanto, passe todos os dados e veja como fica.

nested_full = json_normalize(nested)

nested_full

Perfeito! Como dá para ver, as chaves primárias viraram as colunas do dataframe, enquanto os valores são representados nas linhas.

Só que a saída ficou meio confusa, né? Vamos dividir em múltiplos dataframes.

Desta vez, passe a saída de json.loads para json_normalize especificando um elemento extra chamado record_path.

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

blog

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

article

Pelas saídas acima, você vê que as chaves primárias agora foram divididas em dois dataframes, e os nomes das colunas viraram as chaves que estavam aninhadas dentro das chaves primárias. Legal, né?

Para fechar a parte de JSON, vamos ver rapidamente como ler JSON como arquivo — e não como string.

• Lendo um JSON como arquivo

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

Repare que, neste caso, não há aspas duplas no início e no fim — ou seja, vamos tratar esses dados como arquivo ao ler.

Você faz isso com uma única linha de código. Veja:

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

json_file

Como você pode ver, a saída é semelhante à leitura do JSON como string. A única diferença é que usamos o pandas para fazer o parsing e achatar o JSON. Como o JSON é um dicionário, usamos .from_dict().

Carregando dados HTML

HTML é a linguagem de marcação de hipertexto usada principalmente para criar páginas e aplicativos web. Ela descreve a estrutura da página de forma semântica. O navegador recebe um documento HTML do servidor web e o renderiza como uma página multimídia.

Em aplicações web, o HTML é usado junto com CSS; no lado do servidor, colabora com frameworks como Flask, Django etc.

O HTML usa tags para definir cada bloco de código, como a tag <p></p> para início e fim de um parágrafo, a tag <image></image> para inserir imagens e muitas outras que, juntas, formam uma página HTML.

Para ler um arquivo HTML, o DataFrame do pandas procura uma tag específica: a <td></td>, usada para definir uma tabela em HTML.

O pandas usa read_html() para ler o documento HTML.

Portanto, sempre que você passar um HTML para o pandas esperando um dataframe bonito, garanta que a página tenha uma tabela!

• Sobre os dados: vamos usar um site de Cryptocurrency como dataset HTML, que lista várias moedas e traz detalhes como:
  • Último preço da moeda (Last price)
  • Se o preço subiu ou caiu (em porcentagem %)
  • Volume de 24 horas (quantas moedas foram negociadas, 24 volume)
  • Total de moedas (# Coins)

Bora começar!

Primeiro, importe a biblioteca requests, que vai ajudar a enviar uma solicitação para a URL de onde você quer buscar o HTML.

import requests

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

crypto_url = requests.get(url)

crypto_url

<Response [200]>

Até aqui, você definiu a URL e, com requests.get(), enviou uma solicitação e recebeu um acknowledgement [200] OK, indicando conexão bem-sucedida com o servidor web.

Agora, para ler o conteúdo da página, basta chamar crypto_url.text, que retorna o código HTML daquela página de cryptocurrency.

Fique à vontade para executar crypto_url.text e ver a saída.

Por fim, passe crypto_url.text para pd.read_html(). A função retorna uma lista de dataframes, em que cada elemento da lista é uma tabela (dataframe) existente na página de cryptocurrency.

crypto_data = pd.read_html(crypto_url.text)

Vamos imprimir o length e o type do objeto retornado. O type deve ser uma lista.

len(crypto_data), type(crypto_data)

(1, list)

Pelo resultado, fica claro que existe apenas 1 tabela e o tipo é lista.

crypto_data = crypto_data[0]

Vamos remover a primeira e a segunda colunas, que não trazem informação útil, mantendo todas as linhas.

crypto_final = crypto_data.iloc[:,2:]

Hora de imprimir o dataframe de cryptocurrency!

crypto_final.head()

Pela tabela acima, dá para observar que o Bitcoin tem o maior Market cap.

Removendo NaN (Not a Number)

Existem alguns valores no dataframe que não são valores reais, então vamos removê-los.

Antes, vamos excluir por completo a coluna Price Charts 7d, já que ela é totalmente NaN e não agrega informação.

del crypto_final['Price Charts 7d']

crypto_final.head()

Agora vamos remover os NaN.

crypto_final = crypto_final.dropna()

Visualizando as criptomoedas (Ticker) vs. variação em preço (%)

Primeiro, importe o matplotlib para desenhar o gráfico.

import matplotlib.pyplot as plt
%matplotlib inline

A coluna % está como string e você precisa convertê-la para float. Comece removendo o símbolo % e depois faça a conversão de tipo.

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

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

Agora vamos plotar os dados.

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>

No gráfico acima, você observa que Litecoin (LTC) e Huobitoken (HT) tiveram o maior aumento de preço, enquanto Maticnetwork (MATIC) e Waves tiveram a maior queda.

Carregando dados Pickle

Pickle é um formato binário de serialização específico do Python, diferente do JSON por não ser legível por humanos. Ele é usado para serializar e desserializar estruturas de objetos do Python. O processo converte objetos como DataFrame, lista, dicionário etc. em um fluxo de bytes e os salva em disco.

O grande benefício do Pickle é poder armazenar vários tipos de dados do Python.

Pickle é amplamente usado para armazenar instâncias de modelos de machine learning treinados. Assim como no JSON, o Pickle oferece funções práticas como pickle.load() para carregar um arquivo Pickle e pickle.dump() para salvar objetos no formato Pickle.

Outra vantagem importante do Pickle é que salvar o dataframe como Pickle ocupa menos espaço em disco e mantém o tipo dos dados intacto ao recarregar.

Então, vamos rapidamente fazer o pickle do dataframe de criptomoedas que você construiu e, em seguida, ler esse objeto pickled com o pandas.

import pickle

Use pickle.dump para salvar o dataframe como objeto Pickle e defina o protocol como HIGHEST_PROTOCOL, que também é compatível com Python 2.

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

Por fim, use pandas com read_pickle para converter o objeto pickle em um dataframe.

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

crypto_final.head()

Uau! Bem prático, né? E com Pickle você não precisa se preocupar com erros de conversão de tipo — a serialização em pickle resolve isso para você!

Vá além

Parabéns por concluir o tutorial.

Este foi um ótimo ponto de partida para carregar diferentes formatos de dados em Python com a ajuda do pandas.

Ainda há muitos formatos — como Excel, SQL, HDF5 etc. — que entram no guarda-chuva de importação do pandas. Vale explorar datasets públicos nesses formatos e experimentar.

Se quiser aprender mais sobre DataFrames no pandas, faça o curso interativo da DataCamp data manipulation with pandas. A DataCamp também tem vários tutoriais úteis sobre pandas, incluindo joining dataframes, implementing moving averages e using the apply method. Ou, se você é totalmente novo em pandas, comece por este guia para iniciantes.

Referências:

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

Fique à vontade para deixar suas dúvidas sobre este tutorial nos comentários abaixo.