Visualização com Matplotlib e Seaborn

Matplotlib é a biblioteca padrão de gráficos do Python, e tanto pandas quanto seaborn a utilizam para desenhar. Por convenção, ela é importada com import matplotlib.pyplot as plt. Em um notebook Jupyter, o gráfico aparece abaixo da célula que o desenha; em um script, plt.show() exibe as figuras abertas e, em um script comum, aguarda até que suas janelas sejam fechadas.

Uma figura é toda a superfície de desenho: a imagem exibida ou salva. Uma área de plotagem é uma região dentro da figura, com dados, título, rótulos de eixos e limites próprios; uma figura pode conter várias. Um eixo é uma das retas numéricas de uma área de plotagem, o eixo x ou o eixo y, com suas marcas de graduação e rótulos. Cada item visível, como uma linha, um marcador, um texto ou uma barra, é chamado de elemento gráfico.

fig, ax = plt.subplots() cria uma figura com uma área de plotagem e retorna os dois objetos. figsize=(width, height) define o tamanho da figura em polegadas. O padrão é 6,4 × 4,8 polegadas a 100 pontos por polegada, portanto uma figura padrão tem 640 × 480 pixels na tela; plt.subplots(figsize=(8, 4)) cria uma figura mais larga e baixa.

O Matplotlib oferece dois estilos. No estilo orientado a objetos, você chama métodos em objetos explícitos: ax.plot(...), ax.set_title(...). No estilo pyplot, funções como plt.plot(...) e plt.title(...) atuam na área de plotagem “atual”, geralmente a última criada. Ambos desenham os mesmos gráficos; o estilo orientado a objetos é mais claro quando uma figura tem mais de uma área de plotagem ou o código de plotagem está em uma função, por isso este curso o utiliza.

Os dois estilos usam nomes diferentes para as mesmas configurações: plt.title, plt.xlabel e plt.xlim correspondem a ax.set_title, ax.set_xlabel e ax.set_xlim. Um erro frequente é ax.title("Rainfall"): em uma área de plotagem, title é um atributo que contém um objeto de texto, então chamá-lo gera TypeError: 'Text' object is not callable. Use ax.set_title("Rainfall").

months = [1, 2, 3, 4, 5, 6]; temp_c = [3, 5, 9, 13, 17, 20], seguido de

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(months, temp_c)
ax.set_title("Mean monthly temperature")
ax.set_xlabel("Month")
ax.set_ylabel("Temperature (°C)")

.

As chamadas de desenho adicionam elementos a uma área de plotagem; elas não substituem o que já está nela. Uma segunda chamada ax.plot(...) no mesmo ax adiciona uma segunda linha ao mesmo gráfico. Para obter um gráfico separado, crie uma nova figura com outra chamada plt.subplots() ou desenhe em outra área de plotagem de uma figura com vários painéis.

O pyplot mantém aberta cada figura que criou até que ela seja fechada com plt.close(fig) ou plt.close("all"). Figuras abertas usam memória e, quando há mais de 20 abertas, o Matplotlib emite um aviso. Um código que cria figuras em um laço deve fechar cada figura após salvá-la.

ax.plot(x, y) desenha marcadores ou segmentos de reta que unem os pontos na ordem em que são fornecidos. Um gráfico de linhas é adequado para uma grandeza medida ao longo de uma variável ordenada, como tempo ou distância. Com um argumento, ax.plot(y), os valores de x são, por padrão, 0, 1, 2, ….

Como os pontos são unidos na ordem fornecida, valores de x não ordenados produzem um zigue-zague que vai e volta pelo gráfico. Para x = [3, 1, 2], a linha vai de x = 3 para trás até x = 1 e depois avança até x = 2. Ordene primeiro os dados por x, por exemplo com df.sort_values("x").

Argumentos de estilo: color (um nome como "black" ou "tab:orange", ou um código hexadecimal como "#1f77b4"), linestyle ("-" contínua, "--" tracejada, ":" pontilhada, "-." traço e ponto), linewidth, marker ("o" círculo, "s" quadrado, "^" triângulo) e markersize. Uma string curta de formato combina marcador e estilo de linha: ax.plot(x, y, "o--") desenha círculos unidos por uma linha tracejada. Sem color, cada nova linha recebe a próxima cor do ciclo padrão, que começa com "tab:blue" e "tab:orange".

Atribua um label a cada linha e chame ax.legend() para exibir uma legenda:

ax.plot(months, north, marker="o", label="North")
ax.plot(months, coast, linestyle="--", label="Coast")
ax.legend()

. Se nenhum elemento gráfico tiver um rótulo, ax.legend() não desenha nada e o Matplotlib avisa que não encontrou elementos gráficos com rótulos.

ax.scatter(x, y) desenha um marcador sem ligação para cada observação e é adequado para mostrar a relação entre duas variáveis numéricas. Exemplo: temperatura diária [12, 15, 18, 21, 24, 27, 30, 22] °C e aluguéis de bicicletas [180, 220, 260, 310, 330, 360, 340, 250]; ax.scatter(temp_c, rentals) mostra que os aluguéis em geral aumentam com a temperatura, e a correlação entre as duas listas é de aproximadamente 0,92.

Em ax.scatter, s define a área de cada marcador em pontos quadrados; o padrão é 36, a área de um marcador com 6 pontos de largura. Dobrar s dobra a área, então a largura do marcador cresce apenas por um fator de aproximadamente 1,4. s pode ser um único número ou um valor por ponto, permitindo que o tamanho do marcador represente uma terceira variável.

c colore os pontos: uma cor para todos ou um número por ponto associado a um mapa de cores como cmap="viridis". Guarde o objeto retornado e adicione uma barra de cores: sc = ax.scatter(temp_c, rentals, c=rain_mm, cmap="viridis"); fig.colorbar(sc, ax=ax, label="Rain (mm)").

Quando muitos pontos se sobrepõem (sobreposição excessiva de elementos gráficos), regiões densas viram manchas sólidas e escondem quantos pontos contêm. Reduza a opacidade com alpha=0.3, use marcadores menores ou mostre a densidade, por exemplo com um gráfico de agrupamento em hexágonos (df.plot.hexbin) ou um histograma bidimensional.

ax.plot(x, y, "o"), com um marcador e sem linha, também desenha pontos e é mais rápido para uma quantidade muito grande de pontos, pois todos os marcadores compartilham tamanho e cor. Use ax.scatter quando o tamanho ou a cor precisar variar de um ponto para outro.

ax.bar(categories, heights) desenha uma barra vertical por categoria; ax.barh(categories, widths) desenha barras horizontais, que deixam espaço para nomes longos de categorias. Quando as categorias são strings, o Matplotlib as coloca em posições igualmente espaçadas, na ordem fornecida, e as usa como rótulos das marcas de graduação. Quando são números, as barras ficam nessas posições em um eixo numérico comum.

