Tutorial de visualização de dados com Python e Tableau

Por que usar Python com Tableau

O Tableau oferece várias opções para aumentar e criar novos campos de dados. Você pode executar funções aritméticas, lógicas, espaciais e de modelagem preditiva usando campos calculados. O Tableau é uma poderosa ferramenta de Business Intelligence (BI), mas tem limitações — é aí que a linguagem Python entra em cena.  

Python é uma linguagem muito popular na comunidade de dados. Você pode usá-la para extrair, limpar, processar e aplicar funções estatísticas complexas aos dados. Ela oferece frameworks de machine learning, orquestração de dados, multiprocessamento e bibliotecas ricas para realizar praticamente qualquer tarefa. 

Python é uma linguagem multipropósito, e usá-la com o Tableau dá liberdade para executar tarefas bem complexas. Neste tutorial, vamos usar Python para extrair e limpar os dados. Em seguida, vamos usar os dados limpos para criar visualizações no Tableau.

Não vamos usar o Tabpy para criar um servidor Python do Tableau e executar scripts Python dentro do Tableau. Em vez disso, primeiro vamos extrair e limpar os dados em Python (Jupyter Notebook) e depois usar o Tableau para criar visualizações interativas. 

Goodreads Data Viz | Tableau Public

Este é um tutorial passo a passo com código sobre a API do Goodreads e a criação de visualizações complexas no Tableau. Confira o link abaixo para acessar o código e o dashboard no Tableau. 

• Caderno no DataLab

• Tableau Public

Ingestão e processamento de dados com Python

Na primeira parte do tutorial, vamos aprender a usar a API do Goodreads para acessar dados públicos. No nosso caso, vamos focar no perfil do usuário e convertê-lo em um dataframe legível do pandas. Depois, vamos limpar os dados e exportá-los em formato CSV. 

Primeiros passos

Vamos usar o DataLab para rodar o código em Python. Ele já vem com os pacotes necessários para tarefas de ciência de dados. 

Se você é novo em Python e quer configurar o ambiente na sua máquina, instale o Anaconda. Ele instala o Python, o Jupyter Notebook e os pacotes necessários. 

Antes de começar a escrever o código, precisamos instalar o pacote xmltodict, pois ele não faz parte do stack do DataLab nem do Anaconda. Vamos usar o `pip` para instalar o pacote que está faltando.

Observação: o símbolo `!` funciona apenas em Jupyter Notebooks. Ele permite acessar o terminal dentro da célula de código do Jupyter. 

!pip install xmltodict

>>> Collecting xmltodict
>>>   Using cached xmltodict-0.13.0-py2.py3-none-any.whl (10.0 kB)
>>> Installing collected packages: xmltodict
>>> Successfully installed xmltodict-0.13.0

No próximo passo, vamos importar os pacotes necessários. 

import pandas as pd
import xmltodict
import urllib.request

Fazendo o parsing do link do perfil

Para extrair dados do usuário, precisamos do user id e do user name. Nesta seção, vamos analisar o link do perfil do usuário (Abid). 

Observação: você pode usar o perfil de um amigo ou o seu próprio link e rodar este script. 

1. Extraímos o user_id filtrando apenas os dígitos no link, o que retorna "73376016". 
2. Para extrair o user_name, vamos dividir a string no user_id e depois dividir por "-" para obter o usuário. Substituindo "-" por espaço, obtemos o nome "abid".
3. Por fim, vamos concatenar user_id com user_name. Esse id único será usado na próxima seção para acessar os dados do usuário.

Goodread_profile = "https://www.goodreads.com/user/show/73376016-abid"

user_id = ''.join(filter(lambda i: i.isdigit(), Goodread_profile))
user_name = Goodread_profile.split(user_id, 1)[1].split('-', 1)[1].replace('-', ' ')
user_id_name = user_id+'-'+user_name

print(user_id_name)

>>> 73376016-abid

Extração de dados do Goodreads

No fim de 2020, o Goodreads deixou de fornecer a API para desenvolvedores. Você pode ler o comunicado completo aqui. Para contornar isso, vamos usar chaves de API de projetos antigos como o streamlit_goodreads_app. O projeto explica como acessar os dados de usuário do Goodreads via API. 

O Goodreads também permite baixar os dados em CSV sem chave de API, mas é limitado ao próprio usuário e não oferece liberdade para extrair dados em tempo real. 

Nesta seção, vamos criar funções que recebem user_id_name, version, shelf, per_page e apiKey. 

• apiKey: usada para acessar os dados públicos
• version: para especificar o tipo de dado mais recente
• shelf: há várias prateleiras no perfil do usuário, principalmente read, to-read e currently-reading
• per_page: número de livros por página

A função recebe os parâmetros do usuário para montar a URL e depois faz o download dos dados usando urllib.request. Por fim, recebemos os dados em formato XML. 

apiKey = "ZRnySx6awjQuExO9tKEJXw"
version = "2"
shelf = "read"
per_page = "200"

def get_user_data(user_id, apiKey, version, shelf, per_page):
    api_url_base = "https://www.goodreads.com/review/list"
    final_url = (
        api_url_base
        + user_id
        + ".xml?key="
        + apiKey
        + "&v="
        + version
        + "&shelf="
        + shelf
        + "&per_page="
        + per_page
    )
    contents = urllib.request.urlopen(final_url).read()
    return contents
contents = get_user_data(user_id_name,apiKey,version, shelf, per_page)
print(contents[0:100])


>>> b'<?xml version="1.0" encoding="UTF-8"?>\n<GoodreadsResponse>\n  <Request>\n    <authentication>true</aut'

Convertendo XML para JSON

Nossos dados iniciais estão em XML e não há um jeito direto de convertê-los em um banco estruturado. Então, vamos transformá-los em JSON usando o pacote Python xmltodict. 

Os dados XML são convertidos em JSON aninhado e, para exibir a primeira entrada das resenhas de livros, vamos usar colchetes para acessar os dados encapsulados. 

Você pode explorar metadados e outras opções, mas neste tutorial vamos focar nos dados de resenhas dos usuários.  

contents_json = xmltodict.parse(contents)
print(contents_json["GoodreadsResponse"]["reviews"]["review"][:1])

>>> [{'id': '4626706284', 'book': {'id': {'@type': 'integer', '#text': '57771224'}, 'isbn': '1250809606', 'isbn13': '9781250809605', 'text_reviews_count': {'@type': 'integer', '#text': '150'}, 'uri': 'kca://book/amzn1.gr.book.v3.tcNoY0o7ErAhczdQ', 'title': 'Good Intentions', 'title_without_series': 'Good Intentions', 'image_url': .........

Convertendo JSON para dataframe do pandas 

Para converter o tipo JSON em dataframe do pandas, vamos usar a função json_normalize. Os dados de review estão no terceiro nível e, para acessá-los, vamos navegar por GoodreadsResponse, reviews e review.

Antes de exibir o dataframe, vamos filtrar dados irrelevantes descartando os livros sem a coluna date_updated. 

Aprenda várias formas de ingerir arquivos CSV, planilhas, JSON, bancos SQL e APIs com pandas no curso Streamlined Data Ingestion with pandas. 

df = pd.json_normalize(contents_json["GoodreadsResponse"]["reviews"]["review"])
df = df[df["date_updated"].notnull()]
df.head()

Limpeza dos dados

O dataframe bruto parece razoavelmente limpo, mas ainda precisamos reduzir o número de colunas. 

Como podemos ver, há 61 colunas.

df.shape
(200, 61)

Vamos remover as que estão vazias. 

df.dropna(axis=1, how='all', inplace=True)
df.shape
(200, 58)

Removemos com sucesso 3 colunas com valores ausentes.

Agora vamos verificar todos os nomes de colunas com `df.columns` e selecionar as mais úteis. 

final_df = df[
    [
        "rating",
        "started_at",
        "read_at",
        "date_added",
        "book.title",
        "book.average_rating",
        'book.ratings_count',
        "book.publication_year",
        "book.authors.author.name"
    ]
]
final_df.head()

Como dá para observar, o dataframe final está limpo e com os campos mais relevantes. 

Exportando o arquivo CSV

Na última seção, vamos exportar o dataframe para um arquivo CSV compatível com o Tableau. Na função to_csv, adicione o nome do arquivo com a extensão e remova o índice definindo o argumento index como False. 

final_df.to_csv("abid_goodreads_clean_data.csv",index=False)

O arquivo CSV aparecerá no diretório atual.

Arquivo CSV limpo do Goodreads

Você também pode conferir o Jupyter Notebook em Python: Ingestão de dados usando a API do Goodreads. Ele ajuda a depurar seu código e, se quiser pular a parte de programação em Python, basta clicar em Copy & Edit e rodar o script. 

Visualização de dados no Tableau

Na segunda parte, vamos usar os dados limpos e criar visualizações simples e complexas no Tableau. Nosso objetivo é plotar gráficos interativos para entender o comportamento de leitura do usuário. 

Conectando os dados

Vamos conectar o arquivo CSV selecionando a opção de arquivo Text e escolhendo o arquivo abid_goodreads_clean_data.csv. Depois, vamos alterar os campos Started At, Read At e Date Added para o tipo Date & Time, como mostrado abaixo. 

Observação: é uma boa prática ajustar os tipos dos campos logo no início.  

Conectando os dados e ajustando os tipos

Criando o histograma de avaliações

Nesta seção, vamos criar o histograma das avaliações do usuário. 

• Primeiro, arraste o campo Rating para a prateleira Rows. 

Histograma de avaliações — parte 1

• Clique no botão Show Me para acessar os modelos de visualização. Vamos converter o gráfico de barras em histograma clicando em Histogram.

Histograma de avaliações — parte 2

• O eixo de Rating tem marcas de 0,5. Altere as marcas clicando com o botão direito no eixo inferior e escolhendo Edit Axis. Depois, vá na aba Tick Marks e mude Major Tick Marks para Fixed. Garanta que o Tick Origin seja 0 e o Tick Interval seja 1.

Histograma de avaliações — parte 3

• Vamos personalizar o histograma limpando rótulos dos eixos, mudando cores e bordas das barras e adicionando rótulos. Você encontra essas opções no painel Marks, no meio à esquerda. 

Histograma de avaliações — parte 4

O usuário geralmente atribuiu notas entre 3 e 4. As notas zero são livros não avaliados. 

Gráfico de linhas

Para criar o gráfico de linhas:

1. Arraste o campo Book.Publication Year para as prateleiras Rows e Columns.
2. Mude o campo em Rows para contagem clicando com o botão direito e selecionando Measure > Count. 
3. Mude o campo em Columns para dimensão clicando com o botão direito e selecionando Dimensions.
4. No painel Marks, clique em Automatic e altere para Line. 
5. Limpe os rótulos dos eixos, personalize o gráfico, adicione título e remova valores nulos.
   
   

Gráfico de linhas por ano de publicação

O usuário leu alguns livros antigos, mas se interessa especialmente por obras publicadas entre 2015 e 2020. 

Se você ficou sobrecarregado e quer aprender os fundamentos do Tableau, o Tableau Tutorial for Beginners da Eugenia Anello pode ajudar. 

Boxplot

Para criar o box-and-whisker plot:

1. Arraste o campo Books.Ratings Count para Rows. Altere de Discrete para Continuous. 
2. Arraste o campo Books.Ratings Count para Detail no painel Marks. Mude de Measure para Dimension.
3. Clique em Show Me e selecione a opção de box-and-whisker plots. 
4. Mova o campo de Rows para Columns para deixá-lo horizontal. 
5. Finalize personalizando: aumente o tamanho, mude a cor, adicione um título e renomeie o eixo para "Popularity".

Boxplot do número de avaliações por livro

Parece que o usuário lê livros menos populares e alguns bem famosos. Isso indica um gosto próprio baseado no conteúdo, não na popularidade. 

Gráfico de bolhas

Criamos visualizações simples e úteis para entender o comportamento de leitura. Agora, vamos avançar para uma visualização mais complexa, que inclui criar um campo calculado, editar bins e trabalhar com múltiplas camadas.

No gráfico de bolhas, os rótulos representam quantos dias o usuário levou para terminar um livro, e o tamanho da bolha representa o número de ocorrências. Não temos um campo de duração, mas podemos criá-lo a partir de Started At e Read At.

No primeiro passo, crie um novo campo calculado clicando na seta para baixo no painel Data e escolhendo Create Calculated Field. 

Criando um campo calculado

Na nova janela, você deve:

1. Renomear o título para "Read Duration"
2. Usar a função DATEDIFF para obter a diferença entre Read At e Started At.
3. Garantir que o primeiro argumento da função seja "day".
4. Arrastar e soltar ou digitar os nomes dos campos entre colchetes como segundo e terceiro argumentos. 

Read Duration em dias

O campo Read Duration é contínuo e, para criar o gráfico de bolhas compactas (packed bubbles), precisamos dividir o campo em partes menores, os chamados bins. 

1. Arraste o novo campo `Read Duration` para a prateleira Rows.
2. Clique em Show Me e selecione histogram. Isso criará automaticamente um campo de bin.

Criação de um campo de bin 

1. Clique com o botão direito no campo recém-criado Read Duration (bin) e selecione a opção Read Duration in Days.
2. Altere o Size of Bins para 10. Isso criará partes menores que ajudarão a refinar o gráfico de bolhas compactas. 

Editando os bins

Passamos pela parte mais trabalhosa — hora de colher os frutos. 

1. Para a visualização simples, clique em Show Me e selecione packed bubbles. Você verá círculos de tamanhos diferentes, todos de uma cor. 
2. Para adicionar cores, arraste o campo Read Duration para Color no painel Marks. 
3. Mude o campo de cor para Count (Distinct) clicando com o botão direito no campo e selecionando Measure > Count (Distinct). Isso dará uma cor única a cada bin/etiqueta. 

Bolhas compactas — versão monocromática

1. Clique em Color no painel Marks e selecione Edit Colors… > Sunrise-Sunset Diverging. Você pode escolher qualquer gradiente que preferir. 
2. Finalize personalizando e garantindo que sua visualização esteja atraente e comunique a mensagem certa.

Bolhas compactas 

O usuário levou menos de um dia para terminar a maioria dos livros. Também é possível ver alguns outliers acima de 300. 

Também podemos criar um dashboard no Tableau combinando essas visualizações. Aprenda a criar um dashboard no Tableau neste tutorial.

Conclusão

Neste tutorial, vimos a importância do Python e como usá-lo com o Tableau. Na primeira parte, extraímos dados de usuários do Goodreads por meio da API para desenvolvedores e convertimos os dados XML em um dataframe do pandas limpo e estruturado. Na segunda parte, usamos os dados limpos para criar visualizações simples e complexas. 

A combinação de Python com Tableau abre um mundo de possibilidades. Você pode integrar pipelines de dados, implementar modelos de machine learning, rodar análises estatísticas complexas e executar várias tarefas que seriam inviáveis apenas no Tableau. 

Você pode rodar o código Python no DataLab gratuitamente — ele já vem com todos os pacotes necessários para este exemplo. Para criar as visualizações no Tableau, usamos a versão gratuita chamada Tableau Public.

Se você está começando em Python e quer aprender mais sobre funcionalidades e sintaxe, confira o curso Introduction to Data Science in Python. E você pode dominar o básico de visualização e customização no Tableau com a trilha de habilidades Tableau Fundamentals. Ela tem 5 cursos que cobrem a introdução ao Tableau, análise de dados, criação de dashboards interativos, um estudo de caso e conexão a múltiplas fontes de dados.