# Python para Data Analytics: Matplotlib, Seaborn e Visualizacao de Dados para Entrevistas

> Guia completo sobre visualizacao de dados com Python voltado para entrevistas tecnicas de Data Analytics. Aborda a API orientada a objetos do Matplotlib, graficos estatisticos com Seaborn, heatmaps de correlacao, estilizacao profissional e exercicio pratico de dashboard.

- Published: 2026-04-22
- Updated: 2026-04-22
- Author: SharpSkill
- Tags: python, matplotlib, seaborn, data-visualization, data-analytics, interview
- Reading time: 9 min

---

Processos seletivos para vagas de Data Analytics, Data Science e Business Intelligence no mercado brasileiro exigem cada vez mais que candidatos demonstrem dominio pratico de visualizacao de dados com Python. Empresas de tecnologia, fintechs e consultorias avaliam nao apenas a capacidade de gerar graficos, mas a habilidade de transformar conjuntos de dados complexos em narrativas visuais claras, reproduziveis e profissionais. Matplotlib e Seaborn sao as duas bibliotecas que compoe a base desse ecossistema, e o conhecimento solido de ambas representa um diferencial competitivo significativo em qualquer etapa tecnica.

Este artigo percorre o caminho completo da visualizacao de dados para entrevistas: da configuracao do ambiente ao desenvolvimento de um dashboard multipaineis, passando por graficos de barras, subplots comparativos, distribuicoes estatisticas, heatmaps de correlacao e estilizacao de nivel corporativo. Cada exemplo utiliza codigo funcional e pronto para execucao, acompanhado de explicacoes sobre as decisoes tecnicas que entrevistadores esperam ouvir.

> **Por que a API orientada a objetos importa em entrevistas**
>
> A maioria dos entrevistadores espera que o candidato utilize a API orientada a objetos do Matplotlib (`fig, ax = plt.subplots()`) em vez da interface funcional `plt.plot()`. A API OO oferece controle explicito sobre cada elemento do grafico, funciona de forma previsivel com multiplos subplots e reflete praticas de codigo de producao. Todos os exemplos deste artigo seguem esse padrao.

## Preparacao do Ambiente de Desenvolvimento

A configuracao adequada do ambiente de trabalho e o primeiro passo antes de qualquer exercicio de visualizacao. A criacao de um ambiente virtual isolado e a instalacao de versoes especificas das bibliotecas garantem reprodutibilidade total, tanto em projetos profissionais quanto em desafios tecnicos cronometrados.

```bash
# setup.sh
python -m venv venv
source venv/bin/activate
pip install matplotlib==3.10.8 seaborn==0.13.2 pandas numpy
```

O ambiente virtual impede conflitos entre dependencias de projetos distintos. Apos a instalacao, a verificacao das versoes confirma que todas as bibliotecas estao operacionais e na versao correta:

```python
# verify_install.py
import matplotlib
import seaborn as sns
import pandas as pd

print(f"Matplotlib: {matplotlib.__version__}")
print(f"Seaborn: {sns.__version__}")
print(f"Pandas: {pd.__version__}")
```

Se alguma versao divergir do esperado, o comando `pip install --upgrade` seguido do nome da biblioteca e da versao desejada resolve o problema. Com o ambiente funcional, a proxima etapa consiste em compreender a arquitetura central do Matplotlib.

## Fundamentos do Matplotlib: A API Orientada a Objetos na Pratica

O Matplotlib estrutura toda visualizacao em torno de dois conceitos-chave: a **Figure**, que funciona como o container de nivel superior (a "tela" completa), e os **Axes**, que representam a area retangular onde os dados sao efetivamente desenhados. Cada Axes possui seus proprios eixos X e Y, titulo e configuracoes de estilo. Essa separacao e central em entrevistas porque permite manipular cada grafico de forma independente dentro de uma mesma figura.

A API orientada a objetos (OO) concede controle total sobre todos os elementos graficos. O exemplo a seguir demonstra a criacao de um grafico de barras com formatacao profissional, representando o tipo exato de exercicio cobrado em avaliacoes tecnicas:

```python
# bar_chart_oo.py
import matplotlib.pyplot as plt
import numpy as np

# Sample quarterly revenue data
quarters = ["Q1", "Q2", "Q3", "Q4"]
revenue = [42_000, 58_000, 51_000, 67_000]

# Create figure and axes explicitly
fig, ax = plt.subplots(figsize=(8, 5))

# Draw bars with a specific color
ax.bar(quarters, revenue, color="#2563eb", width=0.5)

# Label axes clearly — interviewers check for this
ax.set_xlabel("Quarter")
ax.set_ylabel("Revenue (USD)")
ax.set_title("Quarterly Revenue — 2025")

# Format y-axis with dollar amounts
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))

# Remove top and right spines for a cleaner look
ax.spines[["top", "right"]].set_visible(False)

plt.tight_layout()
plt.savefig("quarterly_revenue.png", dpi=150)
plt.show()
```

Varios elementos deste codigo merecem destaque em contexto de entrevista. A criacao explicita de `fig` e `ax` por meio de `plt.subplots()` sinaliza dominio da API OO e maturidade tecnica. A formatacao do eixo Y com cifrao e separador de milhares via `FuncFormatter` demonstra preocupacao com a legibilidade de dados financeiros. A remocao dos spines superior e direito segue convencoes modernas de design de visualizacoes, eliminando elementos visuais que nao acrescentam informacao. O `plt.tight_layout()` ajusta automaticamente margens e espacamentos para evitar cortes ou sobreposicoes nos rotulos.

Um detalhe tecnico importante: `plt.savefig()` deve ser chamado antes de `plt.show()`. Em determinados backends graficos, `plt.show()` limpa a figura da memoria, e salvar o arquivo depois resultaria em uma imagem em branco.

## Subplots: Comparacao Visual de Metricas Lado a Lado

Entrevistas de Data Analytics frequentemente pedem que o candidato compare multiplas metricas em uma unica visualizacao. A tecnica de subplots posiciona graficos diferentes dentro da mesma figura, o que facilita a identificacao de padroes, correlacoes e divergencias entre variaveis.

```python
# subplots_comparison.py
import matplotlib.pyplot as plt
import numpy as np

months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun"]
users = [1200, 1350, 1500, 1420, 1680, 1820]
revenue = [24_000, 27_000, 30_000, 28_400, 33_600, 36_400]

# Two side-by-side plots sharing the x-axis
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5), sharey=False)

# Left panel: user growth as a line chart
ax1.plot(months, users, marker="o", color="#2563eb", linewidth=2)
ax1.set_title("Monthly Active Users")
ax1.set_ylabel("Users")
ax1.spines[["top", "right"]].set_visible(False)

# Right panel: revenue as a bar chart
ax2.bar(months, revenue, color="#16a34a", width=0.5)
ax2.set_title("Monthly Revenue")
ax2.set_ylabel("Revenue (USD)")
ax2.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))
ax2.spines[["top", "right"]].set_visible(False)

fig.suptitle("Product Metrics — H1 2025", fontsize=14, fontweight="bold")
plt.tight_layout()
plt.savefig("product_metrics.png", dpi=150)
plt.show()
```

A chamada `plt.subplots(1, 2)` cria uma grade de uma linha por duas colunas, e o desempacotamento `(ax1, ax2)` atribui cada subplot a uma variavel independente. O parametro `sharey=False` assegura que cada painel mantenha sua propria escala no eixo Y, o que e essencial quando as metricas possuem magnitudes distintas (numero de usuarios versus receita em dolares). O titulo global da figura, definido por `fig.suptitle()`, contextualiza o conjunto de visualizacoes sem competir com os titulos individuais de cada painel.

A hierarquia visual resultante -- titulo geral, titulos dos paineis, rotulos dos eixos -- corresponde exatamente ao padrao que avaliadores procuram em respostas de entrevista.

