Skip to content

Pandas Folha de referência

Biblioteca Python de análise e manipulação de dados.

01

Primeiros Passos

Instalação e Import

pandas é convencionalmente importado como pd, com numpy como np, já que o pandas usa arrays numpy por baixo. As duas estruturas de dados centrais são Series (array 1D rotulado) e DataFrame (tabela 2D rotulada). Quase toda manipulação de dados tabulares em Python começa aqui.

pandas
# Install pandas (pick one)
pip install pandas
conda install pandas

# Standard import convention
import pandas as pd
import numpy as np  # pandas relies heavily on numpy

# Check version
print(pd.__version__)

# Pandas is built on numpy: a Series is a 1D labeled array,
# a DataFrame is a 2D labeled table (dict of Series).

Series e DataFrame

Uma Series tem uma única coluna de valores mais um índice (rótulos). Um DataFrame é uma coleção de Series compartilhando um índice comum — pense numa planilha ou tabela SQL. Você pode construir DataFrames a partir de dicts (chaves=colunas), listas de listas, arrays numpy ou arquivos.

pandas
import pandas as pd

# Series: 1D labeled array
s = pd.Series([10, 20, 30, 40], index=["a", "b", "c", "d"])
# a    10
# b    20
# ...

# DataFrame: 2D table (dict of columns)
df = pd.DataFrame({
    "name":  ["Alice", "Bob", "Charlie"],
    "age":   [25, 30, 35],
    "city":  ["NYC", "LA", "SF"],
})

# From list of lists with column names
df2 = pd.DataFrame([[1, 2], [3, 4]], columns=["a", "b"])

Criando um DataFrame de Exemplo

Para experimentos rápidos, construa um DataFrame pequeno a partir de um dict. Para testes maiores, use geradores aleatórios do numpy com uma seed, por reprodutibilidade. date_range cria DatetimeIndex — a fundação do trabalho com séries temporais. Definir um índice significativo (datas, IDs) cedo torna as seleções e joins posteriores muito mais limpos.

pandas
import pandas as pd
import numpy as np

# Quick test DataFrame with random data
df = pd.DataFrame({
    "id":     range(1, 6),
    "name":   ["Alice", "Bob", "Charlie", "David", "Eve"],
    "age":    [25, 30, 35, 28, 40],
    "score":  [85.5, 92.0, 78.3, 88.9, 95.2],
    "pass":   [True, True, False, True, True],
})

# Larger random DataFrame
rng = np.random.default_rng(42)
big = pd.DataFrame(rng.normal(size=(100, 4)), columns=list("ABCD"))

# Dates as index
dates = pd.date_range("2024-01-01", periods=5)
ts = pd.DataFrame({"value": [1, 2, 3, 4, 5]}, index=dates)

Lendo Dados de Arquivos

read_csv é o cavalo de batalha — sempre especifique sep, encoding, parse_dates e index_col quando relevantes, para evitar limpeza pós-carga. Parquet é muito mais rápido e menor que CSV para grandes conjuntos de dados e preserva dtypes. Para SQL, engines SQLAlchemy tratam o pooling de conexões. read_clipboard é surpreendentemente prático para análise rápida de copiar e colar.

pandas
import pandas as pd

# CSV — the most common
df = pd.read_csv("data.csv")
df = pd.read_csv("data.csv", sep=";", encoding="utf-8",
                 parse_dates=["date"], index_col="id")

# Excel (needs openpyxl)
df = pd.read_excel("data.xlsx", sheet_name="Sheet1")

# JSON
df = pd.read_json("data.json")

# Parquet (fast columnar format, great for large data)
df = pd.read_parquet("data.parquet")

# SQL (needs SQLAlchemy)
from sqlalchemy import create_engine
engine = create_engine("sqlite:///my.db")
df = pd.read_sql("SELECT * FROM users", engine)

# Clipboard (paste a table from a spreadsheet)
df = pd.read_clipboard()

Salvando Dados

Sempre passe index=False ao salvar em CSV/Excel, a menos que seu índice carregue dados significativos — senão você ganha uma coluna espúria 'Unnamed: 0' ao recarregar. Parquet preserva dtypes entre salvar/carregar (CSV não). Use if_exists='append' para adicionar linhas a uma tabela SQL existente, 'replace' para sobrescrever.

pandas
import pandas as pd

# CSV (no index by default is usually what you want)
df.to_csv("output.csv", index=False)
df.to_csv("output.csv", index=False, encoding="utf-8-sig")  # Excel-friendly

# Excel (needs openpyxl)
df.to_excel("output.xlsx", sheet_name="Sheet1", index=False)

# Parquet (preserves dtypes, fast, compressed)
df.to_parquet("output.parquet")

# JSON
df.to_json("output.json", orient="records", indent=2)

# SQL
df.to_sql("users", engine, if_exists="replace", index=False)

# Multiple sheets to one Excel file
with pd.ExcelWriter("multi.xlsx") as writer:
    df1.to_excel(writer, sheet_name="sheet1", index=False)
    df2.to_excel(writer, sheet_name="sheet2", index=False)
02

Inspeção de Dados

Visualizando Dados: head, tail, sample

head/tail mostram as pontas; sample mostra linhas aleatórias, mais representativo para conferir distribuições e formatos. Use set_option para desativar truncamento ao inspecionar DataFrames largos — os padrões escondem colunas e linhas. Sempre olhe dados de amostra antes de qualquer análise, para capturar cedo problemas de codificação, valores sentinela e incompatibilidades de tipo.

pandas
import pandas as pd

# First/last rows
df.head()        # first 5 (default)
df.head(10)      # first 10
df.tail()        # last 5
df.tail(3)       # last 3

# Random sample (great for sanity checks)
df.sample(5)                    # 5 random rows
df.sample(frac=0.1, random_state=42)  # 10% of rows
df.sample(n=5, replace=True)    # sample with replacement (bootstrap)

# See the raw values (not truncated)
pd.set_option("display.max_rows", 200)
pd.set_option("display.max_columns", None)
pd.set_option("display.width", 1000)

Estrutura e Dtypes

info() é a chamada de inspeção mais útil que existe — mostra dtypes, contagens não nulas por coluna e memória. Fique atento ao dtype object (geralmente strings guardadas de forma ineficiente); converter para 'category' ou 'string' economiza memória. memory_usage(deep=True) revela o custo real das colunas object, que costuma ser muito maior que o reportado.

pandas
# Shape and basic structure
df.shape         # (rows, cols)
df.size          # rows * cols
df.ndim          # 2 for DataFrame, 1 for Series
len(df)          # number of rows

# Column names and dtypes
df.columns       # column labels
df.index         # row labels
df.dtypes        # dtype of each column
df.info()        # concise summary: dtypes, non-null counts, memory

# Memory usage (helpful for big data)
df.memory_usage(deep=True)
df.info(memory_usage="deep")

Estatísticas Descritivas

describe() dá um resumo estatístico rápido — atenção a contagens desiguais (valores ausentes) e mínimos/máximos suspeitos. value_counts() é essencial para colunas categóricas (mostra frequência e equilíbrio de classes). corr() assume Pearson; passe method='spearman' para correlação por postos. Sempre use numeric_only=True em frames de tipos mistos para evitar erros.

pandas
# Numeric summary (count, mean, std, min, quartiles, max)
df.describe()
df.describe(include="all")   # include non-numeric too
df.describe(percentiles=[.1, .5, .9])

# Per-column stats
df["age"].mean()
df["age"].median()
df["age"].std()
df["age"].var()
df["age"].min(), df["age"].max()
df["age"].quantile(0.95)

# Non-numeric summaries
df["city"].value_counts()
df["city"].unique()
df["city"].nunique()

# Correlation and covariance
df.corr(numeric_only=True)
df.cov(numeric_only=True)

Valores Únicos e Contagens

value_counts é uma das funções pandas mais usadas — pareie com normalize=True para proporções e dropna=False para verificar ausências. crosstab constrói uma tabela de frequência de dois categóricos, útil para testes qui-quadrado e matrizes de confusão. Binarizar colunas contínuas antes do value_counts revela a forma da distribuição.

pandas
# Unique values
df["city"].unique()              # array of unique values
df["city"].nunique()             # count of unique
df["city"].nunique(dropna=False) # include NaN

# Value counts (frequency table)
df["city"].value_counts()
df["city"].value_counts(normalize=True)   # proportions
df["city"].value_counts(ascending=True)
df["city"].value_counts(dropna=False)     # count NaN too

# Cross tabulation (frequency table of two columns)
pd.crosstab(df["city"], df["pass"])

# Binning then counting
df["age_group"] = pd.cut(df["age"], bins=[0, 18, 30, 50, 100],
                          labels=["child", "young", "adult", "senior"])
df["age_group"].value_counts()

Verificando Valores Ausentes

Sempre verifique ausências antes da análise — isnull().sum() por coluna é a primeira olhada padrão. Preste atenção às colunas com alta fração ausente; podem precisar ser descartadas ou de outra estratégia de tratamento. Linhas com valores ausentes em colunas críticas podem ser filtradas com df[df.isnull().any(axis=1)]. A biblioteca missingno visualiza padrões de ausência para achar problemas estruturais nos dados.

pandas
# Count missing per column
df.isnull().sum()
df.isna().sum()           # alias

# Fraction missing
df.isnull().mean().mul(100).round(2)  # % missing per column

# Total missing
df.isnull().sum().sum()

# Rows with any missing
df[df.isnull().any(axis=1)]

# Non-null counts
df.notnull().sum()

# Visualize missingness pattern
# (requires missingno: import missingno as msno; msno.matrix(df))
03

Básico de Series

Criando Series

Uma Series é um array 1D com rótulos (o índice). O índice permite buscar valores por rótulo, não só por posição. Especificar dtypes menores (int8, float32) economiza memória em dados grandes — int8 guarda -128..127, suficiente para booleanos-como-int ou códigos pequenos. Chaves de dict naturalmente viram o índice.

pandas
import pandas as pd
import numpy as np

# From a list
s = pd.Series([1, 2, 3, 4])

# From a list with custom index
s = pd.Series([10, 20, 30], index=["a", "b", "c"])

# From a dict (keys become index)
s = pd.Series({"a": 1, "b": 2, "c": 3})

# From a numpy array
s = pd.Series(np.random.randn(5))

# Scalar broadcast to an index
s = pd.Series(5, index=["a", "b", "c"])  # [5, 5, 5]

# Specify dtype
s = pd.Series([1, 2, 3], dtype="float64")
s = pd.Series([1, 2, 3], dtype="int8")    # save memory

Indexação e Seleção

Slicing por rótulo (s['a':'c']) é INCLUSIVO nas duas pontas — uma pegadinha comum vs o slicing posicional do Python, que é exclusivo. Use .loc para rótulos e .iloc para posições, para evitar ambiguidade, especialmente com índices inteiros. O s[...] padrão é sobrecarregado (rótulo ou posição conforme o dtype), então .loc/.iloc explícito é mais seguro em código de produção.

pandas
s = pd.Series([10, 20, 30, 40], index=["a", "b", "c", "d"])

# By label (index)
s["a"]            # 10
s[["a", "c"]]     # multiple labels -> Series
s["a":"c"]        # slice INCLUSIVE of both ends (label-based)

# By position
s.iloc[0]         # first by position
s.iloc[-1]        # last
s.iloc[1:3]       # EXCLUSIVE of end (positional, like Python)

# By label with .loc (explicit)
s.loc["a"]
s.loc["a":"c"]    # inclusive

# Boolean indexing
s[s > 20]
s[(s > 10) & (s < 40)]

Operações Vetorizadas

Operações em Series são vetorizadas (sem loops Python) e alinham pelo índice — ao somar duas Series, o pandas casa os rótulos e preenche NaN onde não se sobrepõem. Esse alinhamento de índice é o recurso matador do pandas, mas pode surpreender; use .values para operar em arrays numpy crus se quiser matemática puramente posicional. Operações vetorizadas são 100-1000x mais rápidas que loops iterrows.

pandas
s = pd.Series([1, 2, 3, 4])

# Element-wise arithmetic (aligns on index)
s + 10          # [11, 12, 13, 14]
s * 2
s ** 2
1 / s           # [1.0, 0.5, 0.333, 0.25]

# Between two Series (aligns on index, NaN for mismatches)
s1 = pd.Series({"a": 1, "b": 2, "c": 3})
s2 = pd.Series({"b": 20, "c": 30, "d": 40})
s1 + s2         # a=NaN, b=22, c=33, d=NaN

# Comparison and boolean
s > 2           # [False, False, True, True]
s.between(2, 3) # inclusive

# Math methods
s.sum(), s.mean(), s.std(), s.cumsum()

Funções Úteis de Series

sort_values e rank são ferramentas do dia a dia. drop_duplicates mantém a primeira ocorrência por padrão; use keep='last' para a última. clip é prático para limitar outliers antes de plotar. A maioria das funções ignora NaN por padrão; passe skipna=False para propagar NaN. Muitas funções retornam uma nova Series (o pandas é imutável na maior parte), então encadeie: s.dropna().sort_values().head(10).

pandas
s = pd.Series([3, 1, 4, 1, 5, 9, 2, 6, np.nan])

# Sorting
s.sort_values()                  # ascending
s.sort_values(ascending=False)
s.sort_index()

# Ranking
s.rank(method="average")         # 'min','max','first','dense'

# Unique, counts
s.unique()
s.nunique()
s.value_counts()
s.duplicated()                   # boolean: True if seen before
s.drop_duplicates()

