Boxplots em Python: Um guia abrangente para iniciantes

Você já se perguntou como representar melhor as distribuições de dados numéricos em Python? Bem, sua melhor opção seria aprender a usar boxplots! Os boxplots são uma ótima maneira de visualizar comparações de distribuição entre vários grupos.

Neste tutorial, abordaremos o que são boxplots, as diferentes maneiras de criá-los em Python e alguns erros comuns de iniciantes.

O que são boxplots em Python?

Os boxplots, também conhecidos como gráficos box-and-whisker, são uma forma padrão de exibir a distribuição de dados com base em um resumo de cinco números: mínimo, primeiro quartil (Q1), mediana, terceiro quartil (Q3) e máximo.

Os boxplots são particularmente úteis para identificar outliers e entender a dispersão e a assimetria dos dados. Eles também são usados na comparação de vários grupos ou na visualização da distribuição de uma única variável.

Componentes do boxplot

Um boxplot típico vem com vários componentes como parte de sua anatomia:

1. Mediana: Esse é o valor médio dos dados, representado por uma linha dentro da caixa.
2. Caixas: Eles representam o intervalo interquartil (IQR) dos dados, que representa o intervalo entre o Q1 e o Q3. As bordas inferior e superior representam Q1 e Q3, respectivamente.
3. Bigodes: Essas são linhas verticais que se estendem de cada extremidade da caixa para representar os valores mínimo e máximo, excluindo quaisquer valores discrepantes.
4. Excedentes: Esses são pontos fora dos bigodes considerados incomuns ou extremos em comparação com o restante dos dados.
5. Bonés: Essas são linhas horizontais nas extremidades dos bigodes, representando os valores mínimo e máximo, incluindo quaisquer valores discrepantes.

Esses componentes se combinam para dar significado estatístico ao boxplot e permitir comparações visuais fáceis entre diferentes grupos de dados.

O Python é uma ferramenta avançada que pode nos ajudar a criar boxplots. Nas seções a seguir, analisaremos diferentes métodos para fazer isso.

Boxplots em Python: Guia passo a passo

Agora que você tem uma compreensão básica dos boxplots, vamos ver como criá-los usando Python. Várias bibliotecas em Python, como Matplotlib, Seaborn e Plotly, oferecem suporte à criação de boxplots.

1. Instalação das bibliotecas necessárias

Para criar boxplots em Python, você deve primeiro instalar as bibliotecas necessárias. As principais bibliotecas necessárias são Matplotlib, Seaborn e Plotly.

Aqui está o código para instalá-los:

pip install matplotlib
pip install seaborn
pip install plotly==5.22.0

2. Importação de bibliotecas e carregamento de dados

Após a instalação, a próxima etapa é importar essas bibliotecas para o seu ambiente Python.

Certifique-se também de carregar os conjuntos de dados necessários que você usará para os boxplots, se houver.

#imports Matplotlib library and assigns shorthand 'plt'
import matplotlib.pyplot as plt
#imports Seaborn library and assigns shorthand 'sns'
import seaborn as sns
#imports Plotly library and assigns shorthand 'px'
import plotly.express as px

3. Criando boxplots do Matplotlib

Graças à versatilidade do Python, para criar um boxplot simples, você precisa de um código mínimo. Vamos começar com a biblioteca mais comum, Matplotlib.

1. Boxplot único do Matplotlib

Para criar um boxplot usando o Matplotlib, importe as bibliotecas necessárias:

import matplotlib.pyplot as plt
import numpy as np

Em seguida, vamos preparar um conjunto de dados simples:

# Generates some random dataset
np.random.seed(10) 
data = np.random.normal(0, 1, 100)

Por fim, vamos criar o boxplot real e imprimi-lo:

# Creates a boxplot
plt.boxplot(data) plt.title('Basic Boxplot') plt.show()

Aqui estão os resultados:

2. Vários boxplots do Matplotlib

Se quiser criar boxplots separados em subplots diferentes, você pode usar a função subplot. Isso permite que você crie vários boxplots lado a lado em uma única imagem. 

Aqui está o exemplo de código completo:

import matplotlib.pyplot as plt
import numpy as np
# Generates multiple datasets
data1 = np.random.normal(0, 1, 100)
data2 = np.random.normal(1, 2, 100)
data3 = np.random.normal(2, 1.5, 100)
# Creates subplots
fig, axs = plt.subplots(1, 3, figsize=(15, 5))
# Plots Boxplot for Data 1
axs[0].boxplot(data1)
axs[0].set_title('Data 1')
axs[0].set_xlabel('Sample')
axs[0].set_ylabel('Value')
# Plots Boxplot for Data 2
axs[1].boxplot(data2)
axs[1].set_title('Data 2')
axs[1].set_xlabel('Sample')
axs[1].set_ylabel('Value')
# Plots Boxplot for Data 3
axs[2].boxplot(data3)
axs[2].set_title('Data 3')
axs[2].set_xlabel('Sample')
axs[2].set_ylabel('Value')
# Adjusts layout
plt.tight_layout()
plt.show()

Este é o gráfico resultante:

No entanto, esses subplots não compartilham o mesmo eixo e não são adequados para comparações lado a lado entre categorias. Para vários boxplots com o mesmo eixo, você precisará criar boxplots agrupados.

Os boxplots agrupados são especialmente úteis para comparar distribuições em várias categorias. Eles permitem uma compreensão mais detalhada dos dados. Essas comparações podem revelar diferenças que não são imediatamente óbvias em outros gráficos.

Cada grupo é apresentado lado a lado no mesmo gráfico, facilitando o destaque de variações, tendências e exceções em diferentes subcategorias.

Veja como você pode criar uma subparcela agrupada:

# Generates grouped data
data_group1 = [np.random.normal(0, 1, 100), np.random.normal(1, 2, 100), np.random.normal(2, 1.5, 100)]
data_group2 = [np.random.normal(0, 1, 100), np.random.normal(1, 2, 100), np.random.normal(2, 1.5, 100)]
# Combines two data groups into a dataset
data = data_group1 + data_group2
# Creates grouped boxplots
plt.boxplot(data, positions=[1, 2, 3, 5, 6, 7], labels=['G1-D1', 'G1-D2', 'G1-D3', 'G2-D1', 'G2-D2', 'G2-D3'])
plt.title('Grouped Boxplots')
plt.xlabel('Group-Dataset')
plt.ylabel('Value')
plt.show()

Este é o boxplot agrupado produzido pelo código acima:

4. Personalizando os boxplots do Matplotlib

Você pode usar a personalização avançada no Matplotlib para aprimorar suas visualizações de dados.

Técnicas como adição de médias, adição de desvio padrão, criação de boxplots agrupados e uso de boxplots horizontais podem fornecer melhores insights sobre a distribuição de seus dados.

A personalização dos boxplots em Python também permite que você adapte os visuais às especificações do seu projeto.

Aqui estão algumas maneiras de personalizar os boxplots usando a biblioteca Matplotlib:

1. Adição de rótulos e títulos

Os títulos e rótulos tornarão seus gráficos mais fáceis de entender para os visualizadores, que poderão discernir rapidamente a comparação de dados. A adição desses itens é simples e pode ser feita usando as funções do Matplotlib.

Para adicionar rótulos a um boxplot do Matplotlib:

plt.boxplot(data)
# Adds title
plt.title('Customized Boxplot Title')
# Adds x axis label
plt.xlabel('Customized X Label')
# Adds y axis label
plt.ylabel('Customized Y Label')
plt.show()

Isso criará um boxplot rotulado como o da imagem abaixo:

2. Ajuste das cores do boxplot

Se você personalizar as cores e os estilos dos boxplots em Python, poderá fazer uma apresentação visualmente atraente e clara dos dados. Eles também ajudarão você a enfatizar com eficácia pontos de dados específicos ou comparações com os participantes.

Você pode alterar as cores das caixas, bigodes, limites, medianas e flutuadores usando os parâmetros boxprops, whiskerprops, capprops, medianprops e flierprops.

Aqui está o exemplo de código:

plt.boxplot(data, boxprops=dict(color='blue'), whiskerprops=dict(color='red'), capprops=dict(color='green'), medianprops=dict(color='orange'), flierprops=dict(markerfacecolor='red', marker='o'))
plt.show()

Isso criará cores diferentes para os componentes do boxplot com base nos parâmetros que você definiu:

3. Adicionando a média e o desvio padrão

Adicione a média e o desvio padrão ao boxplot para fornecer mais informações estatísticas.

# Creates dataset
data1 = np.random.normal(0, 1, 100)
data2 = np.random.normal(1, 2, 100)
data3 = np.random.normal(2, 1.5, 100)
# Calculates the mean and standard deviations
mean = [np.mean(d) for d in data]
std_devs = [np.std(d) for d in data]
# Creates a boxplot
plt.boxplot(data, labels=['Data 1', 'Data 2', 'Data 3'])
# Adds mean as red dots
for i in range(len(mean)):
   plt.plot(i + 1, mean[i], 'ro')
# Adds standard deviations as error bars
for i in range(len(std_devs)):
   plt.errorbar(i + 1, mean[i], yerr=std_devs[i], fmt='o', color='red')
# Plots graph
plt.title('Boxplot with Means and Standard Deviations')
plt.xlabel('Dataset')
plt.ylabel('Value')
plt.show()

Aqui está o gráfico resultante:

4. Boxplots horizontais

Os boxplots horizontais podem tornar a visualização de dados mais legível, especialmente ao lidar com nomes longos de categorias.

Isso pode ser feito simplesmente usando o parâmetro de argumento vert da função boxplot no Matplotlib.

# Creates horizontal boxplot
plt.boxplot(data,
            labels=['Data 1', 'Data 2', 'Data 3'], 
            vert=False)
# Plots graph
plt.title('Horizontal Boxplot')
plt.xlabel('Value')
plt.ylabel('Dataset')
plt.show()

Este é o gráfico resultante da execução do código acima:

Nosso curso Introduction to Data Visualization with Matplotlib também deve ajudar você a entender melhor como criar visualizações de dados além dos boxplots.

Se você precisar consultar essas informações no futuro, aqui está um resumo da folha de dicas para plotagem no Matplotlib:

5. Criando Boxplots com a Seaborn

O Seaborn, desenvolvido com base no Matplotlib, simplifica a criação de boxplots esteticamente agradáveis com o mínimo de código. Sua sintaxe simples a torna acessível a todos os níveis de habilidade, e sua integração com outras bibliotecas permite o máximo de flexibilidade na análise de dados.

1. Boxplot básico de seaborn

Aqui você encontra um guia passo a passo para criar um boxplot básico usando o Seaborn. Como antes, comece importando as bibliotecas necessárias.

# Imports necessary libraries
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

Em seguida, vamos preparar um conjunto de dados simples:

# Generates a random dataset
np.random.seed(10)
data = np.random.normal(0, 1, 100)

Por fim, vamos criar o boxplot real e imprimi-lo:

# Creates a basic boxplot
sns.boxplot(data=data)
# Adds title to the boxplot
plt.title('Basic Boxplot') 
plt.show()

Este é o gráfico resultante:

2. Personalização avançada de seaborn

Você pode personalizar o gráfico do Seaborn usando os parâmetros hue, orient e palette. 

Vamos ver como você pode adicionar cores ao seu boxplot com base em categorias, usando o parâmetro hue:

# Generate multiple datasets
data = {
    'Group': ['A']*100 + ['B']*100 + ['C']*100,
    'Value': np.concatenate([np.random.normal(0, 1, 100), 
                             np.random.normal(1, 2, 100), 
                             np.random.normal(2, 1.5, 100)])
}
df = pd.DataFrame(data)
# Create additional grouping data
df['Subgroup'] = np.random.choice(['X', 'Y'], size=300)
# Plots graph
sns.boxplot(x='Group', y='Value', data=df, hue='Subgroup', palette='Set2')
plt.title('Colored Boxplot')
plt.show()

Aqui está o boxplot modificado:

Para alinhar seu boxplot em uma orientação específica, use o parâmetro orient. Para orientação vertical, o parâmetro orient deve ser definido como 'v'. Para orientação horizontal, deve ser definido como "h".

Aqui está o código para um boxplot horizontal:

# Plots horizontal boxplot
sns.boxplot(data=df, orient='h', palette='Set2')
plt.title('Colored Boxplot')
plt.show()

O código acima criará um boxplot como este:

Para adicionar pontos de dados individuais ao boxplot, você pode usar um gráfico de enxame usando a função swarmplot:

# Plots boxplot
sns.boxplot(x='Group', y='Value', data=df)
# Overlays swarm plot over boxplot
sns.swarmplot(x='Group', y='Value', data=df, color='black', alpha=0.5)
plt.title('Boxplot with Swarmplot')
plt.show()

O código acima criará um boxplot como este:

Um gráfico de enxame como esse pode ajudar a fornecer mais informações sobre a distribuição de seus dados. Ele complementa as informações estatísticas de um boxplot para dar aos seus espectadores uma visão abrangente dos seus dados.

Confira nosso curso Introdução à visualização de dados com o Seaborn para saber mais sobre como implementar visualizações de dados no Seaborn.

Se você quiser consultar essas informações no futuro, aqui está uma folha de dicas para plotagem no Seaborn:

Interpretando os resultados do Python Boxplot

A interpretação de um boxplot depende do contexto e da pergunta de pesquisa específica que ele aborda.

No entanto, algumas diretrizes gerais podem ajudar você a entender a distribuição de dados mostrada no boxplot. Isso inclui:

• A linha mediana indica o valor médio do conjunto de dados.
• A faixa interquartil (IQR) ou 50% intermediária dos valores está entre o primeiro quartil (Q1) e o terceiro quartil (Q3).
• Os bigodes se estendem 1,5 vezes acima e abaixo do Q3 e do Q1, respectivamente.
• Os valores discrepantes são plotados individualmente com um ponto ou asterisco.
• O comprimento da caixa e dos bigodes dá uma ideia de como os dados estão espalhados.
• As distribuições distorcidas exibirão assimetria no tamanho e na posição da caixa em relação à linha mediana.
• Outliers além de 1,5 vezes acima ou abaixo de Q3 e Q1 podem indicar valores extremos ou possíveis erros na medição de dados.

Erros comuns que você deve evitar ao criar boxplots em Python

Embora o Python facilite a criação de boxplots visualmente atraentes com base em seus conjuntos de dados, alguns aspectos devem ser considerados para evitar visualizações enganosas ou incorretas.

1. Não lidar com valores ausentes

Ao criar um boxplot Python, os profissionais geralmente ignoram a importância do pré-processamento de dados, o que leva a resultados enganosos. 

Todas as visualizações de dados exigem alguma forma de limpeza antes da plotagem. Os boxplots não são exceção e podem exibir valores ausentes como outliers, o que pode distorcer os resultados.

2. Dimensionamento inadequado de dados

Além disso, os usuários às vezes não dimensionam os dados adequadamente, o que pode resultar em um boxplot distorcido que deturpa as verdadeiras características do conjunto de dados. A escala garante que os recursos contribuam igualmente para a análise.

3. Não abordar os valores atípicos

Por fim, os analistas podem negligenciar o exame e o tratamento minucioso dos outliers antes da plotagem. O tratamento inadequado dos valores atípicos pode distorcer a interpretação, o que torna crucial distinguir os valores atípicos genuínos dos erros ou anomalias na coleta de dados.

Tente usar esta folha de dicas ao criar visualizações de dados:

Considerações finais

Os boxplots são uma ferramenta valiosa para visualizar as distribuições de dados e compará-las entre categorias. 

Em Python, você pode usar Matplotlib, Seaborn ou Plotly para criar boxplots rapidamente sem muita codificação. A DataCamp tem cursos abrangentes para cada uma dessas ferramentas:

• Introdução à visualização de dados com o Matplotlib
• Introdução à visualização de dados com a Seaborn
• Introdução à visualização de dados com o Plotly

O que você acha de explorar mais sobre a visualização de dados usando Python? Então, o programa de habilidades de Visualização de dados com Python ajudaria muito você!