Por padrão, as barras começam em uma linha de base de 0, então o comprimento de cada barra mostra seu valor. O argumento width é medido em unidades do eixo x e seu valor padrão é 0,8. Categorias em string são colocadas a uma unidade de distância umas das outras, então o padrão deixa um espaço de 0,2 entre as barras, e width=1 faz com que barras vizinhas se toquem.

200 pessoas foram perguntadas sobre como costumam se deslocar: carro 84, ônibus 52, bicicleta 38, a pé 26. ax.barh(["Car", "Bus", "Bike", "Walk"], [84, 52, 38, 26]) desenha quatro barras horizontais. As proporções são 42%, 26%, 19% e 13%, que somam 100%.

ax.barh coloca a primeira categoria na parte inferior do eixo, pois o eixo y cresce para cima. Para ler uma lista ordenada de cima para baixo, como no exemplo dos deslocamentos, chame ax.invert_yaxis() ou inverta tanto as categorias quanto seus valores antes de criar o gráfico, mantendo cada valor com sua categoria.

Barras agrupadas colocam várias séries lado a lado em cada categoria. Use posições numéricas e desloque cada série pela metade da largura de uma barra:

x = np.arange(3)
ax.bar(x - 0.2, north, width=0.4, label="North")
ax.bar(x + 0.2, coast, width=0.4, label="Coast")
ax.set_xticks(x, labels=["Jan", "Feb", "Mar"])
ax.legend()

. As barras do Norte ficam em −0,2, 0,8 e 1,8, e as do Litoral em 0,2, 1,2 e 2,2, centralizadas em cada marca de graduação.

Barras empilhadas desenham uma segunda série sobre a primeira com bottom=: ax.bar(days, car); ax.bar(days, bus, bottom=car). Se um dia tem 40 viagens de carro e 25 de ônibus, o segmento do ônibus vai de 40 a 65, e a altura total da barra é 65.

bars = ax.bar(...) retorna um contêiner de barras; ax.bar_label(bars) escreve cada valor no fim de sua barra. fmt controla o texto: fmt="%.1f" escreve 3,14 como “3.1”, e fmt="{:.0f} km" o escreve como “3 km”.

O Matplotlib desenha as barras na ordem dos dados, não em ordem de tamanho. Para um gráfico ordenado, ordene primeiro os valores, por exemplo com sorted() em pares ou sort_values() no pandas. O argumento yerr= adiciona barras de erro de um comprimento especificado a cada barra, e ax.errorbar(x, y, yerr=...) faz o mesmo para pontos.

Um gráfico de barras compara valores de categorias distintas, então suas barras ficam separadas por espaços. Um histograma, por sua vez, mostra como uma variável numérica se distribui em intervalos adjacentes, e suas barras se tocam. Desenhar medições como uma barra por linha de dados produz um gráfico de barras de valores brutos, não um histograma.

Defina textos com ax.set_title("..."), ax.set_xlabel("...") e ax.set_ylabel("..."), ou com uma chamada: ax.set(title="Monthly rainfall", xlabel="Month", ylabel="Rainfall (mm)"). Inclua a unidade no rótulo do eixo, por exemplo “Precipitação (mm)” ou “Distância (km)”, para que cada valor das marcas de graduação tenha significado.

O Matplotlib escolhe os limites dos eixos a partir dos dados, com uma pequena margem. Defina-os com ax.set_xlim(1, 12) e ax.set_ylim(0, 120), ou fixe apenas um extremo com ax.set_ylim(bottom=0). ax.set(xlim=(1, 12), ylim=(0, 120)) faz o mesmo em uma chamada.

ax.set_xticks([1, 4, 7, 10]) escolhe as posições das marcas de graduação, e ax.set_xticks([1, 2, 3], labels=["Jan", "Feb", "Mar"]) também substitui seus rótulos. Gire rótulos apertados com ax.tick_params(axis="x", labelrotation=45). Formatadores de rótulos mudam a forma como os valores são escritos: ax.yaxis.set_major_formatter(PercentFormatter(xmax=1, decimals=0)), com PercentFormatter importado de matplotlib.ticker, apresenta o valor 0,25 como “25%”.

ax.set_yscale("log") coloca o eixo y em uma escala logarítmica, na qual distâncias iguais representam razões iguais: o passo de 10 a 100 tem o mesmo comprimento que o de 100 a 1.000. Ela é adequada para valores que abrangem várias ordens de grandeza, como populações de cidades. Um eixo logarítmico não pode mostrar zero nem valores negativos.

ax.legend() coloca a legenda onde ela cobre a menor quantidade de pontos (loc="best", o padrão para a legenda de uma área de plotagem). Escolha uma posição com loc="upper left", adicione um título com title="Station" e distribua as entradas em colunas com ncols=2. ax.legend(bbox_to_anchor=(1.02, 1), loc="upper left") coloca a legenda logo fora da borda direita da área de plotagem.

ax.grid(True, alpha=0.3) adiciona linhas de grade claras nas marcas de graduação; ax.grid(axis="y") desenha apenas as horizontais, o que ajuda a ler as alturas das barras.

Folhas de estilo alteram a aparência padrão de todos os gráficos posteriores: plt.style.use("ggplot"). plt.style.available lista os estilos instalados; os estilos semelhantes aos do seaborn que acompanham o Matplotlib recebem nomes como "seaborn-v0_8-whitegrid". Para aplicar um estilo apenas a um bloco de código, use with plt.style.context("ggplot"):.

Configurações padrão individuais ficam em plt.rcParams, por exemplo plt.rcParams["font.size"] = 12 ou plt.rcParams["figure.figsize"] = (8, 4). Elas se aplicam às figuras criadas posteriormente, e plt.rcdefaults() restaura os padrões do Matplotlib.

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot([1, 2, 3, 4], [62, 48, 55, 40], marker="o", label="North")
ax.set(title="Monthly rainfall, January to April", xlabel="Month", ylabel="Rainfall (mm)", ylim=(0, 70))
ax.set_xticks([1, 2, 3, 4], labels=["Jan", "Feb", "Mar", "Apr"])
ax.legend()
ax.grid(axis="y", alpha=0.3)

.

Em uma figura com várias áreas de plotagem, funções pyplot como plt.title ou plt.xlabel alteram apenas a área atual, geralmente a última criada, então um título pode aparecer no painel errado. Chamar os métodos da área desejada, como axes[0].set_title(...), evita isso.

Construa a tabela larga de precipitação com uma coluna por estação:

import pandas as pd
wide = pd.DataFrame({
    "North": [62, 48, 55, 40],
    "Coast": [110, 95, 80, 60],
    "Valley": [20, 15, 30, 45]
}, index=pd.Index(["Jan", "Feb", "Mar", "Apr"], name="month"))

Toda Series e todo DataFrame do pandas tem um método .plot que desenha com o Matplotlib e retorna a área de plotagem do Matplotlib em que desenhou. df.plot(kind="bar") e df.plot.bar() são a mesma chamada. Os tipos são "line" (o padrão), "bar", "barh", "hist", "box", "kde" ou "density", "area", "pie", "scatter" e "hexbin".

Por padrão, o índice se torna o eixo x e cada coluna numérica se torna uma linha, com uma legenda criada a partir dos nomes das colunas. Uma Series apresenta seus valores em função do índice. Para escolher colunas, passe x="month" e y="rain_mm", ou uma lista como y=["North", "Coast"].

Uma tabela wide com o índice Jan, Fev, Mar, Abr e as colunas Norte [62, 48, 55, 40], Litoral [110, 95, 80, 60] e Vale [20, 15, 30, 45], todos em milímetros de precipitação. ax = wide.plot(marker="o", figsize=(8, 4), title="Monthly rainfall"); ax.set_ylabel("Rainfall (mm)") desenha três linhas identificadas em uma área de plotagem e depois define o rótulo de y com um método comum do Matplotlib.

Argumentos comuns de .plot: title, xlabel, ylabel, xlim, ylim, figsize, color, legend=False, rot (rotação dos rótulos das marcas de graduação em graus), grid=True e logy=True. ax= desenha em uma área de plotagem existente, por exemplo um painel de plt.subplots(1, 2), em vez de criar uma figura.

subplots=True desenha cada coluna em sua própria área de plotagem e retorna um array do NumPy de áreas de plotagem em vez de uma única área; layout=(2, 2) as organiza em uma grade e sharey=True fornece a elas uma escala y compartilhada. Para a tabela das três estações, wide.plot(subplots=True, layout=(1, 3), sharey=True) produz um painel por estação.

Gráficos de dispersão e de agrupamento em hexágonos existem apenas para DataFrames e precisam de x e y: days.plot.scatter(x="temp_c", y="rentals", c="rain_mm", colormap="viridis") colore os pontos pela precipitação. Uma Series não tem gráfico de dispersão, então s.plot.scatter() gera um erro. df.plot.hist(bins=5) e df.plot.box() produzem um histograma e um diagrama de caixa para cada coluna numérica.

s.plot.pie() desenha um setor para cada valor, com tamanho proporcional à sua parcela do total. Como gráficos de setores precisam de uma Series com partes não negativas de um todo, uma coluna de contagens como s.value_counts() é uma entrada típica.

Gráficos de barras no pandas tratam o índice como categorias e colocam as barras nas posições 0, 1, 2, … quaisquer que sejam os valores do índice. Gráficos de linhas usam os valores reais do índice quando são números ou datas. Portanto, uma linha e barras do pandas desenhadas na mesma área de plotagem só se alinham quando os valores de x da linha correspondem às posições das barras, como em um índice padrão 0, 1, 2, …; para anos como 2020 a 2023, a linha fica muito à direita das barras. Ao combiná-los, desenhe ambos nas mesmas posições.

Com um índice de datas e horas (DatetimeIndex), .plot() coloca datas no eixo x e cria seus rótulos automaticamente. Dados diários costumam ficar mais claros após a reamostragem temporal, por exemplo para médias mensais com s.resample("MS").mean().plot().

.plot desenha apenas colunas numéricas. Se números foram lidos como texto, por exemplo porque uma coluna contém “12 mm”, a coluna é ignorada e, quando não restam dados numéricos, o pandas gera TypeError: no numeric data to plot. Converta primeiro a coluna, por exemplo com pd.to_numeric(...).

Um gráfico desenha os valores presentes na tabela, então faça primeiro um resumo. Exemplo: uma tabela longa rain com 12 linhas, uma por estação e mês, e as colunas month, station e rain_mm. rain.groupby("station")["rain_mm"].mean() fornece uma média por estação: Litoral 86,25 mm, Norte 51,25 mm e Vale 27,5 mm. Acrescentar .plot.bar() desenha três barras.

Criar um gráfico das linhas brutas por engano produz leituras individuais em vez das médias solicitadas: rain.plot.bar(x="station", y="rain_mm") desenha 12 barras com nomes de estações repetidos em vez de três médias.

Ordene antes de criar o gráfico para obter barras ordenadas: means.sort_values(ascending=False).plot.bar() coloca a maior média à esquerda. Para um gráfico horizontal, means.sort_values().plot.barh() coloca a maior no topo, pois o primeiro valor é desenhado na parte inferior.

s.value_counts() conta a frequência de cada categoria e lista as contagens da mais frequente à menos frequente. Para os meios de transporte “ônibus”, “carro”, “ônibus”, “bicicleta”, “ônibus”, “carro”, o resultado é ônibus 3, carro 2, bicicleta 1, pronto para .plot.bar(). Use .sort_index() ou .reindex([...]) quando as categorias tiverem uma ordem natural, como os dias da semana.

Um DataFrame em formato largo, com uma coluna por série, produz uma linha ou cor de barra por coluna no pandas. Remodele uma tabela longa com rain.pivot(index="month", columns="station", values="rain_mm"). Quando algum par de índice e coluna ocorre mais de uma vez, pivot gera um erro; use pivot_table(..., aggfunc="mean") ou groupby(["month", "station"])["rain_mm"].mean().unstack().

pivot e pivot_table ordenam o novo índice, então meses em strings aparecem em ordem alfabética, Apr, Feb, Jan, Mar, e um gráfico de linhas percorre os meses na ordem errada. Restaure a ordem real com wide.reindex(["Jan", "Feb", "Mar", "Apr"]) ou armazene o mês como uma categoria ordenada ou como número do mês antes da remodelagem.

Em uma tabela larga, wide.plot.bar() desenha barras agrupadas, um grupo por rótulo do índice e uma cor por coluna, enquanto wide.plot.bar(stacked=True) empilha as colunas. A transposta wide.T.plot.bar() troca os papéis: um grupo por estação, uma cor por mês.

Para obter proporções dentro de cada grupo, normalize uma tabulação cruzada: pd.crosstab(trips["region"], trips["mode"], normalize="index") divide cada contagem pelo total de sua linha, então cada linha soma 1. Se a região N tem duas viagens de carro e uma de ônibus, sua linha é carro 0,67 e ônibus 0,33 (arredondados). .plot.bar(stacked=True) desenha então barras de mesma altura total que mostram a composição de cada região.

