O que é o Plotnine

Plotnine e uma biblioteca Python de visualização de dados baseada na Grammar of Graphics, o mesmo conceito que faz o ggplot2 do R ser tao querido entre cientistas de dados. Criada por Hassan Kibirige e mantida como projeto open source, ela permite construir gráficos complexos de forma declarativa, camada por camada, sem precisar se preocupar com detalhes de renderização.

O problema que ela resolve e clássico: quem vem do R para o Python sente falta do ggplot2. O Matplotlib e poderoso, mas verboso. O Seaborn simplifica bastante, mas ainda e imperativo. O Plotnine permite escrever exatamente a mesma lógica de construção de gráficos do ggplot2, com uma API quase idêntica.

Em junho de 2026, a biblioteca ganhou destaque no Hacker News com uma atualização significativa, atraindo centenas de comentários de desenvolvedores e cientistas de dados que já usavam ou queriam migrar para ela.

Como funciona

A Grammar of Graphics e um modelo conceitual que descreve gráficos como composição de camadas independentes. Em vez de pensar em "tipo de gráfico", você pensa em dados, mapeamentos estéticos (o que vai no eixo X, Y, cor, tamanho) e geometrias (pontos, linhas, barras, histogramas).

No Plotnine, você começa com a função ggplot(), passa um DataFrame do pandas, define os mapeamentos com aes() e vai adicionando camadas com o operador +. Cada camada e independente e pode ter seus próprios dados e mapeamentos, o que permite gráficos muito ricos com código conciso.

Por baixo dos panos, o Plotnine usa o Matplotlib como motor de renderização. Isso significa que ele herda toda a capacidade de exportação do Matplotlib (PNG, SVG, PDF) sem precisar de dependências extras. A conversão entre a lógica de alto nível do Plotnine e o Matplotlib acontece automaticamente.

Principais recursos

O Plotnine implementa a maioria das funcionalidades do ggplot2 original:

  • Geometrias variadas: pontos (geom_point), linhas (geom_line), barras (geom_bar), histogramas (geom_histogram), boxplots (geom_boxplot) e mais de 30 tipos
  • Facets: dividir um gráfico em múltiplos painéis com facet_wrap e facet_grid com uma única linha
  • Themes: estilos visuais prontos como theme_minimal, theme_bw, theme_classic e suporte a temas customizados
  • Scales: controle total sobre eixos, cores e tamanhos com scale_x_log10, scale_color_brewer e outros
  • Stats: transformações estatísticas como regressão linear (stat_smooth) aplicadas direto no gráfico
  • Labels e anotações: adicionar texto, setas e formas geométricas sobre o gráfico

Um diferencial importante e o suporte nativo a DataFrames do pandas, sem precisar de conversões manuais.

Como começar: instalação e primeiro gráfico

A instalação e simples via pip ou conda:

Passo 1: Instale o Plotnine com pip install plotnine. Se você usa conda, conda install -c conda-forge plotnine. As dependências principais (pandas, numpy, matplotlib) são instaladas automaticamente.

Passo 2: Importe o necessário no seu script ou notebook: from plotnine import ggplot, aes, geom_point, theme_minimal. Você pode também fazer from plotnine import * para trazer tudo de uma vez, como e comum em tutoriais.

Passo 3: Crie um DataFrame pandas com seus dados e construa o gráfico: ggplot(df, aes(x='coluna_x', y='coluna_y')) + geom_point() + theme_minimal(). Em um Jupyter Notebook o gráfico aparece inline. Em um script, chame .save('gráfico.png') para exportar.

Exemplo prático

Imagine que você tem um DataFrame com dados de vendas mensais por região e quer visualizar a tendência de cada região no mesmo gráfico, com cores diferentes para cada uma.

Com Matplotlib puro, você precisaria de um loop, definir cores manualmente, criar a legenda separada e ajustar cada detalhe. Com Plotnine, o código fica assim:

from plotnine import ggplot, aes, geom_line, geom_point, theme_minimal, labs
(ggplot(df_vendas, aes(x='mes', y='vendas', color='região'))
+ geom_line()
+ geom_point(size=3)
+ theme_minimal()
+ labs(title='Vendas por Região', x='Mes', y='Vendas (R$)'))