# Statistical
s.sum(), s.prod(), s.cumsum(), s.cummax()
s.abs()
s.round(2)
s.clip(lower=0, upper=10)        # cap values to a range
s.quantile([0.25, 0.5, 0.75])

Tratando NaN em Series

fillna tem muitas estratégias: constante, estatística (média/mediana), preenchimento para frente/trás (ótimo para séries temporais) ou interpolação. ffill/bfill propagam o último valor conhecido — ideal para dados de sensores ou ações que não deveriam saltar. Na leitura, use na_values para converter sentinelas ('?', -999) em NaN, para tratamento uniforme. interpolate suporta os modos linear, time e baseados em índice.

pandas
s = pd.Series([1.0, 2.0, np.nan, 4.0, np.nan])

# Detect
s.isna()             # boolean mask
s.notna()
s.isna().sum()       # count of NaN

# Drop
s.dropna()           # remove NaN

# Fill
s.fillna(0)                       # constant
s.fillna(s.mean())                # with mean
s.fillna(method="ffill")          # forward fill (old API)
s.ffill()                         # forward fill (new)
s.bfill()                         # backward fill
s.interpolate()                   # linear interpolation

# Replace sentinel values with NaN on read
# pd.read_csv("x.csv", na_values=["?", "N/A", ""])
04

Seleção e Filtragem

Selecionando Colunas

A notação com colchetes df['col'] sempre funciona; a notação com ponto df.col é prática, mas falha para nomes com espaços ou que colidem com funções (como 'count'). filter(like=) e select_dtypes são formas limpas de pegar grupos de colunas sem listar cada nome — inestimável em DataFrames largos com centenas de colunas.

pandas
# Single column (returns Series)
df["age"]
df.age            # only if name is a valid Python identifier

# Multiple columns (returns DataFrame)
df[["name", "age", "city"]]

# Columns by pattern
df.filter(like="age")               # columns containing "age"
df.filter(regex="^\d{4}$")          # columns matching regex
df.filter(items=["name", "age"])    # specific columns

# Select by dtype
df.select_dtypes(include="number")
df.select_dtypes(include=["int64", "float64"])
df.select_dtypes(exclude="object")
df.select_dtypes(include="datetime")

loc vs iloc

A pegadinha nº 1 do pandas: .loc usa rótulos (slices inclusivos), .iloc usa posições (slices exclusivos). Para atribuição, SEMPRE use .loc/iloc — indexação encadeada como df[df.a<5]['b']=0 levanta SettingWithCopyWarning e pode falhar silenciosamente. .loc suporta máscaras booleanas (filtragem por rótulo), que é a forma limpa de filtrar e atribuir.

pandas
# .loc: label-based (inclusive slices)
df.loc[5]                         # row with index label 5
df.loc[5, "name"]                 # row 5, column 'name'
df.loc[5:10, ["name", "age"]]     # rows 5-10 (inclusive), 2 cols
df.loc[df["age"] > 30]            # boolean mask

# .iloc: position-based (exclusive slices)
df.iloc[0]                        # first row
df.iloc[-1]                       # last row
df.iloc[0:5]                      # first 5 rows (exclusive)
df.iloc[0:5, 0:2]                 # first 5 rows, first 2 cols
df.iloc[:, 0]                     # all rows, first column

# Setting values (use .loc for assignment!)
df.loc[df["age"] < 0, "age"] = 0  # cap negatives to 0

# AVOID chained indexing: df[df["a"]<5]["b"] = 0  # SettingWithCopyWarning

Filtragem Booleana

Ao combinar condições, use & | ~ com parênteses em cada condição — and/or do Python não funcionam em arrays booleanos. isin é a forma limpa de filtrar por múltiplos valores (mais rápida que == encadeados). Filtragem de strings usa o acessador .str. Nega com ~ (NOT bit a bit). Cada um retorna um novo DataFrame filtrado; atribua a uma variável para mantê-lo.

pandas
# Single condition
df[df["age"] > 30]
df[df["city"] == "NYC"]

# Multiple conditions (use & | ~, NOT and/or/not; parenthesize!)
df[(df["age"] > 25) & (df["city"] == "NYC")]
df[(df["city"] == "NYC") | (df["city"] == "LA")]
df[~df["pass"]]                       # NOT pass

# isin for membership
df[df["city"].isin(["NYC", "LA", "SF"])]

# String methods in filters
df[df["name"].str.startswith("A")]
df[df["name"].str.contains("li", case=False)]

# Between
df[df["age"].between(25, 35, inclusive="both")]

# Null checks
df[df["score"].isnull()]
df[df["score"].notnull()]

Função query()

query() lê como SQL e evita a exigência de parênteses por toda parte da indexação booleana. Use @ para referenciar variáveis locais do Python. Para DataFrames grandes, query pode ser mais rápido, porque avalia a expressão com numexpr, evitando criar arrays booleanos intermediários. É especialmente bom dentro de cadeias groupby e pipelines.

pandas
# query() — string-based filtering, often more readable
df.query("age > 30")
df.query("age > 25 and city == 'NYC'")
df.query("age > 25 and city in ['NYC', 'LA']")
df.query("age > 25 or score > 90")

# Refer to Python variables with @
cities = ["NYC", "LA"]
df.query("city in @cities")

# Compare columns
df.query("score > age")

# Negation
df.query("not pass")

# query is faster than boolean indexing on large frames
# because it uses numexpr to avoid intermediate arrays

Amostragem e Pesos de Amostragem

sample(frac=0.8) seguido de drop(train.index) é uma divisão treino/teste limpa que preserva o índice original. Para amostragem estratificada (preservando proporções de classe), o train_test_split do sklearn é mais confiável que código pandas manual. Amostragem com pesos é útil para amostragem por importância ou simulação de dados enviesados.

pandas
# Random sample
df.sample(n=5)                          # 5 rows
df.sample(frac=0.1)                     # 10% of rows
df.sample(n=5, random_state=42)         # reproducible

# Sample with weights
df.sample(n=5, weights="score")         # higher score -> more likely

# Sample with replacement (bootstrap)
df.sample(n=len(df), replace=True)

# Train/test split
train = df.sample(frac=0.8, random_state=42)
test = df.drop(train.index)

# Stratified sample (preserve class proportions)
from sklearn.model_selection import train_test_split
train, test = train_test_split(df, test_size=0.2,
                                stratify=df["city"], random_state=42)
05

Limpeza de Dados

Tratando Dados Ausentes

dropna(how='all') descarta só linhas totalmente vazias; thresh mantém linhas com pelo menos N valores não nulos. Preencher por coluna com um dict é mais limpo que múltiplas chamadas fillna. Para séries temporais, ffill/bfill e interpolate preservam a continuidade. Sempre considere se a ausência em si é informativa — adicionar uma coluna indicadora 'is_missing' antes de imputar pode preservar esse sinal para ML.

pandas
# Drop rows with any missing
df.dropna()                       # any NaN in any column
df.dropna(how="all")              # only if ALL columns NaN
df.dropna(subset=["age", "city"]) # only check these columns
df.dropna(thresh=3)               # keep rows with >=3 non-NaN

# Fill missing
df.fillna(0)
df.fillna({"age": df["age"].mean(),
           "city": "Unknown"})
df["age"] = df["age"].fillna(df["age"].median())

# Forward/backward fill (for time series)
df.ffill()
df.bfill()

# Interpolate
df.interpolate(method="linear")
df.interpolate(method="time")     # for DatetimeIndex

# Flag rows that were imputed
df["age_was_missing"] = df["age"].isnull()

Removendo Duplicatas

duplicated() marca linhas que repetem uma linha anterior; keep='last' para marcar a primeira ocorrência. keep=False marca toda linha duplicada (incluindo a primeira), útil quando você quer inspecionar todas as linhas conflitantes. drop_duplicates retorna um novo DataFrame; passe inplace=True ou reatribua para modificar. subset permite deduplicar por colunas-chave como e-mail ou ID.

pandas
# Find duplicates
df.duplicated()                   # True for rows that are duplicates of earlier
df.duplicated().sum()             # count
df[df.duplicated()]               # view duplicates

# Drop duplicates
df.drop_duplicates()              # full-row duplicates
df.drop_duplicates(subset=["email"])   # dup on email only
df.drop_duplicates(subset=["name", "dob"], keep="last")  # keep last occurrence
df.drop_duplicates(keep=False)    # drop ALL duplicates (keep none)

# Find rows where a column is duplicated
df[df.duplicated(subset=["email"], keep=False)]
# .keep=False marks ALL duplicates (including first)

Renomeando e Reordenando

rename com um dict de columns é a forma mais segura de renomear — só renomeia as colunas listadas e deixa as outras intocadas. Reordenar colunas é só seleção na ordem desejada. set_index seguido de reset_index(drop=True) é a forma limpa de trocar um índice bagunçado. Use str.strip nos nomes de colunas cedo — espaços finais invisíveis causam KeyError infinitos.

pandas
# Rename columns
df.rename(columns={"old_name": "new_name"})
df.rename(columns=str.upper)        # uppercase all
df.rename(columns=str.strip)        # strip whitespace

# Replace all column names
df.columns = ["id", "name", "age"]

# Add prefix/suffix
df.add_prefix("col_")
df.add_suffix("_v2")

# Reorder columns
df[["name", "age", "city"]]          # select in new order

# Reorder rows by index
df.sort_index()

# Reset / set index
df.reset_index(drop=True)            # drop old index
df.set_index("id")                   # use 'id' as index

# Swap rows and columns
df.transpose()  # or df.T

Conversão de Tipos

astype falha em valores não analisáveis; pd.to_numeric com errors='coerce' transforma valores ruins em NaN — muito mais seguro para dados bagunçados. O dtype 'category' economiza muita memória para strings de baixa cardinalidade. Downcasting (int64->int8) pode cortar a memória em 8x para colunas com faixa pequena de valores. Sempre analise datas com uma string de formato explícita, por velocidade e correção.

pandas
# Convert a column's dtype
df["age"] = df["age"].astype(int)
df["price"] = df["price"].astype(float)
df["pass"] = df["pass"].astype(bool)
df["city"] = df["city"].astype("category")    # save memory

# Convert with pd.to_numeric (handles bad values)
df["price"] = pd.to_numeric(df["price"], errors="coerce")  # bad -> NaN
df["price"] = pd.to_numeric(df["price"], errors="ignore")  # leave as-is

# Parse dates
df["date"] = pd.to_datetime(df["date"], format="%Y-%m-%d")

# Convert multiple columns at once
df = df.astype({"age": "int8", "score": "float32", "city": "category"})

# Downcast to save memory
df["age"] = pd.to_numeric(df["age"], downcast="integer")

Substituindo Valores

replace é o cavalo de batalha para trocar valores sentinela (-999, '?') por NaN antes da análise. map aplica uma consulta de dict elemento a elemento (valores sem correspondência viram NaN). where mantém os valores onde a condição é True e substitui o resto; mask é o inverso. Esses retornam objetos novos — reatribua para aplicar.

pandas
# Replace specific values
df["city"].replace({"NYC": "New York", "LA": "Los Angeles"})
df.replace(-999, np.nan)              # whole frame
df.replace(["?", "N/A", ""], np.nan)  # multiple sentinels

# Replace by condition (mask)
df.loc[df["age"] < 0, "age"] = np.nan

# Clip outliers
df["age"] = df["age"].clip(0, 120)

# Map values with a dict (like a lookup)
df["grade"] = df["score"].map({90: "A", 80: "B", 70: "C"})

# Where: keep where condition True, else replace
df["age"].where(df["age"] >= 0, 0)    # set negatives to 0

# Mask: opposite of where
df["age"].mask(df["age"] < 0, 0)
06

Transformação de Dados

apply e applymap

apply roda uma função Python por elemento/linha — flexível, mas lento (100x mais lento que operações vetorizadas). Sempre prefira operações vetorizadas (df['col'] + 1, .str.upper()) quando possível. Use apply para lógica que não pode ser vetorizada (parsing de string personalizado, transformações condicionais referenciando várias colunas). Para trabalho por linha, axis=1 e acesse colunas via row['col'].

pandas
# Apply a function to each element of a column (Series)
df["age"] = df["age"].apply(lambda x: x + 1)
df["name"] = df["name"].apply(str.upper)

# Apply with multiple args
df["score"] = df["score"].apply(lambda x, n: round(x, n), n=2)

# Apply a function to each ROW (axis=1) — use columns
df["full"] = df.apply(lambda row: f"{row['name']} ({row['age']})", axis=1)

# Apply to every element of a DataFrame (newer: .map)
df = df.map(lambda x: str(x).strip() if isinstance(x, str) else x)

# Vectorized alternative (MUCH faster than apply)
df["age"] = df["age"] + 1  # vectorized, prefer this
df["name"] = df["name"].str.upper()

Adicionando e Modificando Colunas

np.where é o if-else vetorizado — muito mais rápido que apply com lambda. np.select trata múltiplas condições como um case/when. assign é uma forma amigável a encadeamento de adicionar colunas (ótimo em pipelines). insert posiciona uma coluna em um lugar específico. Descarte colunas com drop(columns=[...]) — muito mais claro que del df['col'].

pandas
# Add a new column
df["full_name"] = df["first"] + " " + df["last"]
df["is_adult"] = df["age"] >= 18

# Conditional column with np.where
df["category"] = np.where(df["age"] >= 18, "adult", "minor")

# Multiple conditions with np.select
conditions = [df["age"] < 18, df["age"] < 65, df["age"] >= 65]
choices = ["minor", "adult", "senior"]
df["group"] = np.select(conditions, choices, default="unknown")

# insert at a specific position
df.insert(2, "score_pct", df["score"] / 100)  # at col index 2