> **Erro recorrente em entrevistas: usar plt.title() com subplots**
>
> Um dos equivocos mais comuns em desafios tecnicos e recorrer a chamadas globais como `plt.xlabel()` ou `plt.title()` ao trabalhar com multiplos subplots. Essas funcoes operam apenas sobre o Axes ativo no momento, produzindo resultados imprevisiveis e inconsistentes. A API orientada a objetos (`ax.set_xlabel()`, `ax.set_title()`) elimina toda ambiguidade e constitui a abordagem profissional esperada.

## Visualizacoes Estatisticas com Seaborn

O Seaborn foi projetado sobre o Matplotlib com a finalidade especifica de simplificar a criacao de graficos estatisticos. Enquanto o Matplotlib exige configuracao manual para cada aspecto visual, o Seaborn encapsula padroes recorrentes de analise exploratoria em funcoes de alto nivel que produzem visualizacoes informativas com poucas linhas de codigo.

A analise de distribuicoes figura entre os cenarios mais solicitados em processos seletivos. O exemplo a seguir compara a distribuicao salarial entre dois departamentos utilizando KDE (Kernel Density Estimation), tecnica que estima a funcao de densidade de probabilidade a partir de dados observados e produz uma curva suave que facilita a comparacao entre grupos:

```python
# distribution_analysis.py
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Simulate salary data for two departments
np.random.seed(42)
data = pd.DataFrame({
    "salary": np.concatenate([
        np.random.normal(75_000, 12_000, 200),  # Engineering
        np.random.normal(65_000, 10_000, 150),  # Marketing
    ]),
    "department": ["Engineering"] * 200 + ["Marketing"] * 150
})

# KDE plot comparing salary distributions
fig, ax = plt.subplots(figsize=(10, 5))
sns.kdeplot(
    data=data,
    x="salary",
    hue="department",        # Automatically splits by category
    fill=True,               # Shaded area under the curve
    alpha=0.4,
    palette=["#2563eb", "#dc2626"],
    ax=ax                    # Attach to our explicit axes
)

ax.set_title("Salary Distribution by Department")
ax.set_xlabel("Annual Salary (USD)")
ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))
ax.spines[["top", "right"]].set_visible(False)

plt.tight_layout()
plt.savefig("salary_distribution.png", dpi=150)
plt.show()
```

O parametro `hue="department"` instrui o Seaborn a segmentar os dados automaticamente por categoria, gerando uma curva KDE para cada departamento com cores distintas. O preenchimento ativado por `fill=True` combinado com a transparencia de `alpha=0.4` permite identificar visualmente a regiao de sobreposicao entre as distribuicoes, informacao valiosa para avaliar se a diferenca salarial entre os departamentos e expressiva.

A passagem do parametro `ax=ax` conecta o grafico do Seaborn ao sistema de eixos criado explicitamente pelo Matplotlib. Essa combinacao permite aproveitar a simplicidade do Seaborn para a estrutura principal do grafico e o controle fino do Matplotlib para ajustes de formatacao, uma abordagem hibrida que demonstra versatilidade ao entrevistador.

## Heatmaps de Correlacao: Explorando Relacoes entre Variaveis

Matrizes de correlacao sao presenca constante em entrevistas de Data Analytics porque testam duas habilidades simultaneamente: o dominio tecnico do coeficiente de Pearson e a capacidade de comunicar relacoes complexas entre variaveis de forma visual. O heatmap converte valores numericos abstratos em um mapa de cores intuitivo, acelerando a identificacao de relacoes fortes ou fracas.

```python
# correlation_heatmap.py
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Simulate e-commerce metrics
np.random.seed(42)
n = 500
page_views = np.random.poisson(15, n)
time_on_site = page_views * 2.5 + np.random.normal(0, 5, n)
cart_adds = np.random.binomial(page_views, 0.3)
purchases = np.random.binomial(cart_adds, 0.4)

df = pd.DataFrame({
    "page_views": page_views,
    "time_on_site": time_on_site,
    "cart_adds": cart_adds,
    "purchases": purchases
})

# Compute Pearson correlation
corr_matrix = df.corr()

fig, ax = plt.subplots(figsize=(8, 6))
sns.heatmap(
    corr_matrix,
    annot=True,              # Show correlation values in cells
    fmt=".2f",               # Two decimal places
    cmap="RdBu_r",           # Diverging colormap centered on 0
    vmin=-1, vmax=1,         # Fixed scale for consistency
    square=True,             # Square cells
    linewidths=0.5,
    ax=ax
)

ax.set_title("E-commerce Metrics Correlation")
plt.tight_layout()
plt.savefig("correlation_heatmap.png", dpi=150)
plt.show()
```