O seaborn funciona melhor com dados em formato longo e organizado: uma linha por observação e uma coluna por variável. wide.reset_index().melt(id_vars="month", var_name="station", value_name="rain_mm") transforma a tabela larga de 4 × 3 novamente em 12 linhas com três colunas, para que station possa ser usada para cores ou facetas.

O seaborn é uma biblioteca de gráficos construída sobre o Matplotlib que trabalha diretamente com DataFrames do pandas e calcula resumos estatísticos comuns. Por convenção, é importado com import seaborn as sns. Uma chamada típica indica a tabela e suas colunas: sns.scatterplot(data=days, x="temp_c", y="rentals").

Além de x e y, colunas podem ser associadas a outras características (mapeamentos semânticos): hue define a cor, style define o marcador ou padrão de traços e size define o tamanho do marcador ou a largura da linha. O seaborn escolhe as cores e constrói a legenda. Uma coluna categórica em hue recebe cores distintas; uma coluna numérica recebe um gradiente.

Cada mapeamento precisa de uma coluna em formato longo. Com a tabela longa de precipitação, sns.lineplot(data=rain, x="month", y="rain_mm", hue="station", marker="o") desenha uma linha colorida por estação, com legenda. Se hue indicar uma coluna que não está na tabela, o seaborn gera um ValueError informando que não conseguiu interpretar o valor.

Quando x contém strings, o seaborn coloca as categorias na ordem em que aparecem pela primeira vez nos dados, então meses armazenados como “Jan”, “Feb”, “Mar” nessa ordem de linhas permanecem em ordem de calendário. As funções categóricas, como barplot, boxplot e countplot, aceitam order=["Mon", "Tue", "Wed"] para definir a ordem das categorias, e hue_order define a ordem dos grupos de cores em toda função que tem hue. lineplot não tem argumento order: para corrigir a ordem dos nomes dos meses, transforme a coluna x em uma categoria ordenada, por exemplo pd.Categorical(rain["month"], categories=["Jan", "Feb", "Mar", "Apr"], ordered=True).

As funções no nível da área de plotagem, como scatterplot, lineplot, histplot, boxplot, barplot e heatmap, desenham em uma área de plotagem do Matplotlib, aceitam ax= para escolhê-la e a retornam. As funções no nível da figura, relplot, displot, catplot e lmplot, criam sua própria figura, podem dividi-la em painéis com col e row e retornam um objeto de grade de facetas (FacetGrid) do seaborn.

As funções no nível da figura definem o tamanho por painel: height é a altura de cada painel em polegadas e aspect é sua razão entre largura e altura, então cada painel tem height × aspect polegadas de largura; os padrões são 5 e 1. Como criam sua própria figura, elas não podem desenhar em uma área de plotagem existente: relplot, displot e catplot emitem um aviso e ignoram ax=, e lmplot o rejeita com um TypeError. Elas colocam a legenda fora dos painéis.

sns.set_theme() muda todos os gráficos posteriores, incluindo os feitos apenas com Matplotlib, para a aparência do seaborn: o estilo “darkgrid”, o contexto “notebook” e a paleta padrão do seaborn. style pode ser “darkgrid”, “whitegrid”, “dark”, “white” ou “ticks”; context pode ser “paper”, “notebook”, “talk” ou “poster” e ajusta a escala de fontes e linhas, por exemplo de uma fonte base de 12 pontos para “notebook” a 18 pontos para “talk”.

palette escolhe as cores para hue, por exemplo palette="colorblind", "Set2" ou "viridis". No seaborn 0.13, passar palette sem hue está obsoleto; para colorir barras por categoria, defina hue como a mesma coluna de x e acrescente legend=False: sns.barplot(data=rain, x="station", y="rain_mm", hue="station", legend=False).

O resultado pode ser finalizado com Matplotlib:

ax = sns.scatterplot(...)
ax.set(xlabel="Temperature (°C)", ylabel="Rentals per day", title="Rentals and temperature")

. Para um resultado no nível da figura, use os métodos da grade, como g.set_axis_labels("Temperature (°C)", "Rentals per day"), e g.figure.suptitle("...") para um título geral.

sns.scatterplot(data=days, x="temp_c", y="rentals", hue="weekday", size="rain_mm") desenha um ponto por linha, com cor e tamanho definidos por outras colunas. Combinar hue e style com a mesma coluna atribui a cada grupo uma cor e um marcador distintos, que continuam distinguíveis em escala de cinza.

sns.lineplot agrega por padrão: quando várias linhas compartilham um valor de x, ele desenha a linha passando pela média de seus valores de y e sombreia uma faixa para o intervalo de confiança de 95% dessa média, calculado por reamostragem bootstrap. Exemplo resolvido: em x = 1 os valores de y são 10, 12 e 14, em x = 2 são 20, 21 e 25; a linha passa por 12 e 22.

A faixa padrão mostra a incerteza de cada média, não a amplitude dos dados. errorbar="sd" sombreia uma faixa de um desvio padrão acima e abaixo da média, errorbar=None remove a faixa, e estimator=None (junto com units=) desenha cada série individual sem calcular a média. Com uma linha por valor de x, não há média a calcular nem faixa.

sns.regplot(data=days, x="temp_c", y="rentals") desenha um gráfico de dispersão com uma reta de mínimos quadrados e uma faixa sombreada de confiança de 95% para essa reta; order=2 ajusta uma curva quadrática. sns.lmplot faz o mesmo como função no nível da figura, portanto também pode dividir os dados por hue, col ou row.

Uma linha ajustada resume os dados com o modelo escolhido. Uma reta pode ser traçada sobre dados curvos, então observe os pontos ao redor da linha antes de confiar nela. Uma tendência forte mostra que as variáveis estão associadas nesses dados, sem estabelecer uma causa.

sns.pairplot(df) desenha uma grade com um gráfico de dispersão para cada par de colunas numéricas e a distribuição de cada coluna na diagonal: histogramas por padrão, curvas de densidade quando hue é definido. Quatro colunas numéricas produzem uma grade de 4 × 4 com 16 painéis. corner=True mantém apenas o triângulo inferior, e vars=[...] limita as colunas. A função retorna um PairGrid.

sns.jointplot(data=days, x="temp_c", y="rentals") desenha um gráfico de dispersão com o histograma de cada variável em suas bordas; kind="hex" substitui os pontos por agrupamentos hexagonais, o que ajuda com conjuntos de dados grandes.

sns.relplot(..., kind="scatter") e sns.relplot(..., kind="line") são as versões no nível da figura de scatterplot e lineplot; dispersão é o tipo padrão. Use-as quando a mesma relação deve ser mostrada em painéis separados para cada grupo.

sns.regplot(data=days, x="temp_c", y="rentals") mostra os aluguéis subindo de 180 a 12 °C para aproximadamente 350 nos dias mais quentes, com correlação de cerca de 0,92. O dia de 30 °C tem menos aluguéis (340) que o dia de 27 °C (360), então os pontos se estabilizam na parte superior; um ajuste quadrático (order=2) pode ser comparado com a reta.

