Pandas Avançado: Internals e Otimização

Pandas Avançado: Internals e Otimização

Pandas é uma das bibliotecas mais poderosas do ecossistema Python para análise de dados, mas sua flexibilidade vem com complexidade. Para profissionais que trabalham com grandes volumes de dados e precisam de performance máxima, entender os internals da biblioteca é essencial. Este artigo explora a arquitetura interna do Pandas, trade-offs de design e técnicas avançadas de otimização.

1. Arquitetura Interna: BlockManager e Representação de Dados

No coração do Pandas está o BlockManager, um sistema de gerenciamento de blocos de dados que organiza colunas em blocos contíguos de memória baseados em tipo de dado. Diferentemente de uma abordagem ingênua que armazenaria cada coluna separadamente, o BlockManager agrupa colunas do mesmo tipo (int64, float64, object) em blocos NumPy contíguos.

import pandas as pd
import numpy as np

# Criar DataFrame com múltiplos tipos
df = pd.DataFrame({
    'int_col1': np.arange(1000000),
    'int_col2': np.arange(1000000, 2000000),
    'float_col': np.random.randn(1000000),
    'str_col': ['texto'] * 1000000
})

# Acessar internals (cuidado: API privada, pode mudar)
print(df._mgr)  # BlockManager
print(df._mgr.blocks)  # Blocos de dados
print(df._mgr.axes)  # Índices (linhas e colunas)

O BlockManager oferece vantagens e desvantagens:

• Vantagem: Operações vetorizadas em colunas do mesmo tipo são extremamente rápidas (cache-friendly)
• Desvantagem: Operações que modificam tipos (como adicionar uma coluna string a um bloco int) causam consolidação de blocos, que é custosa
• Trade-off: Pandas 2.0+ está migrando para uma arquitetura baseada em ExtensionArrays para maior flexibilidade, mas com overhead potencial

2. Copy-on-Write (CoW) e Gerenciamento de Memória

Uma das mudanças mais significativas no Pandas 2.0 foi a introdução do Copy-on-Write, um mecanismo que reduz cópias desnecessárias de dados. Antes, operações como slicing criavam cópias implícitas, consumindo memória exponencialmente.

import pandas as pd

pd.options.mode.copy_on_write = True

df = pd.DataFrame({'A': range(1000000), 'B': range(1000000)})

# Com CoW, isso NÃO cria uma cópia imediata
df_slice = df[['A']]
df_slice.loc[0, 'A'] = 999

# df['A'][0] permanece inalterado
print(df['A'].iloc[0])  # 0, não 999

# A cópia só ocorre quando você modifica df_slice
# Isso economiza memória significativamente

Implicações práticas:

• CoW é habilitado por padrão no Pandas 2.0+, mas pode ser desabilitado se necessário
• Reduz consumo de memória em 30-50% para pipelines com muitos slices
• Pode causar comportamentos inesperados se você esperava modificações in-place
• SettingWithCopyWarning é menos relevante agora, mas ainda pode aparecer em código legado

3. Indexação: Hash vs. B-Tree Trade-offs

O Pandas usa diferentes estratégias de indexação dependendo do tipo de índice. Compreender essas estratégias é crucial para otimizar operações de lookup.

import pandas as pd
import numpy as np
from timeit import timeit

# Índice padrão (RangeIndex) - O(1) para acesso posicional
df_range = pd.DataFrame({'value': np.random.randn(1000000)})

# Índice hash (Int64Index com valores únicos) - O(1) para lookup
df_hash = df_range.copy()
df_hash.index = np.random.permutation(1000000)

# Índice ordenado (Int64Index ordenado) - O(log n) mas cache-friendly
df_sorted = df_range.copy()
df_sorted.index = np.arange(1000000)

# Benchmark
print(timeit(lambda: df_range.iloc[500000], number=10000))  # ~0.0001s
print(timeit(lambda: df_hash.loc[500000], number=10000))    # ~0.0005s
print(timeit(lambda: df_sorted.loc[500000], number=10000))  # ~0.0003s

Estratégias de indexação no Pandas:

• RangeIndex: Índice padrão, não consome memória extra, O(1) para acesso posicional
• Int64Index/Float64Index: Usa hash table internamente se valores são únicos, O(1) para lookup
• Index (object): Usa hash table para strings, mas com overhead de objetos Python
• MultiIndex: Estrutura hierárquica, mais lenta para lookup mas excelente para groupby
• CategoricalIndex: Comprime dados repetidos, mas lookup é mais lento

4. Dtypes e ExtensionArrays: Flexibilidade vs. Performance

O Pandas oferece tipos de dados nativos (NumPy-backed) e tipos extensíveis (ExtensionArrays). Essa escolha tem implicações profundas de performance.

import pandas as pd
import numpy as np
from timeit import timeit

# NumPy-backed: int64 (sem suporte a NaN)
df_numpy = pd.DataFrame({'value': np.arange(1000000, dtype='int64')})

# ExtensionArray: Int64 (com suporte a NaN)
df_ext = pd.DataFrame({'value': pd.array(range(1000000), dtype='Int64')})

# Benchmark de operações
print(timeit(lambda: df_numpy['value'].sum(), number=1000))  # ~0.0001s
print(timeit(lambda: df_ext['value'].sum(), number=1000))    # ~0.0005s

# Memória
print(df_numpy.memory_usage(deep=True))  # ~8MB
print(df_ext.memory_usage(deep=True))    # ~16MB (overhead de ExtensionArray)

Trade-offs de tipos:

Tipo	Performance	Flexibilidade	Caso de Uso
int64	Excelente	Sem NaN	Dados limpos, sem valores faltantes
Int64	Bom	Com NaN	Dados com valores faltantes
category	Bom	Valores repetidos	Dados com muita repetição (ex: estados)
string	Moderado	Strings nativas	Operações de string intensivas

5. Operações Vetorizadas vs. Apply: Quando Usar Cada Uma

Uma das maiores fontes de ineficiência em Pandas é o uso de apply() quando operações vetorizadas estão disponíveis. Entender quando cada uma é apropriada é crítico.

import pandas as pd
import numpy as np
from timeit import timeit

df = pd.DataFrame({
    'A': np.random.randn(100000),
    'B': np.random.randn(100000)
})

# ❌ Lento: apply com função Python
def slow_func(row):
    return row['A'] * 2 + row['B'] ** 2

print(timeit(lambda: df.apply(slow_func, axis=1), number=10))  # ~2s

# ✅ Rápido: operação vetorizada
print(timeit(lambda: df['A'] * 2 + df['B'] ** 2, number=10))  # ~0.01s

# ✅ Rápido: apply com função NumPy
print(timeit(lambda: df.apply(np.sum), number=10))  # ~0.05s

Regras práticas:

• Sempre prefira operações vetorizadas (NumPy/Pandas) a apply()
• apply(axis=1) é 100-1000x mais lento que operações vetorizadas
• apply() com funções NumPy é aceitável, mas ainda mais lento que vetorização direta
• Para lógica complexa, considere numba.jit ou Cython em vez de apply()
• itertuples() é mais rápido que iterrows() se você precisar iterar

6. Groupby Internals: Algoritmos de Agrupamento

O groupby() é uma operação fundamental, mas sua implementação interna tem nuances importantes.

import pandas as pd
import numpy as np
from timeit import timeit

df = pd.DataFrame({
    'group': np.random.choice(['A', 'B', 'C', 'D'], 1000000),
    'value': np.random.randn(1000000)
})

# Groupby com agregação simples (otimizado)
print(timeit(lambda: df.groupby('group')['value'].sum(), number=100))  # ~0.01s

# Groupby com agregação customizada (menos otimizado)
print(timeit(lambda: df.groupby('group')['value'].apply(np.sum), number=100))  # ~0.5s

# Groupby com múltiplas agregações (otimizado)
print(timeit(lambda: df.groupby('group')['value'].agg(['sum', 'mean', 'std']), number=100))  # ~0.02s

Otimizações internas do groupby:

• Factorization: Pandas converte chaves de grupo em inteiros para operações mais rápidas
• Cython loops: Agregações built-in (sum, mean, etc.) usam Cython, não Python puro
• Sorted vs. Unsorted: Se dados já estão ordenados, groupby é mais rápido (menos cache misses)
• Múltiplas agregações: Usar .agg(['sum', 'mean']) é mais rápido que múltiplas chamadas

