Pandas: 10 funções para turbinar sua análise… além do básico!

Vamos mudar isso.

1 - Crie colunas sem quebrar o fluxo (assign())

import pandas as pd
import numpy as np

df_produtos = pd.DataFrame({
    'produto': ['Teclado', 'Mouse', 'Monitor'],
    'preco_base': [300, 150, 1200],
    'desconto_perc': [0.05, 0.10, 0.0]
})

df_final = (
    df_produtos
    .assign(
        preco_com_desconto = lambda df: df.preco_base * (1 - df.desconto_perc),
        imposto = lambda df: df.preco_com_desconto * 0.25,
        # Podemos referenciar colunas criadas na mesma chamada assign
        preco_final = lambda df: df.preco_com_desconto + df.imposto
    )
)

print(df_final)

Use quando:

• Você quer manter um fluxo de operações limpo (method chaining).

• A lógica para criar a nova coluna é simples e pode ser expressa em uma linha.

Evite quando:

• A lógica é complexa demais para um lambda. Nesse caso, considere usar pipe() (nossa próxima função).

2 - Organize seu código com funções reutilizáveis (pipe())

def limpar_nulos(df, colunas):
    # Remove linhas onde as colunas especificadas são nulas
    return df.dropna(subset=colunas)

def normalizar_moeda(df, coluna_origem, coluna_destino, taxa):
    # Converte valores para outra moeda
    # Usamos assign aqui também para manter a função pura se preferir
    df_copia = df.copy()
    df_copia[coluna_destino] = (df_copia[coluna_origem] * taxa).round(2)
    return df_copia

# Dados de exemplo
df_vendas = pd.DataFrame({
    'id_pedido': [1, 2, 3, 4],
    'valor_brl': [100.0, np.nan, 300.0, 50.0]
})

# Taxa de conversão hipotética BRL para USD
taxa_usd = 0.18

df_processado = (
    df_vendas
    .pipe(limpar_nulos, colunas=['valor_brl'])
    .pipe(normalizar_moeda,
          coluna_origem='valor_brl',
          coluna_destino='valor_usd',
          taxa=taxa_usd)
)

print(df_processado)

Use quando:

• Você quer organizar passos complexos de pré-processamento.

• Você precisa reutilizar a mesma lógica em diferentes dataframes.

• Você valoriza código testável.

Evite quando:

• A operação é trivial e pode ser feita diretamente com métodos nativos do pandas (como um simples .rename()).

3 - Filtros legíveis como SQL (query())

# Verboso e propenso a erros de parênteses
# df_filtrado = df[(df['categoria'] == 'A') & (df['preco'] > 100) | (df['desconto'] > 0.2)]

df_catalogo = pd.DataFrame({
    'item': ['A', 'B', 'C', 'D'],
    'preco': [50, 150, 90, 200],
    'estoque': [10, 5, 0, 12]
})

# Filtro legível
df_promocao = df_catalogo.query("preco > 100 and estoque > 0")
print(df_promocao)

# Usando variáveis locais (prefixo @)
limite_minimo = 100
df_caros = df_catalogo.query("preco > @limite_minimo")

# df.query("`preço unitário` > 50")

Use quando:

• Os filtros são complexos e envolvem múltiplas condições.

• Você quer melhorar a legibilidade do código de filtragem.

Evite quando:

• Os nomes das colunas não são válidos como nomes de variáveis em Python (e você não quer usar backticks).

• O filtro envolve tipos de dados complexos que o motor interno do query não suporta bem.

4 - Expressões rápidas e vetorizadas (eval())

df_pedidos = pd.DataFrame({
    'preco_unitario': np.random.rand(1000) * 100,
    'quantidade': np.random.randint(1, 10, 1000),
    'frete': np.random.rand(1000) * 20
})

# Calculando o valor total do pedido em uma única expressão
df_pedidos.eval("valor_total = (preco_unitario * quantidade) + frete", inplace=True)

# Você também pode fazer múltiplas operações
df_pedidos.eval("""
custo = preco_unitario * 0.6
lucro = valor_total - custo - frete
""", inplace=True)

print(df_pedidos.head())

Use quando:

• Você está trabalhando com dataframes grandes e performance é uma prioridade em cálculos numéricos.