As funções categóricas do seaborn colocam cada categoria nas posições 0, 1, 2, … do eixo categórico. Até números são tratados como rótulos: os anos 2020, 2021 e 2023 são desenhados igualmente espaçados, sem uma lacuna para 2022. native_scale=True mantém um eixo numérico com o espaçamento real.

sns.barplot(data=rain, x="station", y="rain_mm") desenha uma barra por estação cuja altura é a média de suas linhas, com uma barra de erro para o intervalo de confiança de 95% dessa média. Com a tabela de precipitação, as barras são Litoral 86,25, Norte 51,25 e Vale 27,5 mm. estimator="median" ou estimator="sum" muda o resumo; errorbar="sd" ou errorbar=None altera ou remove as barras de erro.

sns.countplot(data=trips, x="mode") conta as linhas em cada categoria e não precisa de uma coluna numérica; sns.barplot resume uma coluna numérica. Use countplot para “quantos” e barplot para “quanto em média”.

sns.pointplot mostra a média de cada grupo como um ponto com uma barra de erro e une os pontos de cada grupo de hue com uma linha. Ele facilita a comparação de mudanças entre categorias, por exemplo a precipitação média de três estações em cada um de quatro meses.

Uma barra de médias esconde a dispersão e o número de observações: uma média de 3 linhas parece tão sólida quanto uma média de 300. Mostrar os dados costuma ser melhor: sns.stripplot desenha cada observação como um ponto com um pequeno deslocamento visual aleatório, e sns.swarmplot organiza os pontos para que não se sobreponham. Um gráfico de pontos por categoria pode ser desenhado sobre um diagrama de caixa ou gráfico de barras na mesma área de plotagem.

Com hue, gráficos de barras, caixa e violino colocam os grupos lado a lado dentro de cada categoria (deslocamento lateral de grupos) por padrão. Gráficos de pontos, pontos por categoria e enxame desenham os grupos na mesma posição, a menos que dodge=True seja definido, então seus pontos podem se sobrepor. Defina a ordem das categorias com order=[...] e a ordem dos grupos com hue_order=[...].

A orientação segue os dados: coloque as categorias no eixo y e os números no eixo x, sns.barplot(data=rain, x="rain_mm", y="station"), para obter barras horizontais com rótulos longos legíveis. orient="y" (ou "h") declara isso explicitamente.

sns.catplot é a função no nível da figura para todos os gráficos categóricos. Seu kind pode ser “strip” (o padrão), “swarm”, “box”, “violin”, “boxen”, “point”, “bar” ou “count”, e col ou row divide o gráfico em painéis.

Um histograma divide a amplitude de uma variável numérica em intervalos adjacentes chamados intervalos de classe e desenha sobre cada intervalo uma barra cuja altura é o número de observações nele. Ele mostra a forma de uma distribuição: onde os valores se concentram, quanto se dispersam, se são assimétricos e se há lacunas ou valores incomuns.

counts, edges, patches = ax.hist(data, bins=5) desenha o histograma e retorna a contagem em cada intervalo e os limites de classe. Com um número inteiro, os intervalos têm a mesma amplitude, do mínimo ao máximo; o padrão é 10 intervalos. Cada intervalo inclui seu limite esquerdo e exclui o direito, exceto o último, que inclui ambos.

20 tempos de deslocamento em minutos: 12, 15, 18, 20, 22, 22, 25, 27, 28, 30, 31, 33, 35, 38, 40, 42, 45, 50, 55, 62. Com bins=5, os limites são 12, 22, 32, 42, 52 e 62, e as contagens são 4, 7, 4, 3 e 2. O valor 22 fica no segundo intervalo porque os intervalos excluem seu limite direito, e 62 é contado no último intervalo porque ele o inclui.

O número e a posição dos intervalos mudam a representação. Os mesmos 20 tempos com limites [10, 20, 30, 40, 50, 60, 70] produzem as contagens 3, 6, 5, 3, 2 e 1. Poucos intervalos escondem a forma; muitos produzem um gráfico irregular com vários intervalos quase vazios. Experimente várias configurações e prefira limites arredondados que os leitores possam interpretar, como passos de 10 minutos.

density=True no Matplotlib, ou stat="density" no seaborn, ajusta a escala das barras para que sua área total seja 1: cada altura é contagem ÷ (n × amplitude do intervalo). Para os dados de deslocamento com cinco intervalos de 10 minutos, a altura da segunda barra é 7 ÷ (20 × 10) = 0,035 por minuto. Uma altura de densidade não é uma probabilidade; altura × amplitude do intervalo é a proporção de observações no intervalo.

sns.histplot(data=commutes, x="minutes") desenha um histograma com seaborn; bins e binwidth controlam os intervalos. stat escolhe a altura: “count” (padrão), “probability” ou “proportion” (as alturas somam 1), “percent” (as alturas somam 100) e “density” (área 1). Para os cinco intervalos de deslocamento, “probability” fornece 0,2, 0,35, 0,2, 0,15 e 0,1.

Para comparar grupos, sns.histplot(data=commutes, x="minutes", hue="mode") sobrepõe um histograma por grupo; multiple="stack" os empilha, multiple="dodge" os coloca lado a lado, e element="step" desenha contornos cuja sobreposição é mais legível. Grupos de tamanhos diferentes são comparados de forma justa com stat="density", common_norm=False, que ajusta cada grupo para uma área de 1.

Uma estimativa de densidade por núcleo (KDE) é uma curva suave que estima a forma da distribuição; a área sob ela é 1. sns.kdeplot(data=commutes, x="minutes") a desenha, e sns.histplot(..., kde=True) a adiciona a um histograma. bw_adjust acima de 1 torna a curva mais suave, abaixo de 1 mais detalhada.

Uma curva KDE se estende além dos menores e maiores valores, então pode mostrar densidade abaixo de 0 minutos para tempos que não podem ser negativos. cut=0 interrompe a curva nos limites dos dados. Para amostras pequenas, a curva pode sugerir uma forma que os dados não sustentam.

No pandas, commutes["minutes"].plot.hist(bins=5, edgecolor="white") desenha um histograma (o padrão é 10 intervalos), e df.hist() desenha um histograma por coluna numérica em uma grade. No seaborn, sns.displot é a versão no nível da figura: kind="hist" (padrão), kind="kde" ou kind="ecdf", em que uma função de distribuição acumulada empírica (ECDF) mostra, para cada valor, a proporção de observações iguais ou inferiores a ele.