A escolha do colormap `"RdBu_r"` (Red-Blue reversed) segue uma convencao amplamente adotada em analise de dados: correlacoes positivas fortes aparecem em tons avermelhados, correlacoes negativas em azul, e valores proximos de zero em branco neutro. Os parametros `vmin=-1` e `vmax=1` fixam a escala de cores independentemente dos valores reais presentes nos dados, o que garante consistencia na interpretacao visual entre diferentes conjuntos de dados.

O parametro `annot=True` exibe os coeficientes numericos dentro de cada celula, eliminando qualquer ambiguidade na leitura. Em contexto de entrevista, essa dupla codificacao -- visual (cor) e quantitativa (numero) -- e considerada pratica recomendada porque atende estilos diferentes de leitura e interpretacao.

Alem de gerar o heatmap, entrevistadores esperam que o candidato interprete os resultados. Uma correlacao de 0.85 entre `page_views` e `time_on_site` indica uma relacao linear forte e esperada (mais paginas visitadas implicam mais tempo no site). Uma correlacao moderada entre `purchases` e `page_views` sugere a existencia de um funil de conversao com atrito em etapas intermediarias, abrindo espaco para investigacoes mais aprofundadas.

## Estilizacao Profissional: Elevando o Padrao Visual dos Graficos

A distancia entre um grafico amador e um grafico profissional reside quase inteiramente nos detalhes de estilizacao. Em entrevistas e no ambiente corporativo, graficos mal formatados minam a credibilidade da analise, independentemente da qualidade dos dados subjacentes. O Seaborn disponibiliza temas predefinidos que elevam o padrao visual de forma imediata:

```python
# professional_styling.py
import matplotlib.pyplot as plt
import seaborn as sns

# Apply Seaborn's built-in theme
sns.set_theme(
    style="whitegrid",       # Clean background with grid lines
    palette="muted",         # Professional color palette
    font_scale=1.1           # Slightly larger text
)

# Global Matplotlib overrides
plt.rcParams.update({
    "figure.facecolor": "white",
    "axes.facecolor": "white",
    "font.family": "sans-serif",
    "axes.titlesize": 14,
    "axes.labelsize": 12,
})
```

A funcao `sns.set_theme()` configura simultaneamente o estilo de fundo, a paleta de cores e a escala das fontes. O estilo `"whitegrid"` aplica fundo branco com linhas de grade sutis, a combinacao mais adequada para apresentacoes corporativas e relatorios de dados. A paleta `"muted"` utiliza cores dessaturadas que conferem aparencia profissional sem competir pela atencao do observador.

As configuracoes via `plt.rcParams.update()` complementam o tema do Seaborn com ajustes especificos do Matplotlib: fundo branco explicito para ambas as camadas (figura e eixos), fonte sans-serif para maior legibilidade em telas e projecoes, e tamanhos predefinidos para titulos e rotulos. A recomendacao consiste em posicionar esse bloco de configuracao no inicio de qualquer script ou notebook de analise, antes da geracao do primeiro grafico.

> **Atencao a mudancas de API no Seaborn 0.13**
>
> A versao 0.13 do Seaborn introduziu alteracoes significativas na API. O parametro `shade` foi renomeado para `fill` em funcoes como `kdeplot()`, e a funcao `distplot()` foi completamente removida em favor de `histplot()` e `kdeplot()`. Utilizar a API desatualizada em uma entrevista passa a impressao de desatualizacao tecnica. Manter-se em dia com as mudancas do ecossistema e um diferencial que avaliadores reconhecem.