# Assign multiple columns at once (returns new df)
df = df.assign(
    age_months=df["age"] * 12,
    score_squared=df["score"] ** 2,
)

# Drop columns
df.drop(columns=["temp", "junk"])

Binning e Discretização

cut divide o intervalo em bins de largura igual (pode produzir bins vazios); qcut divide em bins de frequência igual (cada bin tem ~a mesma contagem) — geralmente mais útil para dados enviesados. right=False torna os bins inclusivos à esquerda [0,18) em vez de inclusivos à direita (0,18]. Colunas binadas viram dtype categórico, perfeito para agregação com groupby.

pandas
# Equal-width bins
df["age_bin"] = pd.cut(df["age"], bins=4)

# Custom bins with labels
df["age_group"] = pd.cut(
    df["age"],
    bins=[0, 18, 30, 50, 100],
    labels=["child", "young", "adult", "senior"],
    right=False,  # left-inclusive: [0, 18)
)

# Equal-frequency bins (quantiles)
df["income_quartile"] = pd.qcut(df["income"], q=4, labels=["Q1","Q2","Q3","Q4"])

# Get bin edges
df["age_bin"].value_counts(sort=False)
pd.cut(df["age"], bins=4).cat.categories  # see the bin ranges

Operações de String (acessador .str)

O acessador .str vetoriza as funções de string do Python — nunca faça loop com apply(str.upper). split com expand=True transforma uma coluna em várias (ótimo para separar nomes). extract com grupos nomeados puxa dados estruturados do texto. Todas as funções .str retornam NaN para entradas NaN e aceitam na= para controlar esse comportamento.

pandas
# All vectorized string methods via .str
df["name"] = df["name"].str.upper()
df["name"] = df["name"].str.lower()
df["name"] = df["name"].str.strip()           # remove leading/trailing
df["name"] = df["name"].str.replace(" ", "_")
df["name"] = df["name"].str.title()           # Title Case

# Split
df["name"].str.split(" ")                     # list per row
df[["first", "last"]] = df["name"].str.split(" ", expand=True)

# Contains / startswith / match (returns boolean)
df["name"].str.contains("li", case=False, na=False)
df["name"].str.startswith("A")
df["name"].str.match(r"^A\w+$")              # regex match

# Extract with regex groups
df["name"].str.extract(r"(?P<first>\w+)\s+(?P<last>\w+)")

# Length
df["name"].str.len()

Datas e Horas (acessador .dt)

Sempre converta colunas de data com pd.to_datetime primeiro, depois use .dt para acessar componentes. O acessador .dt desbloqueia year/month/day/weekday/hour e operações de fuso. O pandas pode comparar datas com strings ('2024-01-01') diretamente. Trabalho com datetime ciente de fuso usa tz_localize (adiciona tz) e tz_convert (troca tz) — não misture datetimes ingênuos e cientes.

pandas
df["date"] = pd.to_datetime(df["date"])

# Extract parts
df["year"]      = df["date"].dt.year
df["month"]     = df["date"].dt.month
df["day"]       = df["date"].dt.day
df["weekday"]   = df["date"].dt.day_name()    # 'Monday'
df["hour"]      = df["date"].dt.hour
df["is_weekend"] = df["date"].dt.dayofweek >= 5

# Date arithmetic
df["age_days"] = (pd.Timestamp("today") - df["date"]).dt.days

# Format back to string
df["date_str"] = df["date"].dt.strftime("%Y-%m-%d")

# Timezone handling
df["date_utc"] = df["date"].dt.tz_localize("UTC")
df["date_local"] = df["date_utc"].dt.tz_convert("US/Eastern")

# Filter by date
df[df["date"] > "2024-01-01"]
df[df["date"].between("2024-01-01", "2024-12-31")]
07

GroupBy e Agregação

GroupBy Básico

groupby segue dividir-aplicar-combinar: divide linhas pela chave de grupo, aplica uma função por grupo, combina resultados. groupby('city')['age'].mean() retorna uma Series indexada por cidade; agg com uma lista retorna um DataFrame. size() conta todas as linhas por grupo (incluindo chaves NaN); value_counts() exclui NaN e ordena por frequência. Múltiplas chaves de grupo criam um índice hierárquico.

pandas
# Split-Apply-Combine: group rows, compute per group
df.groupby("city")["age"].mean()         # one column, one agg
df.groupby("city")["age"].agg(["mean", "median", "std"])

# Multiple columns
df.groupby("city")[["age", "score"]].mean()

# Group by multiple columns (hierarchical)
df.groupby(["city", "pass"])["age"].mean()

# Quick counts per group
df.groupby("city").size()                # includes NaN groups
df["city"].value_counts()                # excludes NaN, sorted

# Iterate over groups
for name, group in df.groupby("city"):
    print(name, len(group))

Múltiplas Agregações

Agregações nomeadas (pandas 0.25+) são a forma mais limpa — as colunas de saída recebem os nomes que você especifica em vez de um MultiIndex. A sintaxe é nova_col=('coluna_origem', 'função'). Funções personalizadas via lambda funcionam, mas são mais lentas que as embutidas (mean, sum etc. são otimizadas em C). Sempre reset_index() se quiser a chave de grupo como coluna comum.

pandas
# Different aggregations per column
df.groupby("city").agg({
    "age":   ["mean", "median", "std"],
    "score": ["min", "max", "count"],
})

# Named aggregations (cleaner output, no MultiIndex)
result = df.groupby("city").agg(
    avg_age=("age", "mean"),
    median_age=("age", "median"),
    n_people=("age", "count"),
    max_score=("score", "max"),
)

# Custom aggregation function
df.groupby("city").agg(
    age_range=("age", lambda x: x.max() - x.min()),
)

# Reset index to get a flat DataFrame
result = result.reset_index()

transform e filter

transform é mágico — retorna uma Series do mesmo comprimento da entrada, transmitindo o resultado de cada grupo aos seus membros. Perfeito para adicionar estatísticas no nível do grupo (média por categoria) junto às linhas originais, ou preencher valores ausentes com médias de grupo. filter mantém ou descarta grupos inteiros com base numa condição booleana por grupo (ex.: descartar cidades com amostras de menos).

pandas
# transform: broadcast group result back to original shape
df["age_mean_city"] = df.groupby("city")["age"].transform("mean")
df["age_dev"] = df["age"] - df.groupby("city")["age"].transform("mean")

# Fill missing with group mean
df["score"] = df.groupby("city")["score"].transform(
    lambda s: s.fillna(s.mean()))

# filter: keep/drop entire groups based on a condition
# keep groups with more than 2 rows
big_groups = df.groupby("city").filter(lambda g: len(g) > 2)
# keep groups where average score > 80
df.groupby("city").filter(lambda g: g["score"].mean() > 80)

apply em Grupos

apply sobre groupby é o mais flexível (roda qualquer função por grupo), mas o mais lento — prefira agregações embutidas (mean, sum) ou transform quando possível. Retornar uma Series da sua função cria um DataFrame com o índice da Series como colunas. idxmax retorna o índice do máximo — use-o para consultar outras colunas da mesma linha.

pandas
# Apply any function per group (most flexible)
def top_scorer(g):
    return g.nlargest(1, "score")

df.groupby("city").apply(top_scorer)
df.groupby("city").apply(lambda g: g.nlargest(2, "score"))

# Normalize within group
df.groupby("city").apply(
    lambda g: (g["score"] - g["score"].mean()) / g["score"].std()
)

# Multiple results per group
def summarize(g):
    return pd.Series({
        "count": len(g),
        "avg_score": g["score"].mean(),
        "top_name": g.loc[g["score"].idxmax(), "name"],
    })

df.groupby("city").apply(summarize)

# include_groups=False (newer pandas) to exclude group cols from g

Tabelas Dinâmicas e Crosstab

pivot_table é groupby + unstack combinados — perfeito para transformar dados longos numa matriz (ex.: nota média por cidade × aprovação). margins=True adiciona totais de linha/coluna. crosstab é um pivot especializado em contar combinações (tabelas de frequência); normalize='index' dá proporções por linha. Melt é o inverso, convertendo wide de volta para long.

pandas
# pivot_table: groupby + reshape in one step
pd.pivot_table(df, values="score", index="city", columns="pass",
               aggfunc="mean")
pd.pivot_table(df, values="score", index="city", columns="pass",
               aggfunc=["mean", "count"], margins=True)

# Multiple values
pd.pivot_table(df, values=["age", "score"], index="city",
               aggfunc={"age": "mean", "score": "max"})

# crosstab: frequency table of two (or more) categoricals
pd.crosstab(df["city"], df["pass"])
pd.crosstab(df["city"], df["pass"], normalize="index")  # row %
pd.crosstab(df["city"], df["pass"], values=df["score"],
            aggfunc="mean")  # like a pivot

# Melt a pivot back to long
wide = pd.pivot_table(df, values="score", index="city", columns="pass")
long = wide.reset_index().melt(id_vars="city", var_name="pass",
                                value_name="score")
08

Merging e Joining

merge (joins estilo SQL)

merge é o JOIN SQL do pandas — how controla inner/left/right/outer/cross. Sempre especifique on explicitamente; se a chave tiver nomes diferentes, use left_on/right_on. Use suffixes para desambiguar colunas sobrepostas (o padrão _x/_y é opaco). validate='m:1' (ou '1:1','1:m','m:m') levanta erro se a cardinalidade do join estiver errada — uma ótima salvaguarda contra duplicação acidental de linhas.

pandas
# Like SQL JOIN
pd.merge(df1, df2, on="id")                     # inner join (default)
pd.merge(df1, df2, on="id", how="left")         # left join
pd.merge(df1, df2, on="id", how="right")
pd.merge(df1, df2, on="id", how="outer")        # full outer
pd.merge(df1, df2, on="id", how="cross")        # cartesian product

# Different column names in each frame
pd.merge(df1, df2, left_on="user_id", right_on="id")

# Join on index
pd.merge(df1, df2, left_index=True, right_index=True)

# Suffixes for overlapping non-key columns
pd.merge(df1, df2, on="id", suffixes=("_left", "_right"))

# Validate to catch unexpected duplicates
pd.merge(df1, df2, on="id", validate="m:1")  # many-to-one expected

concat (empilhamento)

concat empilha DataFrames verticalmente (axis=0, padrão) ou horizontalmente (axis=1). ignore_index=True descarta os índices originais e cria um 0..n-1 limpo — geralmente o que você quer ao empilhar. join='inner' mantém só as colunas compartilhadas (útil quando os frames se desviaram). verify_integrity=True dá erro em índices duplicados, uma rede de segurança para appends bagunçados.

pandas
# Stack vertically (rows) — same columns
pd.concat([df1, df2])
pd.concat([df1, df2], ignore_index=True)   # reindex 0..n-1

# Stack horizontally (columns)
pd.concat([df1, df2], axis=1)

# Concat with keys (hierarchical index)
pd.concat([df1, df2], keys=["q1", "q2"])

# Append (deprecated; use concat)
# df1.append(df2)  # deprecated, use pd.concat

# Verify columns match when stacking
pd.concat([df1, df2], verify_integrity=True)  # error on dup index

# Join options for mismatched columns
pd.concat([df1, df2], join="inner")  # keep only shared columns
pd.concat([df1, df2], join="outer")  # keep all, NaN for missing

join (por índice)

join é açúcar sintático sobre merge para o caso comum de juntar por índices — um pouco mais conciso quando ambos os frames já têm índices significativos. Para juntar por colunas, merge é mais claro. join pode juntar vários DataFrames de uma vez (passe uma lista), o que é prático para combinar várias tabelas de consulta num frame principal.

pandas
# join is merge optimized for joining on the index
df1.join(df2)                          # join on index
df1.join(df2, how="left")              # left, right, inner, outer
df1.join([df2, df3])                   # join multiple at once

# join on a column (set index first)
df1.set_index("id").join(df2.set_index("id"), how="inner")

# Suffix for overlapping columns
df1.join(df2, lsuffix="_left", rsuffix="_right")

# When to use join vs merge:
# - join: keys are the index (faster, cleaner)
# - merge: keys are regular columns (more flexible)

combine e update

combine_first é a forma idiomática de preencher valores ausentes a partir de outro DataFrame — como um coalesce no SQL. update modifica df1 no próprio local, sobrescrevendo só onde df2 tem valores não NaN. São ótimos para atualizar um dataset mestre com dados parciais mais novos. concat + drop_duplicates é uma união/dedup rápida, mas para operações de conjunto de verdade considere merge com indicator=True.

pandas
# combine_first: fill NaN in df1 with values from df2
df1.combine_first(df2)
# Where df1 is NaN, take df2's value; otherwise keep df1.

# update: overwrite df1 in place with non-NaN from df2
df1.update(df2)

# combine with a custom function
import numpy as np
df1.combine(df2, lambda s1, s2: np.minimum(s1, s2))

# Concat then drop duplicates (union with dedup)
pd.concat([df1, df2]).drop_duplicates()

Verificando Resultados de Merge

indicator=True é inestimável para depurar joins — diz de qual lado vieram as linhas. Um salto súbito na contagem de linhas após um merge geralmente significa chaves duplicadas num frame; verifique com value_counts() na chave antes de juntar. Para o simples 'filtrar df1 às linhas cuja chave existe em df2', use isin (semi-join) — sem merge real.

pandas
# indicator=True adds a '_merge' column showing the source
merged = pd.merge(df1, df2, on="id", how="outer", indicator=True)
# _merge values: 'left_only', 'right_only', 'both'

# Find rows in df1 but not df2 (anti-join)
only_left = merged[merged["_merge"] == "left_only"]

# Find rows in both (intersection)
both = merged[merged["_merge"] == "both"]

# Detect unexpected row explosion (duplicate keys)
print(len(df1), len(df2), len(merged))
# if len(merged) >> max(len(df1), len(df2)) you have duplicate keys

# isin for a simple semi-join (filter df1 to keys in df2)
df1[df1["id"].isin(df2["id"])]            # semi-join
df1[~df1["id"].isin(df2["id"])]           # anti-join
09

Remodelagem de Dados

melt (wide para long)

melt converte dados em formato wide (uma linha por entidade, muitas colunas de medição) para long (uma linha por medição), que é o formato tidy preferido pela maioria das bibliotecas de ML/estatística. id_vars são as colunas identificadoras mantidas como estão; o resto inteiro vira pares var/value. O formato long é mais fácil para groupby, filtrar e plotar.

pandas
# melt: unpivot columns into rows
df_wide = pd.DataFrame({
    "id": [1, 2],
    "q1": [10, 20],
    "q2": [15, 25],
    "q3": [20, 30],
})

long = df_wide.melt(id_vars="id", var_name="quarter", value_name="score")
#    id quarter  score
# 0   1      q1     10
# 1   2      q1     20
# ...

# Melt only specific columns
df_wide.melt(id_vars="id", value_vars=["q1", "q2"])

# Keep the wide columns too (with identifier)
df_wide.melt(id_vars="id", value_vars=["q1","q2","q3"],
             var_name="quarter", value_name="score",
             ignore_index=True)

pivot (long para wide)

pivot remodela long para wide sem agregação — falha se houver pares (index, columns) duplicados; nesse caso, use pivot_table com um aggfunc. Os nomes das colunas viram as colunas do pivot, o que pode confundir — reset_index() e columns.name=None limpam o resultado. pivot é o inverso de melt.

pandas
# pivot: long to wide (without aggregation)
df_long = pd.DataFrame({
    "id": [1, 1, 1, 2, 2, 2],
    "quarter": ["q1", "q2", "q3", "q1", "q2", "q3"],
    "score": [10, 15, 20, 30, 35, 40],
})

wide = df_long.pivot(index="id", columns="quarter", values="score")
# quarter  q1  q2  q3
# id
# 1        10  15  20
# 2        30  35  40

# pivot fails on duplicate index/value combos — use pivot_table then
df_long.pivot_table(index="id", columns="quarter",
                    values="score", aggfunc="sum")

# Restore a regular column from the index
wide = wide.reset_index()
wide.columns.name = None

stack e unstack

stack/unstack movem níveis entre linhas e colunas em objetos MultiIndex — poderosos para remodelar resultados agrupados. groupby com múltiplas chaves produz uma Series com MultiIndex; unstack transforma um nível em colunas, para uma visão de matriz. stack é o inverso. São os blocos de construção das tabelas dinâmicas por baixo dos panos.

pandas
# MultiIndex column example
df = pd.DataFrame({
    ("A", "x"): [1, 2],
    ("A", "y"): [3, 4],
    ("B", "x"): [5, 6],
})

# stack: turn column level into inner row index
stacked = df.stack()
# Now a Series with MultiIndex (row, col_level_2)

# unstack: inverse — turn row level into column level
stacked.unstack()

# Common use: reshape grouped result
g = df.groupby(["city", "year"])["score"].mean()
# city  year
# NYC   2023    80
# NYC   2024    85
# LA    2023    70

g.unstack("year")  # years become columns
#        2023  2024
# city
# NYC    80    85
# LA     70    NaN

Explodindo Listas

explode transforma uma coluna de listas numa linha por elemento da lista, duplicando as outras colunas — essencial para dados aninhados (arrays JSON, registros com múltiplas tags). É a forma limpa de normalizar colunas com listas antes da análise. Para o caminho inverso (combinar linhas numa lista), use groupby + apply(list).

pandas
# explode: turn list-like values into separate rows
df = pd.DataFrame({
    "id": [1, 2],
    "tags": [["python", "ml"], ["sql", "db", "etl"]],
})
#              id           tags
# 0             1  [python, ml]
# 1             2  [sql, db, etl]

exploded = df.explode("tags")
#    id    tags
# 0   1  python
# 0   1      ml
# 1   2     sql
# 1   2      db
# 1   2    etl

# Useful after str.split
df["tags"] = df["tags_str"].str.split(",")
exploded = df.explode("tags")

# Aggregate back: groupby + list
exploded.groupby("id")["tags"].apply(list)

Operações com MultiIndex

MultiIndex (índice hierárquico) permite representar dados de alta dimensão em 2D. xs (corte transversal) seleciona num nível específico sem precisar especificar cada um dos níveis externos. swaplevel e sort_index(level=) reordenam níveis para visões diferentes. Na maior parte do tempo, reset_index() achata um MultiIndex de volta a colunas comuns, o que é mais fácil de trabalhar.

pandas
# Create a MultiIndex DataFrame
idx = pd.MultiIndex.from_tuples([("NYC", 2023), ("NYC", 2024),
                                  ("LA", 2023)], names=["city", "year"])
df = pd.DataFrame({"score": [80, 85, 70]}, index=idx)

# Select by outer level
df.loc["NYC"]              # all NYC rows
df.xs("NYC", level="city") # same, more explicit

# Select by inner level
df.xs(2023, level="year")

# Swap levels
df.swaplevel()

# Sort by level
df.sort_index(level="year")

# Reset one level back to a column
df.reset_index(level="year")

# Flatten columns after a groupby
g = df.groupby(["city", "year"]).mean().reset_index()
10

Ordenação e Ranking

Ordenando Valores

sort_values com uma lista de colunas e uma lista ascending correspondente ordena lexicograficamente — chave primária primeiro, depois desempate. na_position controla onde vão os NaN (padrão 'last'). A ordenação é estável, então chaves iguais preservam a ordem original. Ordenar altera a ordem do índice; reset_index(drop=True) dá um índice sequencial limpo depois.

pandas
# Sort by one column
df.sort_values("age")
df.sort_values("age", ascending=False)

# Sort by multiple columns (stable sort)
df.sort_values(["city", "age"], ascending=[True, False])
# city ascending, age descending within each city

# Put NaNs first or last
df.sort_values("score", na_position="first")

# In-place (modifies df)
df.sort_values("age", inplace=True)

# Sort by index
df.sort_index()
df.sort_index(axis=1)            # sort columns by name
df.sort_index(ascending=False)

# Reset index after sorting
df.sort_values("age").reset_index(drop=True)

Ranking

rank é essencial para calcular percentis, top-N dentro de grupos e estatísticas não paramétricas. method='dense' dá 1,2,2,3 (sem lacunas) — ótimo para medalhas ou notas; 'first' desempata pela ordem de aparição. rank(pct=True) retorna percentis. groupby + rank calcula rankings dentro do grupo (ex.: maior vendedor por região).

pandas
# Default rank: average for ties (1, 2.5, 2.5, 4)
df["rank"] = df["score"].rank()

# Methods for handling ties
df["score"].rank(method="average")  # default
df["score"].rank(method="min")      # ties get the min rank
df["score"].rank(method="max")      # ties get the max rank
df["score"].rank(method="first")    # ties broken by order of appearance
df["score"].rank(method="dense")    # 1, 2, 2, 3 (no gaps)

# Ascending / descending
df["score"].rank(ascending=False)   # highest = rank 1

# Rank as percentile
df["pct"] = df["score"].rank(pct=True)

# Rank within groups
df["city_rank"] = df.groupby("city")["score"].rank(ascending=False)

nlargest e nsmallest

nlargest/nsmallest são otimizados — usam um heap internamente, então são mais rápidos que ordenar o frame inteiro quando você só precisa de poucas linhas (ex.: top 10 de um milhão). Para 'top N por grupo', groupby + apply(nlargest) é o idioma, embora seja mais lento que sort completo + groupby head em alguns dados. keep controla o desempate ('first', 'last', 'all').

pandas
# Top N rows — faster than sort_values + head on large data
df.nlargest(5, "score")            # top 5 by score
df.nlargest(5, "score", keep="first")  # tie-breaking
df.nsmallest(3, "age")             # youngest 3

# Top N per group
df.groupby("city").apply(lambda g: g.nlargest(2, "score"))

# Bottom N with multiple columns
df.nsmallest(5, ["age", "score"])

# Equivalent sort_values (slower for big data)
df.sort_values("score", ascending=False).head(5)

Ordenando Índices e Colunas

sort_index(axis=1) coloca as colunas em ordem alfabética — prático depois que merges adicionam colunas em ordem arbitrária. Para pôr colunas-chave primeiro (como 'id', 'name'), use concatenação de listas: colunas da frente e depois o resto. A seleção explícita de colunas df[[...]] é a forma mais clara de reordenar e também como você subconjunta colunas.

pandas
# Sort the row index
df.sort_index()
df.sort_index(ascending=False)

# Sort columns alphabetically
df.sort_index(axis=1)
df.sort_index(axis=1, ascending=False)

# Reorder columns explicitly
df[["name", "age", "city", "score"]]

# Reorder to a pattern
cols = sorted(df.columns)
df = df[cols]

# Move specific columns to the front
front = ["id", "name"]
df = df[front + [c for c in df.columns if c not in front]]

Ordenação com Keys

sort_values(key=) aplica uma função à coluna antes de ordenar — ordenações sem diferenciar caixa ou por comprimento. Colunas Categóricas ordenadas classificam pela ordem de categorias definida, não alfabeticamente — ótimo para dias da semana, tamanhos (P<M<G) ou ordens de negócio personalizadas. Ordenação natural (arquivo1, arquivo2, arquivo10) precisa de uma key personalizada que separe dígitos.

pandas
# Sort by a function of the values (key, like sorted())
df.sort_values("name", key=lambda s: s.str.lower())
# case-insensitive sort

# Sort by string length
df.sort_values("name", key=lambda s: s.str.len())

# Sort by a custom order (categorical)
df["city"] = pd.Categorical(df["city"],
    categories=["NYC", "LA", "SF"], ordered=True)
df.sort_values("city")  # follows the defined category order

# Natural sort (numbers in strings)
import re
def natural_key(s):
    return [int(t) if t.isdigit() else t for t in re.split(r"(\d+)", s)]
df.sort_values("version", key=lambda s: s.map(natural_key))
11

Operações com Datetime

Analisando Datas

Sempre passe uma string de formato explícita quando a souber — é 10x mais rápida que a inferência e evita ambiguidade (01/02/2024 pode ser 2 de janeiro ou 1º de fevereiro). errors='coerce' transforma valores não analisáveis em NaT (Not a Time, o NaN de datetime). pd.to_datetime num DataFrame com colunas year/month/day constrói datas a partir das partes.

pandas
# Parse strings to datetime
df["date"] = pd.to_datetime(df["date"])
df["date"] = pd.to_datetime(df["date"], format="%Y-%m-%d")  # faster + safer

# Handle mixed formats
df["date"] = pd.to_datetime(df["date"], format="mixed")

# Coerce bad values to NaT (datetime NaN)
df["date"] = pd.to_datetime(df["date"], errors="coerce")

# Parse on read
df = pd.read_csv("data.csv", parse_dates=["date", "created_at"])

# Parse multiple columns into one
df["datetime"] = pd.to_datetime(df[["year", "month", "day"]])

# Timestamp (scalar)
pd.Timestamp("2024-06-15 14:30:00")
pd.Timestamp.now()
pd.Timestamp("2024-06-15").tz_localize("UTC")

date_range e Periods

date_range gera sequências de DatetimeIndex com strings de freq flexíveis: 'D' (dia), 'H' (hora), 'MS' (início do mês), 'W-MON' (segundas semanais), 'Q' (trimestre). bdate_range pula fins de semana. Period representa um intervalo (um mês inteiro, um trimestre) em vez de um instante — útil para períodos de relatório. Aliases de freq são poderosos: '2D' = a cada 2 dias.

pandas
# Generate a sequence of dates
pd.date_range("2024-01-01", "2024-01-10")           # daily
pd.date_range("2024-01-01", periods=10)             # 10 days
pd.date_range("2024-01-01", periods=10, freq="H")   # hourly
pd.date_range("2024-01-01", "2024-12-31", freq="MS") # month start
pd.date_range("2024-01-01", "2024-12-31", freq="W-MON") # weekly Mondays

# Business days only
pd.bdate_range("2024-01-01", periods=10)

# Period (represents an interval, like a month)
p = pd.Period("2024-06", freq="M")
p.to_timestamp()    # convert to the month's start
p.start_time, p.end_time

# Period range
pd.period_range("2024-01", "2024-12", freq="M")

Resampling e Conversão de Frequência

resample é o groupby para séries temporais — downsample com uma agregação (somam e médias de W/M/Q), upsample com um preenchimento (ffill, interpolate). resample exige um DatetimeIndex. Os argumentos 'label' e 'closed' controlam se a fronteira do bin pertence ao período esquerdo ou direito — importante para agregações semanais/mensais, para evitar erros de uma unidade.

pandas
ts = pd.Series(range(100), index=pd.date_range("2024-01-01", periods=100, freq="D"))

# Downsample (more frequent -> less frequent): use agg
ts.resample("W").sum()       # weekly sum
ts.resample("M").mean()      # monthly mean
ts.resample("QE").max()      # quarterly max

# Upsample (less -> more frequent): need fill
ts.resample("H").asfreq()            # hourly, NaN for gaps
ts.resample("H").ffill()             # forward fill
ts.resample("H").interpolate()       # linear interp

# Custom aggregation
ts.resample("W").agg(["mean", "std", "count"])

# Resample with multiple columns
df.resample("M").agg({"sales": "sum", "visits": "mean"})

# Use 'label' and 'closed' to control bin edges
ts.resample("M", label="right", closed="right").sum()

Shift e Lags

shift, diff e pct_change são a fundação da engenharia de features para séries temporais. shift(1) cria um lag (o valor de ontem alinhado à linha de hoje) — perfeito para features autorregressivas. shift(-1) espiar o futuro (use para construir alvos do próximo passo). diff e pct_change medem mudanças. Sempre ordene pelo tempo antes de usá-los e fique atento a NaN nas bordas.

pandas
# Shift values forward/backward (for time-series features)
ts.shift(1)          # move values down by 1 (yesterday's value)
ts.shift(-1)         # move up by 1 (tomorrow's value)

# Difference (today - yesterday)
ts.diff()            # first difference
ts.diff(7)           # week-over-week difference

# Percentage change
ts.pct_change()
ts.pct_change(periods=7)  # 7-day pct change

# Lag features for ML
df["lag_1"]  = df["sales"].shift(1)
df["lag_7"]  = df["sales"].shift(7)
df["roll_7"] = df["sales"].rolling(7).mean()
df["target_next"] = df["sales"].shift(-1)  # next-day target

# Shift by a time frequency
ts.shift(1, freq="D")   # shift the INDEX by 1 day

Janelas Rolling e Expanding

rolling computa uma estatística sobre uma janela deslizante — médias móveis, volatilidade etc. min_periods permite que janelas parciais computem (senão as primeiras N-1 são NaN). ewm dá médias móveis ponderadas exponencialmente (pontos recentes pesam mais — comum em finanças). expanding cresce desde o início (estatísticas cumulativas). Janelas baseadas em tempo ('7D') tratam amostragem irregular corretamente, diferente de janelas por contagem de linhas.

pandas
s = pd.Series([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], dtype=float)

# Rolling window (fixed-size sliding window)
s.rolling(3).mean()        # 3-period moving average
s.rolling(7).std()
s.rolling(3, min_periods=1).mean()  # allow partial windows

# Custom aggregation
s.rolling(3).apply(lambda x: x.max() - x.min())

# Exponentially weighted (decaying weights)
s.ewm(span=7).mean()       # EWMA — recent data weighted more
s.ewm(alpha=0.3).mean()

# Expanding window (grows from start)
s.expanding().mean()       # cumulative mean
s.expanding().max()        # running max

# Window with time-based offset (needs DatetimeIndex)
ts.rolling("7D").mean()    # 7-day window, not 7 rows
12

Dados Categóricos

Criando Categóricos

O dtype category guarda strings como códigos inteiros mais uma tabela de consulta — enorme economia de memória para colunas de baixa cardinalidade (uma coluna de cidade com 5 valores únicos e um milhão de linhas). Categóricos ordenados suportam comparações (size > 'M') e ordenam pela ordem de categoria, não alfabeticamente. Use category para colunas com um conjunto pequeno e conhecido de valores.

pandas
# Convert to category dtype
df["city"] = df["city"].astype("category")

# Create with explicit categories
s = pd.Categorical(["a", "b", "a", "c"],
                    categories=["a", "b", "c", "d"])

# Ordered categorical (for sorting & comparisons)
size = pd.Categorical(["M", "L", "S", "XL"],
                       categories=["S", "M", "L", "XL"],
                       ordered=True)
size > "M"  # works because it's ordered

# Memory savings
df["city"].memory_usage(deep=True)              # object
df["city"].astype("category").memory_usage(deep=True)  # much less

O Acessador .cat

O acessador .cat manipula metadados categóricos. remove_unused_categories apara a lista de categorias aos valores reais — importante depois de filtrar, quando muitas categorias ficam vazias. rename_categories muda rótulos sem mudar os códigos subjacentes. reorder_categories muda a ordem de classificação. Todas retornam novas Series; reatribua para aplicar.

pandas
s = pd.Series(["a", "b", "a", "c"], dtype="category")

# Inspect categories
s.cat.categories        # Index(['a', 'b', 'c'])
s.cat.codes             # integer codes
s.value_counts()

# Add / remove categories
s = s.cat.add_categories(["d"])
s = s.cat.remove_categories(["d"])     # values in 'd' become NaN
s = s.cat.remove_unused_categories()

# Rename categories
s = s.cat.rename_categories({"a": "alpha", "b": "beta"})

# Reorder categories
s = s.cat.reorder_categories(["c", "b", "a"])

# Set / unset ordering
s = s.cat.as_ordered()
s = s.cat.as_unordered()

Operações Categóricas

Operações categóricas são geralmente mais rápidas que operações object (string) para groupby e value_counts. Ao mesclar duas colunas categóricas, alinhe primeiro os conjuntos de categorias com set_categories — categorias desiguais causam merges lentos e NaNs silenciosos. Converta de volta para string/object com astype(str) quando o custo da categoria não compensa (ex.: colunas de texto livre).

pandas
# Operations preserve categorical dtype where possible
s = pd.Series(["low", "high", "med", "low"], dtype="category")
s.value_counts()

# Comparison on ordered categoricals
size = pd.Series(["M", "L", "S"], dtype="category")
size = size.cat.as_ordered().cat.reorder_categories(["S","M","L","XL"])
size > "M"   # boolean Series

# Groupby works as expected
df.groupby("city")["score"].mean()

# Converting back
df["city"] = df["city"].astype(str)         # to string
df["city"] = df["city"].astype("object")    # to object

# Beware: merges between categoricals can be slow if categories differ
# Align categories before merging:
cats = sorted(set(df1["city"].cat.categories) |
              set(df2["city"].cat.categories))
df1["city"] = df1["city"].cat.set_categories(cats)
df2["city"] = df2["city"].cat.set_categories(cats)

Otimização de Memória

A otimização de memória importa ao carregar dados grandes: converta strings de baixa cardinalidade para category (economia de 10-100x), faça downcast de numéricos (int64->int8 para inteiros de faixa pequena, float64->float32). O dtype 'string' (pandas 1.0+) é mais eficiente em memória que object e trata NaN melhor. Regra prática: se nunique/len < 0.5, category compensa.

pandas
# Check current memory
df.info(memory_usage="deep")

# Convert object columns to category when cardinality is low
for col in df.select_dtypes(include="object"):
    if df[col].nunique() / len(df) < 0.5:  # <50% unique
        df[col] = df[col].astype("category")

# Downcast numeric columns
df["age"] = pd.to_numeric(df["age"], downcast="integer")
df["score"] = pd.to_numeric(df["score"], downcast="float")

# Use string dtype (pandas 1.0+) instead of object
df["name"] = df["name"].astype("string")

# Compare memory before/after
before = df.memory_usage(deep=True).sum()
# ... optimize ...
after = df.memory_usage(deep=True).sum()
print(f"Reduced from {before/1e6:.1f}MB to {after/1e6:.1f}MB")

Variáveis Dummy (One-Hot)

get_dummies codifica colunas categóricas em colunas indicadoras 0/1 — essencial antes de modelos lineares que não tratam categóricos. drop_first evita a armadilha da variável dummy (multicolinearidade) na regressão linear. Para pipelines de ML, prefira o OneHotEncoder do sklearn (trata categorias não vistas no teste via handle_unknown='ignore') a get_dummies.

pandas
# One-hot encode categoricals
pd.get_dummies(df["city"])
pd.get_dummies(df, columns=["city", "pass"])  # encode multiple

# Drop first to avoid multicollinearity (for linear models)
pd.get_dummies(df["city"], drop_first=True)

# With a prefix
pd.get_dummies(df["city"], prefix="city")

# From categorical with all categories
pd.get_dummies(df["city"].astype("category"))

# Alternatively, sklearn's OneHotEncoder (for ML pipelines)
from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(sparse_output=False, handle_unknown="ignore")
X_ohe = ohe.fit_transform(df[["city"]])
13

Desempenho e Otimização

Vetorização (evite iterrows)

iterrows é o pecado nº 1 de desempenho do pandas — é 100-1000x mais lento que operações vetorizadas. Sempre prefira operações de coluna vetorizadas (df['a'] + df['b']), .str para strings e np.where para if-else. Se realmente precisar de loop, itertuples é muito mais rápido que iterrows (namedtuples vs Series). Para lógica complexa, considere numba ou cython, ou extraia para numpy com .to_numpy().

pandas
# BAD: iterrows is extremely slow
for idx, row in df.iterrows():
    df.loc[idx, "x"] = row["a"] + row["b"]

# GOOD: vectorized operations
df["x"] = df["a"] + df["b"]

# GOOD: .str accessor for strings
df["name"] = df["name"].str.upper()

# GOOD: np.where for conditionals
df["cat"] = np.where(df["a"] > 0, "pos", "neg")

# If you must iterate (rare), use itertuples (faster than iterrows)
for row in df.itertuples():
    process(row.a, row.b)

# Or .to_numpy() / .values for raw array loops
for row in df[["a", "b"]].to_numpy():
    ...

# Benchmark
%timeit df["a"] + df["b"]
%timeit df.apply(lambda r: r["a"] + r["b"], axis=1)

eval e query

eval e query analisam expressões em string e as avaliam com numexpr, que pode ser 2-4x mais rápido que aritmética Python em DataFrames grandes, porque evita criar arrays intermediários e usa avaliação em nível C. O benefício diminui em dados pequenos (custo de análise). Útil para expressões complexas em frames grandes — mas sempre faça benchmark, pois não é sempre mais rápido.

pandas
# eval: evaluate string expressions (uses numexpr, faster on big data)
df.eval("total = a + b + c", inplace=True)
df.eval("ratio = a / (b + c)")
df.eval("c = a > b")

# Multiple operations in one eval (efficient)
df.eval("""
total = a + b
ratio = a / b
flag = a > 10
""", inplace=True)

# query: boolean filter via string (same engine)
df.query("a > 0 and b < 10")

# Local variables with @
threshold = 5
df.query("a > @threshold")

# eval is faster than Python arithmetic on large frames
# because it avoids intermediate arrays

Dtypes Eficientes

Escolher o dtype certo é a grande vitória mais fácil para memória: faça downcast de inteiros (int64->int8 economiza 8x), use category para strings de baixa cardinalidade (10-100x), use 'string' em vez de object. Int64 anulável (I maiúsculo) trata colunas de inteiros com NaN — int64 comum não pode ter NaN, então tais colunas assumem float64. O dtype Sparse ajuda com dados majoritariamente zero.

pandas
# Downcast numerics
df["age"] = pd.to_numeric(df["age"], downcast="unsigned")  # 0-255
df["score"] = pd.to_numeric(df["score"], downcast="float")

# Use category for low-cardinality strings
df["city"] = df["city"].astype("category")

# Use 'string' dtype instead of object
df["name"] = df["name"].astype("string")

# Use Nullable integers (Int64 with capital I) for ints with NaN
df["count"] = df["count"].astype("Int64")  # supports NaN

# Sparse for mostly-zero data
s = pd.Series([0, 0, 0, 1, 0, 0]).astype("Sparse[int]")

# Compare memory
df["city"].astype("object").memory_usage(deep=True)
df["city"].astype("category").memory_usage(deep=True)

Processamento em Chunks

read_csv(chunksize=...) retorna um iterator — cada chunk é um DataFrame com aquela quantidade de linhas, permitindo processar arquivos maiores que a memória. Agregue por chunk e depois combine os resultados parciais. Para SQL, chunksize usa cursores no lado do servidor. Esta é a forma mais simples de tratar dados em escala de gigabytes sem Spark; para big data de verdade, considere Dask ou Polars.

pandas
# Process a large CSV in chunks (low memory)
chunk_iter = pd.read_csv("huge.csv", chunksize=100_000)

results = []
for chunk in chunk_iter:
    # process each chunk (filter, aggregate, etc.)
    result = chunk.groupby("city")["sales"].sum()
    results.append(result)

# Combine chunk results
total = pd.concat(results).groupby(level=0).sum()

# Or use the iterator directly
for i, chunk in enumerate(pd.read_csv("huge.csv", chunksize=50000)):
    chunk.to_parquet(f"part_{i:04d}.parquet")

# For SQL, use server-side cursors
chunks = pd.read_sql("SELECT * FROM big_table", engine,
                     chunksize=100000)

Profiling e Benchmarking

Sempre faça benchmark antes de otimizar — %timeit compara abordagens rapidamente. ydata-profiling (antes pandas-profiling) gera um relatório HTML completo (estatísticas, correlações, ausências) — inestimável para EDA. Fique atento ao SettingWithCopyWarning: ele sinaliza que sua atribuição pode não persistir, fonte comum de bugs silenciosos. Defina mode.chained_assignment='raise' para capturá-los como erros no desenvolvimento.

pandas
# Time an operation
%timeit df["a"] + df["b"]

# Line profiling (install line_profiler)
# %load_ext line_profiler
# %lprun -f my_function my_function(df)

# Memory profiling (install memory_profiler)
# %load_ext memory_profiler
# %memit df.groupby("city").sum()

# pandas profiling report (install ydata-profiling)
# from ydata_profiling import ProfileReport
# ProfileReport(df).to_file("report.html")

# Quick stats
df.info(memory_usage="deep")
df.describe(include="all")

# Find slow ops
import pandas as pd
pd.set_option("mode.chained_assignment", "warn")  # catch copy bugs
14

Bancos de Dados e SQL

Lendo de SQL

Engines SQLAlchemy tratam pooling de conexões e diferenças de dialeto — use-as em vez de conexões DBAPI cruas. Sempre use consultas parametrizadas (params=) para valores fornecidos pelo usuário, para prevenir SQL injection. chunksize transmite tabelas grandes em lotes. Para consultas complexas, escreva-as em SQL (o banco é otimizado para elas) e deixe o pandas cuidar do resultado.

pandas
from sqlalchemy import create_engine
import pandas as pd

# Create an engine (connection pool)
engine = create_engine("sqlite:///my.db")
engine = create_engine("postgresql://user:pass@host:5432/db")
engine = create_engine("mysql+pymysql://user:pass@host/db")

# Read a whole table
df = pd.read_sql("users", engine)

# Read a query
df = pd.read_sql("SELECT * FROM users WHERE age > 18", engine)

# Parameterized queries (safe from SQL injection)
df = pd.read_sql(
    "SELECT * FROM users WHERE city = %s",
    engine,
    params=("NYC",),
)

# Chunked reads for large tables
for chunk in pd.read_sql("SELECT * FROM big", engine, chunksize=100000):
    process(chunk)

Escrevendo em SQL

if_exists='replace' descarta e recria a tabela; 'append' adiciona linhas; 'fail' (padrão) levanta erro se a tabela existe. method='multi' agrupa linhas numa única instrução INSERT — muito mais rápido que o padrão de uma linha por instrução. Para escritas muito grandes, chunksize=10000 equilibra memória e idas e voltas. Sempre passe index=False, a menos que o índice seja dado real.

pandas
# Write a DataFrame to a SQL table
df.to_sql("users", engine, if_exists="replace", index=False)
df.to_sql("users", engine, if_exists="append", index=False)  # add rows

# Specify schema and dtype
from sqlalchemy.types import VARCHAR, INTEGER
df.to_sql("users", engine, if_exists="replace",
          dtype={"name": VARCHAR(100), "age": INTEGER()})

# Write in chunks (for large DataFrames)
df.to_sql("users", engine, if_exists="append",
          chunksize=10000, method="multi")

# method='multi' uses a single INSERT with multiple rows (faster)
# For PostgreSQL, method='multi' with chunksize ~10000 is optimal

# Don't write the index unless it's meaningful data
# index=False avoids a spurious 'index' column

Operações Estilo SQL no pandas

A maioria das operações SQL mapeia para o pandas: SELECT é seleção de colunas, WHERE é indexação booleana, GROUP BY é groupby, JOIN é merge, UNION é concat+drop_duplicates, CASE WHEN é np.where. Conhecer esses mapeamentos permite escolher a ferramenta certa: SQL para joins/agregações complexas no servidor (deixando o banco otimizar), pandas para análise iterativa e plotagem.

pandas
# SELECT cols
df[["name", "age"]]
# WHERE
df[df["age"] > 18]
# GROUP BY + aggregations
df.groupby("city")["age"].mean()
# ORDER BY
df.sort_values("age", ascending=False)
# LIMIT
df.head(10)
# DISTINCT
df["city"].unique()
df.drop_duplicates(subset=["city"])
# JOIN
pd.merge(df1, df2, on="id", how="inner")
# UNION
pd.concat([df1, df2]).drop_duplicates()
# CASE WHEN
np.where(df["age"] >= 18, "adult", "minor")
# HAVING
g = df.groupby("city").filter(lambda g: g["age"].mean() > 30)

Execução SQL com text()

SQLAlchemy 2.0 exige text() para strings SQL cruas — é uma medida de segurança que separa SQL confiável de parâmetros não confiáveis. engine.begin() abre uma transação que auto-commita em sucesso e faz rollback em exceção — sempre use-a para escritas. Vincule parâmetros com :nome e um dict de params para prevenir injeção.

pandas
from sqlalchemy import text

# Use text() for explicit SQL (recommended over raw strings)
query = text("SELECT city, COUNT(*) as n FROM users GROUP BY city")
df = pd.read_sql(query, engine)

# Bind parameters safely
query = text("SELECT * FROM users WHERE age > :min_age AND city = :city")
df = pd.read_sql(query, engine,
                 params={"min_age": 18, "city": "NYC"})

# Execute DDL or DML (non-SELECT)
with engine.begin() as conn:  # transaction
    conn.execute(text("CREATE INDEX idx_city ON users(city)"))
    conn.execute(text("DELETE FROM users WHERE id = :id"),
                 {"id": 999})

Parquet vs CSV vs SQL

Parquet é o melhor padrão para armazenamento — colunar, comprimido e preservando dtypes (CSV perde dtypes e força re-inferência a cada carga). Feather é o mais rápido para caches de vida curta (formato Apache Arrow, sem custo de serialização). Pickle é conveniente, mas quebra entre versões de Python/pandas. Use SQL quando os dados são compartilhados e precisam de consulta no servidor.

pandas
# CSV: human-readable, slow, loses dtypes, large
df.to_csv("data.csv", index=False)
df = pd.read_csv("data.csv")  # re-infers dtypes (slow, error-prone)

# Parquet: binary, fast, preserves dtypes, compressed (best for storage)
df.to_parquet("data.parquet")
df = pd.read_parquet("data.parquet")  # dtypes preserved exactly

# Feather: fastest for short-lived storage (Apache Arrow)
df.to_feather("data.feather")  # requires a RangeIndex
df = pd.read_feather("data.feather")

# Pickle: Python-specific, fast, but version-fragile
df.to_pickle("data.pkl")
df = pd.read_pickle("data.pkl")

# SQL: shared, queryable, but slower for bulk reads
df.to_sql("table", engine)
df = pd.read_sql("SELECT * FROM table", engine)

# Rule of thumb:
# - CSV for human exchange
# - Parquet for storage/archival (best default)
# - Feather for fast cache between Python processes
# - SQL for shared, queryable data
15

Análise de Séries Temporais

Definindo um DatetimeIndex

O trabalho com séries temporais no pandas começa com um DatetimeIndex — defina a coluna de data como índice e ordene-a. Então você pode fatiar com strings (df.loc['2024-06'] para cada junho) e usar resample/rolling/shift. Indexação por string parcial é incrivelmente conveniente. Sempre ordene o índice depois de defini-lo; muitas operações de séries temporais exigem índices ordenados.

pandas
# Ensure the date column is datetime, then set as index
df["date"] = pd.to_datetime(df["date"])
df = df.set_index("date").sort_index()

# Now you can slice by date strings
df.loc["2024"]                 # all of 2024
df.loc["2024-06"]              # June 2024
df.loc["2024-06-01":"2024-06-15"]  # date range (inclusive)

# Partial string indexing on Series
s = df["value"]
s["2024-06-15"]

# Filter with date strings
df[df.index >= "2024-01-01"]

# A DatetimeIndex unlocks resample, rolling, shift, etc.

Resampling na Prática

resample é o groupby de séries temporais — 'MS' (início do mês), 'ME' (fim do mês), 'QE' (fim do trimestre), 'W' (semanal). Combine com groupby para reamostragem por categoria (ex.: vendas semanais por cidade). asfreq adiciona linhas para períodos de tempo ausentes (preenchendo com NaN), o que é útil para expor lacunas em dados irregulares. A agregação last() pega o valor final de cada período.

pandas
# Daily -> monthly revenue
daily.resample("MS").sum()

# Common frequencies:
# D=day, B=business day, W=weekly, MS=month start, ME=month end,
# QS=quarter start, YE=year end, H=hour, T/min=minute, S=second

# Multiple aggregations
daily.resample("ME").agg({"sales": "sum", "users": "mean"})

# Resample per group
df.groupby("city").resample("W")["sales"].sum()

# Handle missing periods (fill gaps in the timeline)
daily.asfreq("D")           # add NaN rows for missing days
daily.asfreq("D").ffill()   # fill them

# Quarter-end reporting
daily.resample("QE").last()  # last value of each quarter

Fusos Horários

tz_localize atribui um fuso a timestamps ingênuos (sem mudar os valores); tz_convert converte para outro fuso (mudando os valores exibidos). Os dois são fáceis de confundir. Sempre localize primeiro, depois converta. Transições de horário de verão criam horários ambíguos/ausentes — trate-os com ambiguous='infer' (para dados ordenados) ou 'NaT'.

pandas
# Localize naive timestamps (assign a timezone)
s = pd.Series(pd.date_range("2024-01-01", periods=3, freq="H"))
s_localized = s.dt.tz_localize("UTC")
s_localized = s.dt.tz_localize("America/New_York")

# Convert between timezones
s_utc = s.dt.tz_localize("UTC")
s_est = s_utc.dt.tz_convert("US/Eastern")
s_hk  = s_utc.dt.tz_convert("Asia/Hong_Kong")

# On a DatetimeIndex
idx = pd.date_range("2024-01-01", periods=3, freq="H", tz="UTC")
idx = idx.tz_convert("Asia/Shanghai")

# Remove timezone info
s_naive = s_utc.dt.tz_localize(None)

# Ambiguous times (DST fall-back): use 'infer' or 'NaT'
s.dt.tz_localize("US/Eastern", ambiguous="infer")

Funções de Janela

Janelas rolling baseadas em tempo ('7D') tratam dados amostrados irregularmente corretamente, diferente de janelas por contagem de linhas (rolling(7)). ewm (ponderado exponencialmente) pesa mais as observações recentes — comum em finanças para suavização. groupby + rolling computa janelas por grupo (ex.: média móvel de 7 dias por ação). reset_index limpa o MultiIndex que groupby+rolling produz.

pandas
# Rolling window with time offset
ts.rolling("7D").mean()      # 7-day window (handles irregular sampling)

# Rolling with custom function
ts.rolling("30D").apply(lambda x: np.quantile(x, 0.95))

# Expanding window (cumulative)
ts.expanding(min_periods=10).mean()

# Exponentially weighted
ts.ewm(span=20).mean()       # like a 20-period EWMA
ts.ewm(halflife=10).mean()

# Window per group
df.groupby("city")["sales"].rolling("7D").mean().reset_index(level=0, drop=True)

# Compare rolling vs ewm for smoothing
# ewm weights recent points more — better for fast-changing series

Sazonalidade e Decomposição

seasonal_decompose divide uma série temporal em componentes de tendência, sazonal e residual — útil para entender a estrutura e remover a sazonalidade. period é o comprimento do ciclo (12 para dados mensais com sazonalidade anual). Groupby em index.month ou index.dayofweek revela padrões sazonais. O autocorrelation_plot mostra quão correlacionada uma série é com seus próprios lags.

pandas
# Seasonal decomposition (needs statsmodels)
from statsmodels.tsa.seasonal import seasonal_decompose

# Additive model: y = trend + seasonal + residual
result = seasonal_decompose(ts, model="additive", period=12)
result.plot()
result.trend, result.seasonal, result.resid

# Multiplicative model: y = trend * seasonal * residual
result = seasonal_decompose(ts, model="multiplicative", period=12)

# Seasonal plots
ts.groupby(ts.index.month).mean()   # average by month
ts.groupby(ts.index.dayofweek).mean()  # by weekday

# Lag plot (autocorrelation check)
pd.plotting.lag_plot(ts, lag=1)
pd.plotting.autocorrelation_plot(ts)
16

Visualização

Gráficos Básicos

A plotagem do pandas é construída sobre matplotlib — o acessador .plot dá gráficos rápidos para EDA. plot() assume linha (bom para séries temporais), plot.bar() para contagens categóricas, plot.hist() para distribuições, plot.scatter() para relações. Para gráficos de qualidade de publicação, troque para seaborn ou plotly, mas para inspeção rápida durante a análise, os gráficos do pandas são imbatíveis.

pandas
import matplotlib.pyplot as plt

# Line plot (default for time series)
df["score"].plot()
df.plot(x="date", y="score")

# Bar chart
df["city"].value_counts().plot.bar()
df["city"].value_counts().plot.barh()  # horizontal

# Histogram
df["age"].plot.hist(bins=20)
df[["age", "score"]].plot.hist(alpha=0.5, bins=20)

# Scatter
df.plot.scatter(x="age", y="score", c="pass", colormap="viridis")

# Box plot (per group)
df.boxplot(column="score", by="city")

# Area, density, pie
df["city"].value_counts().plot.pie(autopct="%1.1f%%")
df["score"].plot.kde()  # kernel density estimate

plt.tight_layout(); plt.show()

Plotando com Seaborn

Seaborn brilha em visualizações estatísticas: violin plots, pair plots (matriz de dispersão), heatmaps, linhas de regressão com intervalos de confiança. Ele trata o 'agrupar por cor' (hue) com elegância, o que é verboso no matplotlib. pairplot é a forma mais rápida de escanear todas as relações par a par num dataset. Sempre passe o DataFrame e use nomes de colunas — a API do seaborn é projetada para dados tidy.

pandas
import seaborn as sns
import matplotlib.pyplot as plt

# Statistical plots that pandas can't easily do
sns.histplot(df["score", kde=True])
sns.boxplot(data=df, x="city", y="score")
sns.violinplot(data=df, x="city", y="score")

# Relationships
sns.scatterplot(data=df, x="age", y="score", hue="city")
sns.pairplot(df[["age", "score", "pass"]], hue="pass")

# Correlation heatmap
sns.heatmap(df.corr(numeric_only=True), annot=True, cmap="coolwarm")

# Regression plot
sns.regplot(data=df, x="age", y="score")

# Facet grid (small multiples)
g = sns.FacetGrid(df, col="city", hue="pass")
g.map(sns.histplot, "score")

plt.tight_layout(); plt.show()

Gráficos Interativos com Plotly

Plotly Express produz gráficos interativos (tooltips no hover, zoom, pan) — ótimo para dashboards e compartilhar insights com partes interessadas não técnicas. A API espelha o seaborn (passe um DataFrame, mapeie colunas para estéticas). write_html salva um arquivo HTML interativo autocontido. Para puro desempenho com milhões de pontos, considere datashader; para polimento, o Plotly é excelente.

pandas
import plotly.express as px

# Interactive scatter (hover, zoom, pan)
fig = px.scatter(df, x="age", y="score", color="city",
                 hover_data=["name"], title="Score vs Age")
fig.show()

# Line chart
fig = px.line(df, x="date", y="score", color="city")

# Bar
fig = px.bar(df, x="city", y="score", color="pass", barmode="group")

# Histogram
fig = px.histogram(df, x="score", color="city", marginal="box")

# Faceted
fig = px.scatter(df, x="age", y="score", facet_col="city")

# 3D
fig = px.scatter_3d(df, x="age", y="score", z="hours", color="city")

# Save as HTML (interactive, no JS needed to view)
fig.write_html("plot.html")

Subplots e Layouts

plt.subplots cria uma grade de eixos; passe cada um a ax= ao plotar. sharex/sharey alinham eixos entre subplots (útil para comparar escalas). secondary_y plota uma segunda série num eixo y diferente (ex.: preço e volume). tight_layout previne sobreposição de rótulos. Para layouts complexos, gridspec oferece controle mais fino do dimensionamento dos subplots.

pandas
import matplotlib.pyplot as plt

# pandas plot on specific axes
fig, axes = plt.subplots(2, 2, figsize=(12, 8))
df["age"].plot.hist(ax=axes[0, 0], title="Age")
df["score"].plot.hist(ax=axes[0, 1], title="Score")
df["city"].value_counts().plot.bar(ax=axes[1, 0], title="City")
df.plot.scatter(x="age", y="score", ax=axes[1, 1], title="Age vs Score")
plt.tight_layout(); plt.show()

# Shared x-axis
fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(10, 6))
df["score"].plot(ax=ax1)
df["age"].plot(ax=ax2)

# Secondary y-axis
ax = df["score"].plot()
df["age"].plot(ax=ax, secondary_y=True)
ax.set_ylabel("Score"); ax.right_ax.set_ylabel("Age")

Estilizando DataFrames

Objetos Styler personalizam como DataFrames renderizam no Jupyter e HTML — gradientes, barras nas células e formatação condicional tornam as tabelas legíveis de relance. format controla a exibição numérica (decimais, porcentagens). A estilização é computada na exibição (não muda os dados) e pode ser exportada para HTML em relatórios. applymap aplica uma função por célula; apply funciona por linha/coluna.

pandas
# Style a DataFrame for HTML/Jupyter display
styled = df.style.highlight_max(color="lightgreen")
styled = df.style.highlight_min(color="lightcoral")
styled = df.style.background_gradient(cmap="Blues", subset=["score"])

# Bar charts inside cells
df.style.bar(subset=["score"], color="#5fba7d")

# Format numbers
df.style.format({"score": "{:.2f}", "age": "{:.0f}"})
df.style.format({"score": "{:.2%}"})  # as percentage

# Conditional formatting
def color_neg_red(val):
    color = "red" if val < 0 else "black"
    return f"color: {color}"
df.style.applymap(color_neg_red, subset=["change"])

# Combine styles
(df.style
   .format({"score": "{:.2f}"})
   .background_gradient(cmap="RdYlGn", subset=["score"])
   .set_caption("Student Scores"))

# Export to HTML
styled.to_html("table.html")
17

Exportação e Formatação

Formatação de Exibição

As opções de exibição controlam como o pandas imprime no console/Jupyter — aumente max_rows/max_columns para ver mais, defina float_format para decimais consistentes. option_context é um gerenciador de contexto que muda temporariamente as configurações (restaura depois), perfeito para inspeção pontual sem alterar globalmente seu ambiente. Ponha as configurações de uso frequente num script de inicialização.

pandas
# Global display options
pd.set_option("display.max_rows", 100)
pd.set_option("display.max_columns", 50)
pd.set_option("display.width", 1000)
pd.set_option("display.max_colwidth", 100)
pd.set_option("display.float_format", "{:.2f}".format)

# Reset to defaults
pd.reset_option("display.max_rows")

# Float formatting only for one operation
with pd.option_context("display.float_format", "{:.2f}".format):
    print(df)

# Temporarily show more rows
with pd.option_context("display.max_rows", None):
    print(df.head(100))

Exportando para Múltiplos Formatos

to_markdown produz tabelas prontas para GitHub, para READMEs e docs. to_html embute em páginas web; to_latex para artigos acadêmicos. to_dict(orient='records') converte numa lista de dicts (tipo JSON) para APIs. Cada formato tem opções — explore a documentação. Para Excel, o engine='openpyxl' suporta formatar fórmulas, formatos condicionais e gráficos.

pandas
# CSV
df.to_csv("out.csv", index=False)
df.to_csv("out.tsv", sep="\t", index=False)

# Excel with formatting (needs openpyxl)
with pd.ExcelWriter("out.xlsx", engine="openpyxl") as w:
    df.to_excel(w, sheet_name="data", index=False)
    summary.to_excel(w, sheet_name="summary")

# Markdown (great for docs/reports)
print(df.to_markdown(index=False))
df.to_markdown("table.md", index=False)

# HTML
df.to_html("table.html", index=False, classes="table")

# LaTeX
print(df.to_latex(index=False, caption="Results"))

# JSON
df.to_json("out.json", orient="records", indent=2, date_format="iso")

# Dict / records
df.to_dict(orient="records")  # list of dicts
df.to_dict(orient="list")     # dict of lists

Clipboard e String

to_clipboard(excel=True) copia uma tabela separada por tabulação que cola direto no Excel/Google Sheets — incrivelmente prático para mover dados entre Python e planilhas. read_clipboard é o inverso: copie uma tabela de uma página web ou planilha e leia-a num DataFrame sem salvar arquivo. to_string dá uma representação em texto puro para logs.

pandas
# Copy a DataFrame to the clipboard (paste into Excel/Sheets)
df.to_clipboard(index=False, excel=True)

# Read from clipboard (paste a table from a spreadsheet/webpage)
df = pd.read_clipboard()

# Convert to string with formatting
print(df.to_string(index=False))
print(df.to_string(max_rows=10))

# Pretty-print in Jupyter
from IPython.display import display
display(df.head(10))

# Render a Series as a string
print(s.to_string())

# Quick peek at value (useful in debugging)
df.head().to_dict("records")

Formatação de Excel

openpyxl permite estilizar a saída Excel programaticamente — cabeçalhos em negrito, larguras de coluna, painéis congelados, formatação condicional, fórmulas. Acesse a pasta de trabalho via writer.book e as planilhas via writer.sheets depois de escrever. Auto-dimensionar colunas exige cálculo manual de largura (o Excel não faz isso automaticamente ao gravar o arquivo). Painéis congelados mantêm cabeçalhos visíveis ao rolar.

pandas
from openpyxl.styles import Font, PatternFill
from openpyxl.utils import get_column_letter

# Write with conditional formatting
with pd.ExcelWriter("report.xlsx", engine="openpyxl") as writer:
    df.to_excel(writer, sheet_name="Data", index=False)

    # Access the workbook to style
    wb = writer.book
    ws = writer.sheets["Data"]

    # Bold header
    for cell in ws[1]:
        cell.font = Font(bold=True, color="FFFFFF")
        cell.fill = PatternFill("solid", fgColor="4472C4")

    # Auto-size columns
    for col in ws.columns:
        max_len = max(len(str(c.value)) for c in col if c.value is not None)
        ws.column_dimensions[get_column_letter(col[0].column)].width = max_len + 2

    # Freeze header row
    ws.freeze_panes = "A2"

Notebooks Reproduzíveis

Padronizar cabeçalhos de notebook (imports, opções, seed, verificação de versão) torna as análises reproduzíveis e economiza tempo de depuração. pd.show_versions() reporta versões de pandas/numpy/python — cole em relatórios de bug. Um helper check_df que imprime shape, dtypes, head e ausências padroniza a primeira olhada em qualquer dataset novo. Suprima só categorias específicas de aviso, nunca todas.

pandas
# At the top of every analysis notebook
import pandas as pd
import numpy as np
pd.set_option("display.max_columns", None)
pd.set_option("display.float_format", "{:.4f}".format)

# Set a seed for reproducibility
np.random.seed(42)

# Show versions for reproducibility
pd.show_versions()

# Common imports grouped
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_theme(style="whitegrid")

# Suppress chained-assignment warnings cleanly
import warnings
warnings.filterwarnings("ignore", category=FutureWarning)

# Validate data on load
def check_df(df, name="df"):
    print(f"=== {name} ===")
    print(f"Shape: {df.shape}")
    print(df.dtypes)
    print(df.head())
    print(df.isnull().sum())
check_df(df)
18

Pegadinhas Comuns

SettingWithCopyWarning

SettingWithCopyWarning é o pandas avisando que sua atribuição pode não persistir — indexação encadeada (df[mask]['col']=x) pode modificar uma cópia temporária. A correção é sempre .loc[máscara_linhas, nome_col] = valor para atribuição condicional. Ao subconjuntar e depois modificar, use .copy() para ser explícito. No desenvolvimento, defina o aviso como 'raise' para capturar esses bugs como erros.

pandas
# BAD: chained indexing — may not modify df
df[df["age"] > 30]["city"] = "NYC"   # SettingWithCopyWarning

# GOOD: single .loc assignment
df.loc[df["age"] > 30, "city"] = "NYC"

# When subsetting, be explicit about copy vs view
subset = df[df["age"] > 30].copy()   # explicit copy
subset["city"] = "NYC"               # safe — modifies subset only

# Detect the warning
pd.set_option("mode.chained_assignment", "warn")   # default
pd.set_option("mode.chained_assignment", "raise")  # error (dev mode)
pd.set_option("mode.chained_assignment", None)     # suppress

# Rule: if you're going to modify, use .loc or .copy() first

Surpresas do Alinhamento de Índice

O alinhamento de índice é o superpoder do pandas e sua maior pegadinha. Quando você atribui uma Series a uma coluna, o pandas casa pelo índice, não pela posição — então, se sua Series tem um índice diferente, você ganha NaN ou valores errados. Use .values para atribuir por posição, ou reset_index para alinhar índices primeiro. Esse bug é silencioso (sem aviso) e é um dos erros de pandas mais comuns.

pandas
# Adding Series aligns on index — NaN where they don't match
s1 = pd.Series([1, 2, 3], index=["a", "b", "c"])
s2 = pd.Series([10, 20, 30], index=["b", "c", "d"])
s1 + s2
# a     NaN
# b    12.0
# c    33.0
# d     NaN

# When assigning a Series to a column, alignment happens by index
df["new"] = some_series   # rows matched by INDEX, not position!

# To force positional alignment, use .values
df["new"] = some_series.values   # assign by position

# After sorting/resetting, indexes may not match
df1 = df.sort_values("age")
df1["rank"] = range(len(df1))   # WRONG if index isn't 0..n-1
df1["rank"] = np.arange(len(df1))  # also WRONG — aligns on index
df1["rank"] = pd.Series(range(len(df1)), index=df1.index)  # correct
# Or simply:
df1 = df1.reset_index(drop=True)
df1["rank"] = range(len(df1))

inplace vs Reatribuição

A comunidade pandas está abandonando inplace=True em favor da reatribuição funcional — ela habilita encadeamento de chamadas (pipelines legíveis) e é mais previsível. inplace raramente economiza memória (o pandas costuma copiar de qualquer forma). O estilo encadeado (df.method().method().method()) lê de cima para baixo e é o idioma moderno. Use inplace só quando medir um benefício real de memória.

pandas
# Two equivalent styles:
df = df.sort_values("age")        # reassign (returns new df)
df.sort_values("age", inplace=True)  # modify in place

# Most pandas methods return a new object (functional style).
# inplace=True modifies the object — but:
# 1. It's being deprecated in some methods
# 2. It can prevent method chaining
# 3. It sometimes still makes a copy under the hood

# Prefer functional style for chaining:
(df
   .sort_values("age")
   .reset_index(drop=True)
   .rename(columns={"old": "new"}))

# inplace is fine for memory savings on huge DataFrames,
# but rarely matters otherwise.

Argumentos Padrão Mutáveis

Crescer um DataFrame linha a linha (df.append ou pd.concat num loop) é O(n²) — cada append copia o frame inteiro. Sempre colete as linhas numa lista e construa o DataFrame uma vez. O mesmo vale para argumentos padrão mutáveis do Python (listas, dicts) — são compartilhados entre chamadas, um bug clássico do Python. Use None como sentinela e inicialize dentro da função.

pandas
# BAD: default mutable args are shared across calls
def add_row(df, new_data=[]):   # NEVER use mutable defaults
    new_data.append(1)
    return df

# GOOD: use None
def add_row(df, new_data=None):
    if new_data is None:
        new_data = []
    ...

# Building a DataFrame row by row (SLOW — anti-pattern)
df = pd.DataFrame()
for item in items:
    df = pd.append(df, item)  # deprecation + O(n^2)

# GOOD: build a list of records, then construct once
records = []
for item in items:
    records.append({"name": item.name, "value": item.value})
df = pd.DataFrame(records)

# Or use from_records
df = pd.DataFrame.from_records(items, columns=["name", "value"])

Propagação de NaN

NaN nunca é igual a si mesmo (NaN == NaN é False) — use isna() para detectar valores ausentes, nunca ==. Por padrão, agregações pulam NaN (sum, mean), mas passe skipna=False para propagá-lo. Colunas de inteiros com qualquer NaN são promovidas para float64 (inteiros numpy não podem guardar NaN); use o dtype anulável 'Int64' (I maiúsculo) para manter inteiros com NaN.

pandas
# NaN propagates through most operations
np.nan + 1          # nan
np.nan > 0          # False
pd.Series([1, 2, np.nan]).sum()    # 3.0 (skips NaN by default)
pd.Series([1, 2, np.nan]).mean()   # 1.5

# Some operations DON'T skip NaN
pd.Series([1, 2, np.nan]).sum(skipna=False)  # nan

# Comparisons with NaN are always False
pd.Series([1, np.nan]) == pd.Series([1, np.nan])
# [True, False]  — NaN != NaN!

# Check for NaN correctly
s.isna()            # True for NaN
s.isnull()          # alias
s == np.nan         # WRONG — always False!
s.fillna(0) == 0    # check after filling

# Integer columns with NaN become float
s = pd.Series([1, 2, None])   # becomes float64: [1.0, 2.0, NaN]
# Use nullable Int64 to keep integer with NaN
s = pd.Series([1, 2, None], dtype="Int64")
19

Padrões do Mundo Real

Template de EDA

Uma função de EDA padronizada garante que você sempre verifique shape, dtypes, ausências, distribuições e duplicatas antes de modelar. Capturar cedo um dtype errado (números como strings), ausências ocultas (valores sentinela como -999) ou duplicatas inesperadas economiza horas de depuração posterior. Rode isto em cada dataset novo como primeiro passo.

pandas
import pandas as pd
import numpy as np

def eda(df, name="df"):
    print(f"=== {name} ===")
    print(f"Shape: {df.shape}")
    print("\n--- dtypes ---")
    print(df.dtypes)
    print("\n--- head ---")
    print(df.head())
    print("\n--- missing ---")
    print(df.isnull().sum())
    print("\n--- numeric summary ---")
    print(df.describe())
    print("\n--- categorical summary ---")
    print(df.describe(include="object"))
    print("\n--- duplicates ---")
    print(f"{df.duplicated().sum()} duplicate rows")

# Usage
eda(df)

# Per-column deep dive
for col in df.columns:
    print(f"\n### {col}")
    print(f"dtype: {df[col].dtype}")
    print(f"unique: {df[col].nunique()}")
    if df[col].dtype == "object":
        print(df[col].value_counts().head(10))
    else:
        print(df[col].describe())

Construindo um Pipeline de Limpeza

Encadeamento de chamadas (o pipeline .pipe / .assign / .dropna) torna a limpeza reproduzível e testável — cada passo é uma função pura, fácil de inspecionar em qualquer ponto. Renomeie colunas para snake_case cedo para evitar dores de aspas. asserções no fim capturam falhas silenciosas (ex.: todas as datas falhando na análise). Envolva o pipeline numa função para reusá-lo em novos lotes de dados.

pandas
def clean(df):
    """A reusable cleaning pipeline."""
    return (df
        # Standardize column names
        .rename(columns=lambda c: c.strip().lower().replace(" ", "_"))
        # Drop empty columns
        .dropna(axis=1, how="all")
        # Parse dates
        .assign(date=lambda d: pd.to_datetime(d["date"], errors="coerce"))
        # Numeric coercion
        .assign(amount=lambda d: pd.to_numeric(d["amount"], errors="coerce"))
        # Fill missing
        .fillna({"category": "unknown"})
        # Dedupe
        .drop_duplicates()
        # Reset index
        .reset_index(drop=True)
    )

df_clean = clean(df_raw)

# Verify
assert df_clean["date"].notnull().all(), "Some dates failed to parse"
assert len(df_clean) <= len(df_raw), "Cleaning should not add rows"

Análise com Tabela Dinâmica

pivot_table é o canivete suíço do analista — combine com margins=True para totais e um heatmap para insights instantâneos. O inverso (melt) devolve ao formato long tidy para processamento adicional. O padrão 'top N por grupo' (ordenar e depois groupby head) é extremamente comum em relatórios de negócio.

pandas
# Multi-dimensional analysis in one shot
pivot = pd.pivot_table(
    df,
    values="revenue",
    index=["region", "product"],
    columns=["quarter"],
    aggfunc="sum",
    fill_value=0,
    margins=True,         # add row/column totals
    margins_name="Total",
)

# Heatmap of the pivot
import seaborn as sns
sns.heatmap(pivot, annot=True, fmt=".0f", cmap="YlGnBu")

# Convert back to long
long = pivot.reset_index().melt(
    id_vars=["region", "product"],
    var_name="quarter",
    value_name="revenue",
)

# Top product per region
top = (df
    .groupby(["region", "product"])["revenue"].sum()
    .reset_index()
    .sort_values("revenue", ascending=False)
    .groupby("region").head(1))

Engenharia de Features para ML

Engenharia de features é onde o conhecimento de domínio encontra o pandas: agregações por entidade (gasto vitalício do cliente), razões (gasto por mês), features baseadas em tempo (tempo de casa) e categóricos binados. Mescle features agregadas de volta ao frame principal pelo ID da entidade. get_dummies faz one-hot encoding para modelos lineares. Envolva numa função para que as mesmas transformações valham no treino e na inferência.

pandas
def add_features(df):
    """Add features for a churn model."""
    out = df.copy()

    # Time-based features
    out["tenure_years"] = out["tenure_months"] / 12
    out["is_new_customer"] = (out["tenure_months"] < 12).astype(int)

    # Aggregations per customer (need transaction history)
    # txns is a separate transactions DataFrame
    agg = txns.groupby("customer_id").agg(
        total_spend=("amount", "sum"),
        txn_count=("amount", "count"),
        avg_txn=("amount", "mean"),
        last_txn_date=("date", "max"),
    ).reset_index()
    out = out.merge(agg, on="customer_id", how="left")

    # Ratio features
    out["spend_per_month"] = out["total_spend"] / out["tenure_months"]

    # Binning
    out["age_group"] = pd.cut(out["age"], bins=[0,25,40,60,100],
                              labels=["young","adult","mid","senior"])

    # Encode categoricals
    out = pd.get_dummies(out, columns=["age_group", "plan"], drop_first=True)

    return out

df_ml = add_features(df)

Lendo CSVs Bagunçados

CSVs reais são bagunçados: codificações erradas (tente latin-1 ou cp1252 quando utf-8 falha), vírgulas decimais europeias (decimal=','), linhas de metadados antes do cabeçalho (skiprows) e valores nulos sentinela (na_values). usecols carrega só as colunas necessárias, economizando memória em arquivos largos. Sempre inspecione as primeiras linhas de um CSV desconhecido num editor de texto antes de ler às cegas.

pandas
# Common CSV issues and fixes

# Bad encoding
df = pd.read_csv("data.csv", encoding="latin-1")  # or utf-8-sig, cp1252

# Wrong separator
df = pd.read_csv("data.tsv", sep="\t")
df = pd.read_csv("data.csv", sep=";", decimal=",")  # European format

# Skip metadata rows at the top
df = pd.read_csv("data.csv", skiprows=3)

# Multiple header rows
df = pd.read_csv("data.csv", header=[0, 1])

# Custom NA values
df = pd.read_csv("data.csv", na_values=["?", "N/A", "NULL", -999])

# Parse dates with multiple formats
df = pd.read_csv("data.csv", parse_dates=["date"], dayfirst=True)

# Only load specific columns (saves memory)
df = pd.read_csv("data.csv", usecols=["id", "date", "amount"])

# Handle quoted fields with commas/newlines
df = pd.read_csv("data.csv", quotechar='"', escapechar="\\")
20

Imersão em Operações de Janela

Rolling com Funções Personalizadas

Agregações rolling embutidas (mean, std, median, quantile) são otimizadas em C e rápidas. Funções apply personalizadas são flexíveis, mas mais lentas (callback Python por janela). Para médias ponderadas ou regressões, use apply com operações numpy dentro. raw=True (padrão) passa arrays numpy (mais rápido); raw=False passa Series se você precisar do índice.

pandas
s = pd.Series(range(20), dtype=float)

# Built-in aggregations (fast, C-optimized)
s.rolling(5).mean()
s.rolling(5).std()
s.rolling(5).median()
s.rolling(5).quantile(0.75)
s.rolling(5).sum()

# Custom function (slower, but flexible)
s.rolling(5).apply(lambda x: x.max() - x.min())

# Weighted rolling average
weights = np.array([0.1, 0.2, 0.3, 0.25, 0.15])
s.rolling(5).apply(lambda x: np.dot(x, weights))

# Rolling regression (slope over window)
def slope(x):
    return np.polyfit(range(len(x)), x, 1)[0]
s.rolling(10).apply(slope)

# raw=False passes Series (with index) to the function
s.rolling(5).apply(lambda x: x.iloc[-1] / x.iloc[0], raw=False)

Janelas Baseadas em Tempo

Janelas baseadas em tempo ('7D') tratam dados amostrados irregularmente corretamente — incluem cada um dos pontos dentro do intervalo de tempo, não um número fixo de linhas. Essencial para séries temporais reais com lacunas. center=True centra a janela no ponto atual (útil para suavização). closed='left' exclui o ponto atual (evita vazamento ao calcular features a partir do 'futuro').

pandas
# Row-count vs time-based windows
ts = pd.Series(range(100), index=pd.date_range("2024-01-01", periods=100, freq="D"))

# Row-count: exactly 7 rows (may span more than 7 days if data is irregular)
ts.rolling(7).mean()

# Time-based: all rows within the last 7 days (handles gaps)
ts.rolling("7D").mean()

# Time-based is essential for irregular time series
irregular = pd.Series([1, 2, 3],
    index=pd.to_datetime(["2024-01-01", "2024-01-05", "2024-01-15"]))
irregular.rolling("7D").sum()   # 1, 3, 3 (third is just itself, no neighbors in 7d)

# Center the window
ts.rolling("7D", center=True).mean()  # window centered on current point

# Closed controls which endpoints are included
ts.rolling("7D", closed="left").mean()  # exclude current point

Expanding e EWMA

expanding computa estatísticas sobre cada um dos dados do início ao ponto atual — útil para benchmarks cumulativos e extremos móveis. ewm (ponderado exponencialmente) pesa mais as observações recentes — o padrão para suavização financeira (EWMA). span é intuitivo (parecido com uma média móvel de N períodos); alpha é o fator de suavização bruto. EWMA reage mais rápido que uma média móvel simples a mudanças recentes.

pandas
s = pd.Series([1, 2, 3, 4, 5, 6, 7, 8], dtype=float)

# Expanding: window grows from the start
s.expanding(min_periods=2).mean()   # cumulative mean
s.expanding().max()                 # running maximum
s.expanding().std()

# Exponentially weighted moving average
s.ewm(span=5).mean()       # span=N similar to N-period moving avg
s.ewm(alpha=0.3).mean()    # alpha = smoothing factor (0-1)
s.ewm(halflife=3).mean()   # halflife: weight halves every N periods

# EWMA volatility (finance)
returns.ewm(span=20).std()  # 20-period EWMA volatility

# Relationship: span = (2/alpha) - 1
# Higher alpha/span = more responsive to recent data

Operações Cumulativas

cumsum, cummax, cummin, cumprod são funções cumulativas diretas — mais rápidos que expanding para os casos comuns. Combinados com groupby, computam totais móveis por grupo (ex.: saldo acumulado por cliente). O truque de cumsum sobre uma condição booleana cria identificadores de sessão/segmento — útil para dividir séries temporais em episódios entre eventos.

pandas
s = pd.Series([1, 2, 3, 4, 5])

# Direct cumulative methods (faster than expanding)
s.cumsum()    # [1, 3, 6, 10, 15]
s.cummax()    # [1, 2, 3, 4, 5]
s.cummin()    # [1, 1, 1, 1, 1]
s.cumprod()   # [1, 2, 6, 24, 120]

# Cumulative within groups
df["running_total"] = df.groupby("customer")["amount"].cumsum()
df["rank_in_group"] = df.groupby("customer")["amount"].rank(ascending=False)
df["pct_of_total"] = df["amount"] / df.groupby("customer")["amount"].transform("sum")

# Cumulative count of condition
df["days_since_event"] = (df["event"] == 1).cumsum()
df["event_number"] = df.groupby(
    (df["event"] == 1).cumsum()
).cumcount()

Rolling Apply com Múltiplas Saídas

Para múltiplas estatísticas móveis, computar cada uma separadamente (window.mean(), window.std()) é mais claro e geralmente mais rápido que um único apply retornando uma Series. Quantis móveis permitem construir bandas de confiança (q10/q90) em torno de uma tendência. Criar um DataFrame de estatísticas móveis é o padrão típico antes de plotar ou alimentar um modelo de ML.

pandas
# Apply a function returning multiple values per window
def rolling_stats(x):
    return pd.Series({
        "mean": x.mean(),
        "std": x.std(),
        "min": x.min(),
        "max": x.max(),
    })

stats = s.rolling(10).apply(rolling_stats, raw=False)
# This creates a DataFrame with one row per window, columns = the Series index

# Alternative: compute each separately (often clearer)
window = s.rolling(10)
result = pd.DataFrame({
    "mean": window.mean(),
    "std":  window.std(),
    "min":  window.min(),
    "max":  window.max(),
})

# Rolling quantiles
q = pd.DataFrame({
    "q10": s.rolling(20).quantile(0.1),
    "q50": s.rolling(20).quantile(0.5),
    "q90": s.rolling(20).quantile(0.9),
})

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.