O resultado e um gráfico com linha e pontos para cada região, legenda automática, tema limpo e titulo formatado. Tudo isso em menos de 10 linhas, com o código descrevendo o que você quer ver, não como desenhar cada elemento.

Comparação com alternativas

O Plotnine compete diretamente com Matplotlib, Seaborn e outras bibliotecas Python de visualização. Cada uma tem seu espaço:

Matplotlib e a base de quase tudo em Python. E extremamente flexível, mas verboso. Para um scatter plot simples você escreve 5-10 linhas. Use quando precisar de controle absoluto sobre cada pixel do gráfico, ou quando estiver integrando com outros sistemas que já usam Matplotlib.

Seaborn facilita muito gráficos estatísticos e tem uma API mais simples que o Matplotlib puro. E ótima para análise exploratória rápida. A diferença e que o Seaborn ainda e imperativo: você chama funções diferentes para cada tipo de gráfico. O Plotnine e declarativo, o que muda a forma de pensar sobre visualização.

Plotly e Altair focam em gráficos interativos para web. Se o objetivo e uma dashboard no navegador com zoom e filtros, o Plotly Express ou o Altair são melhores escolhas. O Plotnine gera imagens estáticas, o que é perfeito para relatórios, papers e apresentações em PDF.

Pontos positivos e limitações

Pontos positivos:

  • API quase idêntica ao ggplot2 do R: cientistas de dados que vem do R se adaptam em minutos
  • Código declarativo que descreve o gráfico, não o processo de desenho
  • Facets funcionam de verdade: dividir em múltiplos painéis e uma única linha
  • Exportação via Matplotlib: PNG, SVG, PDF funcionam sem configuração extra
  • Documentação clara e exemplos práticos abundantes

Limitações reais:

  • Gráficos estáticos apenas: sem interatividade nativa (zoom, hover, filtros)
  • Performance com datasets muito grandes (acima de 1 milhão de linhas) pode ser lenta
  • Nem todas as funcionalidades do ggplot2 original foram portadas ainda
  • Curva de aprendizado para quem nunca viu Grammar of Graphics antes

Casos de uso reais

Cientista de dados migrando do R: já sabe ggplot2 de cor, quer usar Python mas não quer reaprender uma API completamente diferente. O Plotnine permite continuar pensando da mesma forma, apenas trocando library(ggplot2) por from plotnine import *.

Analista de dados criando relatórios: precisa gerar gráficos padronizados e elegantes para PDF ou PowerPoint. O Plotnine com theme_minimal ou temas customizados entrega um visual profissional sem ajustes manuais de cor e fonte.

Desenvolvedor de pipeline de dados: precisa gerar visualizações automaticamente em um script Python que roda no servidor, sem interface gráfica. O Plotnine salva diretamente para arquivo sem precisar de display, ideal para automações.

Professor ou pesquisador: precisa criar figuras para papers e apresentações académicas. A reproducibilidade do código Plotnine e um diferencial: o gráfico e descrito completamente pelo código, fácil de versionar e replicar.

Dicas e boas práticas

Comece pelos dados limpos. O Plotnine trabalha melhor com DataFrames no formato tidy (cada variável em uma coluna, cada observação em uma linha). Se seus dados estão em formato wide (colunas para cada categoria), use pd.melt() para converter antes de plotar.

Use theme() para customizações pontuais em vez de criar um tema do zero. Por exemplo, para aumentar o tamanho da fonte: + theme(text=element_text(size=14)). Para remover o fundo cinza padrão: + theme_bw().

Para salvar em alta resolução, use o parâmetro dpi: p.save('gráfico.png', dpi=300, width=10, height=6). O tamanho e em polegadas por padrão, igual ao comportamento do ggplot2.

Vale a pena?

Vale muito para quem já conhece ggplot2 ou quer aprender a Grammar of Graphics em Python. A curva de aprendizado inicial e compensada rapidamente pela produtividade ao criar gráficos complexos com menos código.

Para quem nunca usou ggplot2 e começa direto com Python, o Seaborn pode ser uma porta de entrada mais suave para gráficos estatísticos simples. Mas se o objetivo e visualizações mais sofisticadas, aprender o modelo declarativo do Plotnine vale o investimento.

O próximo passo e visitar plotnine.org, ler a galeria de exemplos e recriar um gráfico que você já fez no Matplotlib. A diferença em quantidade de código vai ser evidente na primeira tentativa.