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')
Tecnologia

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

json.tail(6)
Tecnologia

json.shape
Tecnologia

(100, 3)
Tecnologia

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')
Tecnologia

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

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

nested
Tecnologia

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

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

nested_full
Tecnologia

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')
Tecnologia

blog
Tecnologia

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

article
Tecnologia

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

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

json_file
Tecnologia

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
Tecnologia

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

crypto_url = requests.get(url)
Tecnologia

crypto_url
Tecnologia

<Response [200]>
Tecnologia

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

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

len(crypto_data), type(crypto_data)
Tecnologia

(1, list)
Tecnologia

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

crypto_data = crypto_data[0]
Tecnologia

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:]
Tecnologia

Hora de imprimir o dataframe de cryptocurrency!

crypto_final.head()
Tecnologia

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']
Tecnologia

crypto_final.head()
Tecnologia

Agora vamos remover os NaN.

crypto_final = crypto_final.dropna()
Tecnologia

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
Tecnologia

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('%'))
Tecnologia

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

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})
Tecnologia

<matplotlib.legend.Legend at 0x1298a9630>

<Figure size 432x288 with 0 Axes>
Tecnologia

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
Tecnologia

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

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

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

crypto_final.head()
Tecnologia

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.