• As operações são aritméticas simples entre colunas.

Evite quando:

• As operações envolvem tipos de dados complexos (listas, objetos) ou funções externas que não são suportadas pelo motor do eval().

5 - Transforme listas em linhas (explode())

df_pedidos_agg = pd.DataFrame({
    'id_pedido': [101, 102],
    'cliente': ['Diego', 'Fernanda'],
    'itens': [['Teclado', 'Mouse'], ['Monitor', 'Cabo']]
})

df_pedidos_detalhado = df_pedidos_agg.explode('itens')

print(df_pedidos_detalhado)
#    id_pedido   cliente      itens
# 0        101     Diego    Teclado
# 0        101     Diego      Mouse
# 1        102  Fernanda    Monitor
# 1        102  Fernanda       Cabo

Use quando:

• Você precisa analisar elementos individuais dentro de coleções armazenadas em células.

• Ótimo combinado com groupby após a explosão.

Evite quando:

• As células contêm objetos complexos que não são listas/arrays (como dicionários aninhados, onde json_normalize pode ser mais adequado).

• Seu dataframe é gigantesco e o explode() gerará um número impraticável de linhas.

6 - De wide para long em uma linha (melt())

df_vendas_wide = pd.DataFrame({
    'loja': ['Centro', 'Shopping'],
    'vendas_jan': [5000, 7000],
    'vendas_fev': [5500, 7200]
})

# Formato wide (ruim para agrupar por mês)
print(df_vendas_wide)

df_vendas_long = df_vendas_wide.melt(
    id_vars=['loja'],             # Colunas que permanecem iguais (identificadores)
    var_name='mes',               # Nome da nova coluna que guarda os nomes das colunas antigas
    value_name='valor_vendas'     # Nome da nova coluna que guarda os valores
)

# Formato long (ideal para análise)
print(df_vendas_long)

Use quando:

• Você precisa preparar dados para visualização (seaborn, matplotlib geralmente preferem formato long).

• Seu dataframe tem colunas que representam medidas ao longo do tempo ou categorias diferentes da mesma medida.

Evite quando:

• Seus dados já estão no formato tidy (longo).

7 - Join por tempo mais próximo (merge_asof())

# Transações de compra
df_transacoes = pd.DataFrame({
    'data_hora': pd.to_datetime(['2025-10-13 10:05:02', '2025-10-13 10:15:30']),
    'valor_usd': [100, 250]
})

# Cotações do dólar
df_cotacoes = pd.DataFrame({
    'data_hora_cotacao': pd.to_datetime(['2025-10-13 10:00:00', '2025-10-13 10:10:00', '2025-10-13 10:20:00']),
    'taxa_brl': [5.10, 5.12, 5.09]
})

# Os dataframes DEVEM estar ordenados pela chave de junção
df_transacoes = df_transacoes.sort_values('data_hora')
df_cotacoes = df_cotacoes.sort_values('data_hora_cotacao')

df_merged = pd.merge_asof(
    df_transacoes,
    df_cotacoes,
    left_on='data_hora',
    right_on='data_hora_cotacao',
    direction='backward' # 'backward' (padrão): cotação mais recente ANTES da transação
                         # 'forward': cotação mais próxima DEPOIS da transação
                         # 'nearest': cotação mais próxima no geral
)

print(df_merged)

Use quando:

• Juntando dados de séries temporais com frequências diferentes ou timestamps desalinhados.

• Dados de sensores (IoT), logs de eventos ou dados financeiros.

Evite quando:

• Você precisa de correspondências exatas (use merge()).

• Seus dados não estão ordenados pela chave de junção.

8 - Agrupe dados em faixas (cut())

df_clientes = pd.DataFrame({
    'nome': ['Mayk', 'Laís', 'Rodrigo', 'Isabela'],
    'idade': [38, 22, 45, 16]
})

# Definindo os limites das faixas e os rótulos
bins = [0, 18, 30, 45, 60, 120]
labels = ['0-18', '19-30', '31-45', '46-60', '60+']

df_clientes['faixa_etaria'] = pd.cut(
    df_clientes.idade,
    bins=bins,
    labels=labels,
    right=True # Inclui o limite direito (ex.: 30 anos entra na faixa 19-30)
)

print(df_clientes)

Use quando: