Tutorial de Plotly Express em Python: crie visualizações incríveis

Plotly não é só sobre criar visualizações bonitas; é sobre liberar todo o potencial dos seus dados e revelar insights que poderiam passar despercebidos. É a ponte entre a linguagem dos números e a linguagem das histórias, ajudando pessoas e organizações a tomarem decisões informadas e gerarem impacto de verdade.

É assim que o ChatGPT descreve o Plotly. E, convenhamos, Plotly é uma das melhores bibliotecas de visualização de dados que existem.

Ele cria gráficos superinterativos e visualmente impecáveis como o abaixo:

Hoje, você vai aprender os fundamentos para criar visuais incríveis com Plotly.

Fundamentos do Plotly Express

Como em qualquer tutorial, começamos instalando a biblioteca via pip (ou, se preferir, conda).

$ pip install --upgrade plotly
$ conda install -c conda-forge plotly

O Plotly recebe atualizações frequentes, então garanta que a flag --upgrade esteja incluída se você já tiver a biblioteca instalada.

Este tutorial foca na API Express do Plotly, lançada em 2019, que trouxe várias vantagens em relação às formas antigas de interagir com a biblioteca principal do Plotly:

• Sintaxe simples (quase como inglês natural)
• Grande variedade de visualizações (e ferramentas para você criar as suas)
• Escalonamento automático de eixos e cores
• Integração com pandas (você pode usar o backend de plotagem do Plotly na função .plot do pandas)

Aqui está a anatomia de um gráfico básico no Plotly Express:

import plotly.express as px

fig = px.plotting_function(
    dataframe,
    x='column-for-xaxis',
    y='column-for-yaxis',
    title='Title For the Plot',
    width=width_in_pixels,
    height=height_in_pixels
)

fig.show()

Tipos de gráficos diferentes ficam sob seus próprios nomes, como histogram ou scatter dentro do módulo express, importado como px. O primeiro argumento de qualquer função de plotagem é o dataframe, seguido pelos nomes das colunas a serem exibidas nos eixos X e Y.

Boas práticas pedem que você dê um title informativo aos seus gráficos, para que os leitores entendam do que se trata.

Quando a função de plotagem é executada, ela retorna um objeto Figure, sobre o qual você chama o método show para exibir o gráfico no seu notebook.

Para começar a criar gráficos, precisamos de um dataset. Neste tutorial, vamos usar o dataset Diamonds. Ele combina bem recursos numéricos e categóricos — perfeito para o objetivo deste artigo.

import pandas as pd

diamonds = pd.read_csv("data/diamonds.csv")

diamonds.head()

O dataset contém mais de 53 mil diamantes com 10 características físicas. Você pode explorar as estatísticas básicas dos dados abaixo.

diamonds.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 53940 entries, 0 to 53939
Data columns (total 10 columns):
#   Column   Non-Null Count  Dtype 
---  ------   --------------  ----- 
0   carat    53940 non-null  float64
1   cut      53940 non-null  object
2   color    53940 non-null  object
3   clarity  53940 non-null  object
4   depth    53940 non-null  float64
5   table    53940 non-null  float64
6   price    53940 non-null  int64 
7   x        53940 non-null  float64
8   y        53940 non-null  float64
9   z        53940 non-null  float64
dtypes: float64(6), int64(1), object(3)
memory usage: 4.1+ MB

diamonds.describe()

Uma das primeiras etapas ao fazer análise exploratória de dados (EDA) é explorar distribuições individuais.

O Plotly oferece muitos gráficos para essa tarefa: histogramas, boxplots, violinos, barras etc. Vamos ver alguns.

Histogramas no Plotly Express

O histograma provavelmente é o primeiro gráfico que muita gente aprende.

Ele ordena os valores de uma distribuição em intervalos (bins). Depois, usa barras para representar quantos valores caem em cada intervalo:

import plotly.express as px
​
fig = px.histogram(
  diamonds,
  x="price",
  title="Histograma dos preços dos diamantes",
  width=600,
  height=400,
)
​
fig.show()

Se você passar o mouse sobre qualquer barra, verá a faixa do intervalo correspondente. O Plotly determina automaticamente o número de bins, mas, se quiser definir manualmente, use o parâmetro nbins.

Porém, é difícil achar o número perfeito de bins para cada distribuição. Por isso, uma prática comum é definir o número de bins como a raiz quadrada do tamanho da distribuição:

# Encontrar o número apropriado de bins
nbins = int(len(diamonds) ** (1 / 2))
​
fig = px.histogram(
  diamonds,
  x="price",
  title="Histograma dos preços dos diamantes",
  nbins=nbins,
  width=600,
  height=400,
)
​
fig.show()

Gráficos de barras no Plotly Express

Histogramas analisam variáveis quantitativas. Para analisar dados categóricos, usamos gráficos de barras. Por exemplo, ao passar a coluna categórica cut para a função histogram, obtemos um tipo de barra chamado countplot. Sim, ele conta o número de observações em cada categoria.

fig = px.histogram(diamonds, x="cut")
​
fig.show()

Mas espera, faltaram rótulos no gráfico! Vamos corrigir isso com a função update_layout, que permite modificar vários aspectos da figura depois de criada.

fig.update_layout(
  title="Quantidade de diamantes em cada categoria de corte",
  xaxis_title="",
  yaxis_title="Contagem",
)

Você já sabe o que o title faz. Os parâmetros xaxis_title e yaxis_title substituem os rótulos dos eixos gerados pelo Plotly (que seriam apenas os nomes das colunas).

Agora, vamos ver o preço médio por categoria de corte de diamante. Primeiro, usamos o groupby do pandas:

mean_prices = (
    diamonds.groupby("cut")["price"].mean().reset_index()
)

mean_prices

Encadear reset_index ao final de uma operação groupby transforma a saída em um DataFrame — e o Plotly adora DataFrames. Então, vamos passá-lo para a função bar:

fig = px.bar(mean_prices, x="cut", y="price")
​
fig.update_layout(
  title="Preços médios dos diamantes por categoria de corte",
  xaxis_title="",
  yaxis_title="Preço médio ($)",
)
​
fig.show()

bar recebe uma variável categórica e outra numérica, criando uma barra para cada linha do DataFrame passado. O resultado é uma comparação agradável dos preços por tipo de diamante.

Boxplots no Plotly Express

Outro gráfico comum para analisar distribuições é o boxplot, criado com box no Plotly Express:

fig = px.box(diamonds, x="clarity", y="carat")
​
fig.update_layout(
  title="Distribuição de quilates por categoria de claridade",
  xaxis_title="Clarity",
  yaxis_title="Carat",
)
​
fig.show()

Em vez de criar barras que mostram apenas a média de quilates, o boxplot exibe várias estatísticas:

Você vê:

• mínimo/máximo
• mediana
• 25º percentil
• 75º percentil
• e outliers

para cada categoria de claridade.

Gráficos de violino no Plotly Express

Outro gráfico interessante para explorar distribuições é o violino. Ele é basicamente um boxplot com alguns reforços:

fig = px.violin(diamonds, x="cut", y="price")
​
fig.show()

Em vez da caixa, ele mostra uma curva suave indicando a densidade da variável. Para sobrepor um boxplot, basta definir o atributo box como True:

fig = px.violin(diamonds, x="cut", y="price", box=True)
​
fig.show()

Diferente do boxplot, que mostra apenas estatísticas-resumo, o violino também revela o formato da distribuição.

Visualizando relações entre variáveis no Plotly Express

Ao plotar variáveis relacionadas, novos padrões e insights começam a aparecer. Por exemplo, se partirmos do pressuposto de que o quilate (peso) é o principal fator que determina o preço do diamante, vamos explorar essa relação.

Scatterplots no Plotly Express

Podemos usar um scatterplot (px.scatter), que plota todos os diamantes como pontos. A posição dos pontos é determinada pelos valores de preço e quilate:

fig = px.scatter(diamonds, x="price", y="carat")
​
fig.update_layout(
  title="Preço vs. quilate",
  xaxis_title="Preço ($)",
  yaxis_title="Quilate",
)
​
fig.show()

Temos aqui um caso clássico de overplotting, que ocorre quando há dados demais para um único gráfico. Em vez de revelar padrões e tendências, o excesso de pontos os esconde.

Podemos resolver plotando apenas ~10% do dataset, o suficiente para revelar padrões existentes:

fig = px.scatter(
  diamonds.sample(5000), x="price", y="carat"
)
​
fig.update_layout(
  title="Preço vs. quilate",
  xaxis_title="Preço ($)",
  yaxis_title="Quilate",
)
​
fig.show()

Na chamada ao scatter, passamos apenas 5.000 linhas (.sample(5000)), o que mostra uma leve tendência de alta na relação preço–quilate.

Heatmaps no Plotly Express

Heatmaps são ótimos para visualizar conjuntos complexos, como uma matriz grande em que é difícil enxergar padrões olhando só os números nas células.

Um heatmap atribui cores com base na magnitude de cada célula da matriz. Um uso comum é visualizar a matriz de correlação de um dataset.

A correlação mede a relação linear entre variáveis numéricas. Assim, cada célula da matriz representa a correlação entre um par de variáveis.

Você pode calcular a matriz de correlação de qualquer conjunto usando o método corr do pandas, que retorna um DataFrame. Se você passá-lo para a função imshow do Express, terá um heatmap:

import plotly.express as px
​
# Criar heatmap com Plotly Express
fig = px.imshow(
  diamonds.corr(),
  color_continuous_scale="Inferno_r",
)
​
# Exibir o gráfico
fig.show()

A correlação varia de -1 a 1. Valores próximos às extremidades indicam uma relação linear forte (positiva ou negativa) entre as variáveis.

Estamos usando o mapa de cores Inferno invertido no parâmetro color_continuous_scale. Você pode escolher outros na página de escalas de cores da documentação do Plotly.

Personalizando gráficos no Plotly Express

Uma das melhores características da API do Plotly Express é a facilidade para personalizar gráficos.

A função update_layout traz muitos parâmetros para modificar praticamente qualquer aspecto dos seus charts.

Dependendo de onde seus gráficos serão exibidos, é sua responsabilidade deixá-los prontos para qualquer audiência, local ou mídia.

Uma das primeiras escolhas é o tema do gráfico. Temas no Plotly são configurações padrão que controlam praticamente todos os componentes.

Você pode mudar isso com o parâmetro template de qualquer função de plotagem:

sample = diamonds.sample(3000)
​
fig = px.scatter(
  sample, x="price", y="carat", template="ggplot2"
)
​
fig.show()

Alguns populares são ggplot2, seaborn, plotly_dark e presentation. Você pode ver a lista completa chamando plotly.io.templates.

Cores

Nossos scatterplots foram bidimensionais até aqui. Mas dá para adicionar mais informação por meio das cores.

Por exemplo, podemos colorir cada ponto conforme a categoria do diamante. Para isso, basta passar cut no parâmetro color:

sample = diamonds.sample(3000)
​
fig = px.scatter(sample, x="price", y="carat", color="cut")
​
fig.show()

O parâmetro color também adiciona uma legenda ao gráfico, mostrando as cores de cada categoria.

Tamanho do marcador

Outra abordagem é exibir uma variável numérica pelo tamanho dos pontos.

Definindo o parâmetro size como carat, temos pontos com tamanhos diferentes conforme o quilate:

fig = px.scatter(sample, x="price", y="x", size="carat")
​
fig.show()

E se usarmos cor e tamanho juntos? Claro!

fig = px.scatter(
  sample, x="price", y="x", size="carat", color="cut"
)
​
fig.show()

Mas este gráfico não é tão informativo, pois traz informação demais para o olho nu processar. Uma boa prática é não colocar mais de três variáveis em um único gráfico.

Conclusão

Parabéns por chegar até aqui! Você aprendeu o suficiente neste tutorial para seguir aprendendo Plotly com outros recursos nossos:

• Curso Introduction to data visualization with Plotly in Python
• Tutorial Data Visualization with Plotly in R
• Tutorial Creating histograms in Plotly

Você também pode conhecer a API Graph Objects do Plotly, para ainda mais personalização, controle total de interatividade e animações, e suporte a tipos avançados de visualização.