Como usar itertools do Python para feature engineering de séries temporais

Python itertools — este é um módulo integrado para trabalhar com iteradores, que se torna uma ferramenta indispensável no feature engineering para séries temporais. Se você está construindo features através de loops e copiando datasets, itertools ajudará você a fazer isso várias vezes mais rápido e com economia de memória.

O que é itertools e por que você precisa dele

O módulo itertools contém funções para criar iteradores rápidos e eficientes em termos de memória. Para trabalhar com séries temporais, isso é crítico: em vez de armazenar listas na memória, geramos features na hora. Em datasets com milhões ou bilhões de pontos, isso não é apenas conveniente — é necessário para trabalhar de forma alguma.

Principais funções itertools para feature engineering:

• `combinations()` — todos os pares e combinações de elementos (features de lag, interações de variáveis)
• `permutations()` — todas as permutações (testando ordens e influência de features)
• `islice()` — extração de subsequências e janelas deslizantes sem cópia
• `zip_longest()` — combinação de séries de comprimentos diferentes com tratamento de valores faltantes
• `chain()` — combinação de iteradores em um fluxo único sem cópia de dados

Exemplos práticos: de abordagem ingênua para escalável

Problema clássico: uma série temporal de preços, precisa-se construir features de lag com defasagens 1, 2, 3.

Abordagem ingênua (lenta):

```python import pandas as pd data = pd.read_csv('prices.csv') for lag in range(1, 4): data[f'price_lag_{lag}'] = data['price'].shift(lag) ```

Problema: cada `shift()` cria uma cópia do dataset na memória. Em 10 milhões de linhas, isso é ~300 milhões de operações de cópia mais 3x de consumo de memória.

Com itertools (rápido e eficiente):

```python from itertools import islice prices = [100, 102, 105, 103, 107, 110] for lag in range(1, 4): lagged = list(islice(prices, lag, None)) print(f'lag {lag}: {lagged}') ```

`islice` não copia a lista — simplesmente desloca o ponteiro para a posição necessária. Em datasets grandes, isso economiza horas de computação.

Segundo exemplo — janelas deslizantes:

```python from itertools import islice, tee

def sliding_window(iterable, n): iterables = tee(iterable, n) for i, it in enumerate(iterables): for _ in range(i): next(it, None) return zip(*iterables)

prices = [100, 102, 105, 103, 107, 110] windows = list(sliding_window(prices, 3)) ```

Isso cria janelas deslizantes de tamanho 3, usando iteradores preguiçosos em vez de copiar o array.

Desempenho: onde a memória e o tempo são economizados

Em datasets com bilhões de pontos:

• Computação preguiçosa — elementos são gerados sob demanda, não carregados como um todo
• Cadeias de operações — `chain()` combina fontes sem cópias intermediárias
• Composição — combinando itertools, construímos um pipeline complexo com memória mínima

Resultado: o consumo de memória pode cair 10-100 vezes. Na nuvem, isso significa uma conta mais barata. Em uma máquina local — funciona com o que anteriormente não cabia na RAM.

O que isso significa para você

Para cientistas de dados: trabalhe com datasets que anteriormente simplesmente não cabiam na memória.

Para engenheiros de ML: um modelo de produção requer menos recursos e é mais estável.

itertools não é mágica, é uma forma integrada de trabalhar com dados de forma mais inteligente. Comece com features de lag e janelas deslizantes, depois encontre onde mais você pode aplicar computação preguiçosa.