## Perguntas Conceituais Recorrentes em Entrevistas de Visualizacao

Alem dos exercicios praticos de codificacao, processos seletivos de Data Analytics incluem regularmente perguntas conceituais que testam a profundidade do conhecimento do candidato. As questoes mais frequentes abrangem os seguintes topicos:

**Grafico de barras ou grafico de linhas: quando usar cada um?** Graficos de barras servem para comparar valores entre categorias discretas sem relacao temporal (departamentos, produtos, regioes). Graficos de linhas sao adequados para representar tendencias ao longo do tempo ou de uma variavel continua ordenada. Usar um grafico de linhas para categorias sem ordenacao implicita sugere uma continuidade que nao existe nos dados e pode induzir interpretacoes equivocadas.

**Como identificar uma visualizacao enganosa?** Graficos enganosos geralmente apresentam uma ou mais destas caracteristicas: eixo Y que nao comeca em zero em graficos de barras (exagera diferencas), escalas truncadas sem indicacao explicita, uso de areas ou volumes em vez de comprimentos para representar quantidades (a percepcao humana de area e nao-linear), e colormaps inadequados que distorcem a percepcao dos dados. A capacidade de identificar e corrigir esses problemas demonstra pensamento critico valorizado por entrevistadores.

**Por que a escolha da paleta de cores importa?** Paletas sequenciais (como `viridis`) sao indicadas para dados que variam de um minimo a um maximo. Paletas divergentes (como `RdBu_r`) funcionam quando ha um ponto central significativo, como zero em correlacoes. Paletas qualitativas (como `Set2`) servem para categorias sem hierarquia. Alem disso, paletas acessiveis a daltonicos (perceptualmente uniformes) sao preferidas em ambientes profissionais. Demonstrar essa consciencia em entrevistas sinaliza maturidade analitica.

**Qual a diferenca pratica entre `plt.show()` e `plt.savefig()`?** A funcao `plt.show()` renderiza o grafico na tela e, dependendo do backend, limpa a figura da memoria. A funcao `plt.savefig()` grava o grafico em arquivo sem exibi-lo. Em scripts de producao, `savefig()` e utilizado com parametros como `dpi=150` para controlar a resolucao e `bbox_inches="tight"` para evitar cortes. A ordem correta e sempre salvar antes de exibir.

**Como garantir reprodutibilidade em graficos com dados aleatorios?** A chamada `np.random.seed(42)` fixa o estado do gerador de numeros pseudoaleatorios, garantindo que cada execucao produza os mesmos dados sinteticos. Isso e fundamental tanto para testes automatizados quanto para demonstracoes em entrevistas, onde a reprodutibilidade permite validar resultados e comparar versoes.

## Exercicio Integrado: Dashboard Completo para Entrevista Tecnica

O exercicio a seguir simula um cenario real de entrevista: a construcao de um dashboard com tres paineis que apresente metricas de produto ao longo de 12 meses. Desafios com esse formato sao recorrentes tanto em etapas take-home quanto em sessoes ao vivo de 30 a 45 minutos. A proposta avalia a capacidade do candidato de integrar subplots, formatacao adequada, estilizacao consistente e interpretacao analitica em uma unica entrega coesa.

