Lazy Evaluation no Polars vs Execução Imediata no Pandas — Por Que Isso Muda Tudo

Durante muitos anos, o Pandas foi a biblioteca que usei para quase tudo — scripts rápidos, etapas de ETL, análises exploratórias.

O modelo de execução imediata parece natural: você escreve uma operação e ela é executada na hora. Isso é ótimo para experimentação e notebooks.

Mas conforme meus fluxos cresceram — mais dados, pipelines mais longos, mais transformações — os limites desse modelo começaram a aparecer.

Foi aí que o Polars entrou no meu fluxo com uma proposta diferente: construir a query primeiro e executar depois.

Neste post, comparo a lazy evaluation do Polars com a execução imediata do Pandas, explicando por que essa diferença importa e onde cada abordagem funciona melhor.

Quando os pipelines começam a crescer

Se você já escreveu um pipeline longo em Pandas, o padrão é conhecido:

• filtrar
• agrupar
• ordenar
• fazer merge
• criar colunas
• renomear

Cada etapa é executada imediatamente.

Isso é simples — mas também significa que o Pandas começa a trabalhar antes mesmo de você terminar de definir o pipeline.

O Polars questiona essa lógica.

No modo lazy, nada é executado até a chamada final de .collect().
Em vez disso, o Polars constrói um plano de execução, aplica otimizações e só então executa tudo de uma vez.

Dataset de exemplo

import pandas as pd
import polars as pl

data = {"name": ["Alice", "Bob", "Charlie"], "score": [85, 92, 78]}

df_pd = pd.DataFrame(data)
df_pl = pl.DataFrame(data)

Pandas: execução imediata

O Pandas funciona de forma direta e intuitiva:

result_pd = df_pd[df_pd["score"] > 80][["name"]]
print(result_pd)

#     name
# 0   Alice
# 1     Bob

Cada transformação acontece na hora.

Isso implica que:

• etapas intermediárias geram DataFrames temporários
• o uso de memória cresce com a complexidade
• o Pandas não consegue reordenar ou otimizar operações

Para muitos cenários, isso é totalmente aceitável.

Polars: lazy evaluation

lazy_query = (
    df_pl.lazy()
    .filter(pl.col("score") > 80)
    .select("name")
)

print(lazy_query)        # mostra o plano lógico
print(lazy_query.collect())

Nada é executado até o .collect().

O Polars constrói um plano lógico que pode ser:

• otimizado
• reordenado
• inspecionado antes da execução

Isso dá muito mais controle sobre como o pipeline será executado.

Por que lazy evaluation importa na prática

Lazy evaluation não é apenas teoria. Ela traz benefícios reais:

1. Pipelines mais rápidos

Operações podem ser combinadas e otimizadas.

2. Menos objetos intermediários

Menor pressão de memória.

3. Performance mais previsível

Execução ocorre uma única vez, com um plano claro.

4. Planos de execução inspecionáveis

Você entende o que vai acontecer antes de rodar.

Quando a execução imediata ainda faz sentido

Execução imediata não é algo negativo.

Para:

• exploração rápida
• datasets pequenos
• uso interativo

O modelo do Pandas continua sendo extremamente produtivo.

Takeaway

O Pandas executa agora — simples e intuitivo.
O Polars executa quando faz sentido — otimizado e intencional.

Entender essa diferença é essencial conforme seus pipelines de dados evoluem.