Um diagrama de caixa resume uma distribuição: a caixa vai do primeiro quartil (Q1) ao terceiro quartil (Q3), uma linha em seu interior marca a mediana, os bigodes se estendem em direção ao menor e ao maior valor típico, e os pontos além dos bigodes são desenhados individualmente como possíveis valores atípicos. A amplitude interquartil IQR = Q3 − Q1 é o comprimento da caixa e abrange a metade central dos dados.

Por padrão, Matplotlib, pandas e seaborn usam whis=1.5: os limites são Q1 − 1,5 × IQR e Q3 + 1,5 × IQR. Cada bigode termina no valor mais extremo dos dados dentro de seu limite, não no próprio limite, e cada valor fora dos limites é desenhado como um ponto separado.

11 tempos de entrega em minutos: 14, 16, 17, 18, 19, 20, 21, 22, 24, 25, 41. O Matplotlib calcula Q1 = 17,5, mediana = 20 e Q3 = 23, então IQR = 5,5. Os limites são 17,5 − 8,25 = 9,25 e 23 + 8,25 = 31,25. O bigode inferior termina em 14, o superior em 25, e 41 é desenhado como um ponto atípico.

Os quartis dependem do método. As bibliotecas de gráficos usam interpolação linear entre valores ordenados (o padrão do NumPy e do pandas), que fornece 17,5 e 23 no exemplo anterior. O método manual de calcular as medianas das metades inferior e superior sem a mediana geral fornece Q1 = 17 e Q3 = 24 para os mesmos dados. Ambos são válidos; pequenas diferenças entre um cálculo manual e um gráfico vêm dessa escolha.

Desenhe o resumo com a biblioteca que você está usando: ax.boxplot([north, coast], tick_labels=["North", "Coast"]) no Matplotlib (o argumento se chamava labels antes da versão 3.9); rain.boxplot(column="rain_mm", by="station") no pandas, que também adiciona o título geral “Boxplot grouped by station”; sns.boxplot(data=rain, x="station", y="rain_mm") no seaborn, com hue para um segundo agrupamento. whis=(0, 100) desenha os bigodes até o mínimo e o máximo, e showfliers=False esconde os pontos atípicos.

Diagramas de caixa lado a lado permitem comparar grupos rapidamente: compare as medianas, os comprimentos das caixas (dispersão da metade central) e a sobreposição das caixas. Uma mediana próxima de uma extremidade da caixa, ou um bigode muito mais longo que o outro, indica uma distribuição assimétrica.

Um diagrama de caixa mostra apenas cinco números e os valores atípicos. Ele não mostra o número de observações, e distribuições de formas muito diferentes podem ter a mesma caixa: uma distribuição com dois picos separados e outra com um único pico podem compartilhar Q1, a mediana e Q3. Sobrepor os pontos, sns.stripplot(data=rain, x="station", y="rain_mm", color="black", alpha=0.5), ou usar um gráfico de violino revela essa diferença.

sns.violinplot(data=rain, x="station", y="rain_mm") desenha uma curva de densidade espelhada para cada grupo com um pequeno diagrama de caixa dentro (inner="box", o padrão); inner="quart" marca os quartis com linhas. Com um hue de dois níveis, split=True coloca um grupo de cada lado do violino. Como uma KDE, o violino pode se estender além dos dados; cut=0 o interrompe no mínimo e no máximo observados.

Um ponto sinalizado pela regra de 1,5 × IQR é incomum em relação ao restante dos dados, o que é um motivo para investigar o valor. Verifique-o: pode ser um erro de digitação ou um valor real e importante, como uma entrega atrasada pelo fechamento de uma via. Remover pontos apenas porque o gráfico os sinaliza distorce a análise.

Um mapa de calor mostra uma tabela de números como uma grade de células coloridas: linhas e colunas são duas categorias (ou variáveis discretizadas em intervalos), e a cor de cada célula representa seu valor. Ele é adequado para padrões em tabelas de duas entradas, como visitantes por dia e horário, e em matrizes de correlação.

sns.heatmap(table) recebe uma tabela larga, usa seu índice como rótulos das linhas e suas colunas como rótulos das colunas e adiciona uma barra de cores como legenda. A tabela geralmente vem de pivot_table: visits.pivot_table(index="day", columns="slot", values="visitors", aggfunc="mean").

Um museu conta visitantes por período de meio dia. Sábado de manhã 120 e 140, sábado à tarde 200; domingo de manhã 90, domingo à tarde 160; segunda-feira de manhã 40, segunda-feira à tarde 70 e 90. A tabela dinâmica de médias é segunda-feira 40 e 80, sábado 130 e 200, domingo 90 e 160 (manhã e tarde). sns.heatmap(pt, annot=True, fmt=".0f", cmap="Blues") mostra a célula mais movimentada, sábado à tarde, como a mais escura. A remodelagem ordena os dias alfabeticamente (Mon, Sat, Sun); pt.reindex(["Sat", "Sun", "Mon"]) restauraria uma ordem escolhida.

annot=True escreve cada valor em sua célula, e fmt define o formato numérico. O padrão ".2g" mantém dois algarismos significativos, então 43,25 é exibido como “43” e 1234 como “1.2e+03”. Use fmt=".0f" para números inteiros ou fmt=".2f" para duas casas decimais; fmt="d" funciona apenas com dados inteiros e gera um ValueError para números de ponto flutuante.

Um mapa de calor de correlação começa com corr = df.corr(numeric_only=True), uma tabela quadrada e simétrica cujos coeficientes definidos variam de −1 a 1. Colunas numéricas não constantes têm 1 na diagonal; colunas constantes têm correlações indefinidas. No pandas 2 e posteriores, numeric_only tem False como padrão, então df.corr() gera um erro quando a tabela tem uma coluna de texto. Desenhe-o com sns.heatmap(corr, annot=True, fmt=".2f", cmap="vlag", vmin=-1, vmax=1, center=0).

Oito dias com temperatura (°C), aluguéis de bicicletas, precipitação (mm) e vento (km/h). A matriz de correlação fornece temperatura e aluguéis 0,92, aluguéis e precipitação −0,82, precipitação e vento 0,75 e temperatura e vento −0,38. Com o mapa de cores “vlag”, o par com forte correlação positiva aparece em vermelho escuro, o par com forte correlação negativa em azul escuro e o par com correlação fraca entre temperatura e vento em um tom claro próximo do centro branco.

Sem vmin e vmax, as cores vão do menor ao maior valor daquela tabela, então a mesma cor pode representar valores diferentes em dois mapas de calor. Fixe os limites para compará-los e use vmin=-1, vmax=1 para correlações. Um mapa de cores sequencial, como “rocket” (o padrão do seaborn), “viridis” ou “Blues”, é adequado para valores que vão de baixo a alto; um mapa de cores divergente, como “vlag”, “coolwarm” ou “RdBu_r”, com center no ponto médio significativo, é adequado para valores acima e abaixo de uma referência como 0. Com center definido e sem cmap, o seaborn usa o mapa divergente “icefire”.

Opções úteis: linewidths=0.5 desenha linhas finas entre as células, square=True torna as células quadradas, cbar_kws={"label": "Visitors"} adiciona um rótulo à barra de cores e valores ausentes (NaN) ficam em branco. mask=np.triu(np.ones_like(corr, dtype=bool)) esconde o triângulo superior e a diagonal de uma matriz de correlação, que repetem o triângulo inferior.

No Matplotlib, im = ax.imshow(values, cmap="viridis"); fig.colorbar(im, ax=ax) desenha um mapa de calor de um array de 2 dimensões, com a linha 0 no topo; “viridis” é o mapa de cores padrão do Matplotlib. imshow identifica os eixos com números de linhas e colunas, então defina os nomes: ax.set_xticks(range(len(cols)), labels=cols). ax.pcolormesh é uma alternativa quando as células têm tamanhos diferentes.

Um coeficiente de correlação mede apenas a força de uma associação linear. Uma correlação próxima de 0 não descarta uma relação curva forte, e um valor atípico pode aumentar ou diminuir muito um coeficiente. Verifique os gráficos de dispersão correspondentes, por exemplo com uma matriz de gráficos de pares, antes de interpretar um mapa de calor de correlação.

Pequenos múltiplos são um conjunto de gráficos do mesmo tipo, um para cada subconjunto dos dados, desenhados com as mesmas escalas e colocados lado a lado para permitir a comparação dos subconjuntos. No Matplotlib, eles são construídos como uma grade de áreas de plotagem em uma figura.

fig, axes = plt.subplots(2, 3, figsize=(12, 6)) retorna uma figura e um array do NumPy de 2 × 3 áreas de plotagem. axes[0, 0] é o painel superior esquerdo e axes[1, 2] o inferior direito. Com uma linha ou uma coluna, o array é unidimensional, então plt.subplots(1, 3) fornece axes[0], axes[1] e axes[2]. axes.flat percorre todos os painéis linha por linha.

O próprio array não pode desenhar: axes.plot(...) gera AttributeError: 'numpy.ndarray' object has no attribute 'plot'. Indexe primeiro um painel, como em axes[0, 1].plot(...).

sharex=True e sharey=True dão a todos os painéis os mesmos limites de x ou y, então alturas iguais representam valores iguais em todos os painéis e apenas os painéis externos mostram os rótulos das marcas de graduação. Sem eixos compartilhados, cada painel ajusta sua escala aos próprios dados, e uma amplitude pequena pode parecer tão grande quanto uma amplitude grande.

fig, axes = plt.subplots(2, 2, sharey=True, layout="constrained"), seguido de for ax, (name, grp) in zip(axes.flat, rain.groupby("station")): ax.plot(grp["month_num"], grp["rain_mm"], marker="o"); ax.set_title(name). As três estações preenchem três dos quatro painéis; axes[1, 1].axis("off") esconde o quarto, vazio.

Rótulos de painéis vizinhos podem se sobrepor. layout="constrained" em plt.subplots ou plt.figure ajusta o espaçamento automaticamente; fig.tight_layout(), chamado após o desenho, é a alternativa mais antiga. fig.suptitle("Monthly rainfall by station") adiciona um título para toda a figura, e fig.supxlabel(...) e fig.supylabel(...) adicionam rótulos compartilhados aos eixos.

Painéis de tamanhos diferentes: plt.subplots(1, 2, gridspec_kw={"width_ratios": [2, 1]}) torna o painel esquerdo duas vezes mais largo que o direito. fig, axd = plt.subplot_mosaic([["top", "top"], ["left", "right"]]) retorna um dicionário de áreas de plotagem, neste caso um painel largo axd["top"] acima de dois menores.

Gráficos do pandas e funções do seaborn no nível da área de plotagem podem preencher painéis escolhidos com ax=: wide["North"].plot(ax=axes[0, 0]) ou sns.histplot(data=commutes, x="minutes", ax=axes[0, 1]). É assim que gráficos das três bibliotecas são combinados em uma figura.

A divisão em facetas desenha o mesmo gráfico uma vez para cada nível de uma variável categórica, cada um em seu próprio painel, com eixos compartilhados. As funções do seaborn no nível da figura fazem isso com col= (painéis lado a lado), row= (painéis empilhados) e col_wrap= (inicia uma nova linha após esse número de colunas).

sns.relplot(data=rain, x="month_num", y="rain_mm", col="station", col_wrap=2, kind="line", height=3, aspect=1.5) desenha três painéis, dois na primeira linha e um na segunda. Cada painel tem 3 polegadas de altura e 3 × 1,5 = 4,5 polegadas de largura, então a figura tem aproximadamente 9 × 6 polegadas.

row e col juntos criam uma grade com um painel por combinação de níveis: duas estações do ano nas linhas e três estações de medição nas colunas produzem 2 × 3 = 6 painéis. col_wrap não pode ser combinado com row.

Os mesmos argumentos funcionam para qualquer tipo de gráfico: sns.displot(data=commutes, x="minutes", col="mode") produz um histograma por meio de transporte, e sns.catplot(data=rain, x="station", y="rain_mm", col="season", kind="box") produz diagramas de caixa por estação do ano.

Por padrão, os painéis compartilham seus eixos x e y, então as alturas podem ser comparadas entre painéis. Deixar cada painel ajustar sua escala aos próprios dados mostra detalhes dentro de grupos pequenos, mas pode tornar enganosa uma comparação visual rápida entre painéis. Com relplot e displot, passe facet_kws={"sharey": False}; catplot aceita sharey=False diretamente, e passá-lo também em facet_kws gera um TypeError.

sns.FacetGrid constrói a grade diretamente e depois desenha em cada painel: g = sns.FacetGrid(commutes, col="mode", height=3); g.map_dataframe(sns.histplot, x="minutes"); g.add_legend(). g.map(plt.scatter, "temp_c", "rentals") passa as colunas indicadas como argumentos posicionais a uma função de plotagem.

Personalize a grade com seus métodos: g.set_titles("{col_name}") define os títulos dos painéis a partir dos nomes dos níveis, g.set_axis_labels("Month", "Rainfall (mm)") adiciona rótulos a todos os eixos, e g.set(ylim=(0, 120)) aplica uma configuração da área de plotagem a cada painel. g.axes_dict["Coast"] ou g.axes.flat permite acessar áreas individuais, e g.figure.suptitle("Rainfall by station", y=1.02) adiciona um título geral acima dos painéis.

hue e col dividem os dados por uma variável. hue sobrepõe os grupos em uma área de plotagem, o que facilita a comparação direta de poucos grupos; col os separa, mantendo a legibilidade quando linhas ou pontos se sobreporiam ou quando há muitos grupos. Ambos podem ser usados ao mesmo tempo, por exemplo col="station", hue="season".

Funções no nível da figura não desenham em uma área de plotagem existente (relplot, displot e catplot ignoram ax= com um aviso, lmplot o rejeita) e não aceitam figsize do Matplotlib (passá-lo gera um erro): defina o tamanho da grade com height e aspect. Para colocar um gráfico com facetas ao lado de outros gráficos em uma figura do Matplotlib, construa os painéis com plt.subplots e funções no nível da área de plotagem.

ax.text(x, y, "text") escreve texto em um ponto dado em coordenadas dos dados, nas mesmas unidades dos valores plotados. ha (“left”, “center”, “right”) e va (“top”, “center”, “bottom”) alinham o texto a esse ponto; fontsize e color definem seu estilo.

Com transform=ax.transAxes, as posições são frações da área de plotagem: (0, 0) é o canto inferior esquerdo e (1, 1) o superior direito. ax.text(0.02, 0.95, "n = 20", transform=ax.transAxes, va="top") mantém uma nota no canto superior esquerdo quaisquer que sejam os dados e os limites. O texto em coordenadas dos dados se move quando os limites mudam e pode ficar fora da área de plotagem.

ax.annotate("Wettest month", xy=(1, 110), xytext=(2, 115), arrowprops=dict(arrowstyle="->")) escreve o texto em xytext e desenha uma seta até o ponto xy; ambos estão em coordenadas dos dados por padrão. textcoords="offset points" faz de xytext um deslocamento a partir de xy em pontos, por exemplo xytext=(10, 10) para 10 pontos à direita e para cima.

Linhas de referência atravessam toda a área de plotagem: ax.axhline(50, color="gray", linestyle="--", label="Target") desenha uma linha horizontal em y = 50, e ax.axvline(...) desenha uma vertical. ax.axvspan(6, 8, alpha=0.2) sombreia o intervalo de x = 6 a x = 8, por exemplo um período de férias. ax.hlines(y, xmin, xmax) desenha linhas horizontais em um intervalo limitado.

No histograma dos 20 tempos de deslocamento, a média é 650 ÷ 20 = 32,5 minutos e a mediana é 30,5 minutos. ax.axvline(32.5, color="black", linestyle="--"); ax.text(33.5, 6.5, "mean 32.5 min") marca a média, que fica à direita da mediana porque alguns deslocamentos longos a elevam.

Valores das barras: ax.bar_label(bars, fmt="%.0f") identifica as barras retornadas por ax.bar. Para barras desenhadas pelo pandas ou seaborn, as barras ficam armazenadas em ax.containers, então ax.bar_label(ax.containers[0]) identifica a primeira série. padding=3 afasta os rótulos 3 pontos das extremidades das barras.

Formas vêm de matplotlib.patches: ax.add_patch(Rectangle((x, y), width, height, fill=False, edgecolor="red")) contorna uma região em coordenadas dos dados, e Circle e Polygon funcionam da mesma maneira.

Textos podem ser calculados a partir dos dados com f-strings, para que os rótulos permaneçam corretos quando os dados mudarem: ax.text(..., f"mean {commutes['minutes'].mean():.1f} min"). Anotações são desenhadas sobre os dados; coloque-as em áreas vazias e use poucas, para destacar o que importa.

fig.savefig("rainfall.png") salva a figura; a extensão do arquivo define o formato: PNG e JPEG são imagens rasterizadas feitas de pixels, enquanto SVG e PDF são imagens vetoriais feitas de formas. format="pdf" define o formato explicitamente.

Imagens rasterizadas têm um número fixo de pixels e ficam borradas quando ampliadas; arquivos vetoriais permanecem nítidos em qualquer tamanho e são adequados para relatórios, impressão e documentos. PNG é um bom formato rasterizado para gráficos na web e em slides. A compressão JPEG tem perda de dados e borra linhas finas e textos, sendo uma escolha ruim para gráficos.

Tamanho em pixels = tamanho da figura em polegadas × dpi (pontos por polegada). fig, ax = plt.subplots(figsize=(8, 5)) salvo com dpi=150 produz 8 × 150 por 5 × 150 = 1200 × 750 pixels. Sem dpi, savefig usa o dpi da própria figura, 100 por padrão, então a mesma figura fica com 800 × 500 pixels. Para formatos vetoriais, o dpi afeta apenas as partes rasterizadas incorporadas.

As larguras de texto e de linhas são definidas em pontos (1 ponto = 1/72 de polegada), em relação às polegadas da figura. Aumentar o dpi adiciona pixels sem mudar o tamanho aparente do texto em relação ao gráfico; aumentar figsize torna o texto relativamente menor. Escolha figsize para o tamanho final de exibição e dpi para a nitidez.

bbox_inches="tight" corta margens vazias e inclui itens que ficam fora da figura, como uma legenda colocada fora da área de plotagem; a imagem salva fica um pouco menor ou maior que tamanho da figura × dpi. pad_inches=0.1 define a margem mantida ao redor dela.

transparent=True salva sem fundo, o que é adequado para slides com fundo colorido; facecolor="white" força um fundo branco, o que importa quando um tema escuro do notebook poderia aparecer no arquivo.

plt.savefig salva a figura atual, então chame-o antes de um plt.show() bloqueante: quando a janela é fechada, o pyplot deixa de acompanhar essa figura, e uma chamada posterior a plt.savefig(...) salva uma figura nova e vazia. Em um notebook Jupyter, o pyplot também deixa de acompanhar a figura ao fim da célula, então plt.savefig em uma célula posterior salva uma imagem vazia. Manter a figura em uma variável evita os dois problemas: fig.savefig(...) continua funcionando após plt.show() ou em uma célula posterior do notebook.

Resultados do seaborn são salvos da mesma forma: um gráfico no nível da área de plotagem por meio de sua figura, ax.figure.savefig("box.png", dpi=200), e uma grade no nível da figura com g.savefig("facets.png", dpi=200), que usa caixas delimitadoras ajustadas ao conteúdo por padrão.

for name, grp in rain.groupby("station"):
    grp = grp.sort_values("month_num")
    fig, ax = plt.subplots(figsize=(6, 4))
    ax.plot(grp["month_num"], grp["rain_mm"], marker="o")
    ax.set(title=name, xlabel="Month", ylabel="Rainfall (mm)")
    fig.savefig(f"rain_{name}.png", dpi=150, bbox_inches="tight")
    plt.close(fig)

. Fechar cada figura mantém baixo o uso de memória e evita o aviso sobre mais de 20 figuras abertas.