```python
# interview_exercise.py
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.05)

# Simulate 12 months of product data
np.random.seed(42)
months = pd.date_range("2025-01", periods=12, freq="MS")
df = pd.DataFrame({
    "month": months,
    "revenue": np.cumsum(np.random.normal(5000, 2000, 12)) + 50_000,
    "customers": np.cumsum(np.random.poisson(50, 12)) + 500,
    "churn_rate": np.clip(np.random.normal(0.05, 0.015, 12), 0.01, 0.12)
})

fig, axes = plt.subplots(1, 3, figsize=(18, 5))

# Panel 1: Revenue trend
axes[0].plot(df["month"], df["revenue"], marker="o", color="#2563eb")
axes[0].set_title("Revenue Trend")
axes[0].set_ylabel("Revenue (USD)")
axes[0].yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))
axes[0].tick_params(axis="x", rotation=45)
axes[0].spines[["top", "right"]].set_visible(False)

# Panel 2: Customer growth
axes[1].bar(df["month"], df["customers"], color="#16a34a", width=20)
axes[1].set_title("Customer Growth")
axes[1].set_ylabel("Total Customers")
axes[1].tick_params(axis="x", rotation=45)
axes[1].spines[["top", "right"]].set_visible(False)

# Panel 3: Churn rate with threshold line
axes[2].plot(df["month"], df["churn_rate"], marker="s", color="#dc2626")
axes[2].axhline(y=0.05, color="gray", linestyle="--", label="Target: 5%")
axes[2].set_title("Monthly Churn Rate")
axes[2].set_ylabel("Churn Rate")
axes[2].yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"{x:.1%}"))
axes[2].tick_params(axis="x", rotation=45)
axes[2].spines[["top", "right"]].set_visible(False)
axes[2].legend()

fig.suptitle("Product Dashboard — FY 2025", fontsize=14, fontweight="bold")
plt.tight_layout()
plt.savefig("interview_dashboard.png", dpi=150)
plt.show()
```

Este exercicio consolida todos os conceitos abordados ao longo do artigo. O primeiro painel apresenta a tendencia de receita como grafico de linha com marcadores circulares, formatacao monetaria no eixo Y e remocao de spines desnecessarios. O segundo painel exibe o crescimento acumulado da base de clientes em barras com largura ajustada para eixos temporais (`width=20` corresponde a aproximadamente 20 dias). O terceiro painel combina a taxa de churn mensal com uma linha horizontal de referencia em 5%, que funciona como benchmark operacional para identificacao imediata dos meses que excedem a meta.

A rotacao dos rotulos do eixo X em 45 graus evita a sobreposicao de datas, um detalhe pratico que entrevistadores observam com atencao. A legenda no terceiro painel contextualiza o significado da linha tracejada, e o titulo geral da figura unifica os tres paineis sob uma narrativa analitica coerente.

Durante a apresentacao em entrevista, espera-se que o candidato articule verbalmente as decisoes de design: grafico de linhas para receita porque trata-se de uma tendencia temporal continua, barras para clientes porque representam um acumulo discreto mensal, e a linha de referencia no churn porque estabelece um contexto analitico que transforma numeros isolados em informacao acionavel.

## Conclusao e Pontos-Chave para a Entrevista

Os principais conceitos que todo candidato a vagas de Data Analytics deve dominar em relacao a visualizacao de dados com Python:

- **A API orientada a objetos do Matplotlib e o padrao profissional esperado**: a criacao explicita de `fig` e `ax` via `plt.subplots()` oferece controle granular, funciona de forma previsivel com subplots e demonstra maturidade tecnica
- **Rotulos, titulos e formatacao adequada sao obrigatorios**: eixos sem rotulos, titulos genericos e ausencia de formatacao monetaria ou percentual comprometem a credibilidade da analise perante avaliadores
- **O Seaborn acelera a producao de graficos estatisticos sofisticados**: funcoes como `kdeplot()` e `heatmap()` encapsulam logica complexa em chamadas simples, integrando-se nativamente com DataFrames do Pandas
- **Heatmaps de correlacao exigem interpretacao de negocio**: gerar a matriz nao basta -- o candidato precisa explicar por que determinadas correlacoes fazem ou nao sentido no contexto do dominio analisado
- **Estilizacao consistente demonstra atencao aos detalhes**: configurar `sns.set_theme()` no inicio do script e remover spines desnecessarios resolve a maioria dos problemas visuais com esforco minimo
- **Dashboards multipaineis integram todas as competencias**: a construcao de uma visualizacao coesa com metricas distintas, formatacao diferenciada por tipo de dado e narrativa analitica articulada constitui o exercicio definitivo para processos seletivos

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/pt/blog/data-analytics/python-matplotlib-seaborn-data-visualization-interview