7. Merge e Join: Algoritmos e Complexidade

Operações de merge são custosas. Entender os algoritmos subjacentes ajuda a otimizar.

import pandas as pd
import numpy as np
from timeit import timeit

df1 = pd.DataFrame({
    'key': np.arange(100000),
    'value1': np.random.randn(100000)
})

df2 = pd.DataFrame({
    'key': np.arange(100000),
    'value2': np.random.randn(100000)
})

# Merge com índice (mais rápido)
df1_indexed = df1.set_index('key')
df2_indexed = df2.set_index('key')
print(timeit(lambda: df1_indexed.join(df2_indexed), number=100))  # ~0.01s

# Merge com coluna (mais lento)
print(timeit(lambda: pd.merge(df1, df2, on='key'), number=100))  # ~0.05s

Estratégias de merge:

• Hash join: Padrão no Pandas, O(n+m), bom para dados não-ordenados
• Sort merge: Mais rápido se dados já estão ordenados, O(n log n)
• Index join: Mais rápido se você usar índices, evita hash table
• Broadcast join: Para DataFrames pequenos, considere usar merge_asof() com índices

8. Otimização de Memória: Chunking e Lazy Evaluation

Para datasets que não cabem em memória, estratégias de chunking são essenciais.

import pandas as pd

# ❌ Carrega tudo em memória
df = pd.read_csv('large_file.csv')

# ✅ Processa em chunks
chunk_size = 50000
results = []

for chunk in pd.read_csv('large_file.csv', chunksize=chunk_size):
    # Processar chunk
    processed = chunk[chunk['value'] > 0].groupby('group')['value'].sum()
    results.append(processed)

final_result = pd.concat(results).groupby(level=0).sum()

# ✅ Usar Dask para lazy evaluation (se disponível)
# import dask.dataframe as dd
# ddf = dd.read_csv('large_file.csv')
# result = ddf[ddf['value'] > 0].groupby('group')['value'].sum().compute()

9. Edge Cases e Armadilhas Comuns

Problema 1: Inplace vs. Copy

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3]})

# ❌ Inplace pode ser mais lento (não é otimizado em todas operações)
df.drop('A', axis=1, inplace=True)

# ✅ Melhor: reatribuir
df = df.drop('A', axis=1)

Problema 2: Chained Indexing

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})

# ❌ Chained indexing (impredizível com CoW)
df['A'][0] = 999

# ✅ Usar .loc ou .at
df.loc[0, 'A'] = 999
df.at[0, 'A'] = 999

Problema 3: Comparações com NaN

import pandas as pd
import numpy as np

df = pd.DataFrame({'A': [1, np.nan, 3]})

# ❌ NaN != NaN, isso retorna False
print(df['A'] == np.nan)  # [False, False, False]

# ✅ Usar isna()
print(df['A'].isna())  # [False, True, False]

10. Benchmarking e Profiling

Para otimizar efetivamente, você precisa medir.

import pandas as pd
import numpy as np
from memory_profiler import profile
import cProfile
import pstats

# Profiling de memória
@profile
def memory_intensive():
    df = pd.DataFrame({'A': np.random.randn(1000000)})
    df['B'] = df['A'] * 2
    return df

# Profiling de CPU
def cpu_intensive():
    df = pd.DataFrame({'A': np.random.randn(100000)})
    return df.groupby(df['A'] // 10)['A'].sum()

cProfile.run('cpu_intensive()', sort='cumulative')

Conclusão

Otimizar Pandas requer compreensão profunda de seus internals. Os pontos-chave são:

• BlockManager agrupa colunas por tipo para cache-efficiency
• Copy-on-Write reduz cópias desnecessárias em Pandas 2.0+
• Operações vetorizadas são 100-1000x mais rápidas que apply()
• Escolher o dtype correto (int64 vs Int64) tem impacto significativo
• Indexação e merge são operações custosas que merecem atenção especial
• Para dados grandes, chunking e lazy evaluation são essenciais
• Sempre meça antes de otimizar