Encadeamento de métodos com pipe()
Escreva pipelines legíveis de transformação de dados usando pipe() para encadear funções personalizadas e métodos nativos do pandas.
Encadeamento de métodos com pipe() é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Pandas & NumPy Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Pandas & NumPy Academy inclui 4 aulas no total.
O problema das variáveis intermediárias
Um pipeline de limpeza de dados sem pipe() geralmente acumula muitas variáveis intermediárias: df1 = clean(df), df2 = transform(df1), df3 = enrich(df2). Essas variáveis poluem o espaço de nomes, dificultam a depuração e incentivam os desenvolvedores a reutilizá-las incorretamente. O resultado é um código difícil de ler de cima para baixo como uma sequência de transformações.
import pandas as pd
df = pd.read_csv('orders.csv')
# Without pipe — intermediate variables everywhere
df1 = df.dropna(subset=['revenue'])
df2 = df1[df1['quantity'] > 0]
df3 = df2.assign(revenue_per_unit=df2['revenue'] / df2['quantity'])
print(df3.shape)Apresentando pipe()
DataFrame.pipe(func) chama func(df) e retorna o resultado, permitindo encadear funções personalizadas da mesma forma que você encadeia métodos nativos do Pandas, como .dropna().query(). O principal benefício é que cada etapa da transformação fica explícita e legível da esquerda para a direita — ou de cima para baixo quando formatada com parênteses —, refletindo a ordem lógica do pipeline.
def drop_nulls(df):
return df.dropna(subset=['revenue'])
def filter_positive_qty(df):
return df[df['quantity'] > 0]
def add_revenue_per_unit(df):
return df.assign(revenue_per_unit=df['revenue'] / df['quantity'])
# With pipe — clean chain
df_clean = (df
.pipe(drop_nulls)
.pipe(filter_positive_qty)
.pipe(add_revenue_per_unit)
)
print(df_clean.shape)Passando argumentos por pipe()
Passe argumentos adicionais para a função encadeada usando argumentos nomeados depois do nome da função: df.pipe(func, arg1=val1). A assinatura da função deve aceitar df como primeiro parâmetro. Funções parametrizadas tornam o pipeline configurável: você pode alterar limites, nomes de colunas ou comportamento sem modificar o corpo da função, apenas alterando os argumentos da chamada de pipe.
def filter_by_region(df, regions):
return df[df['region'].isin(regions)]
def cap_revenue(df, upper):
df = df.copy()
df['revenue'] = df['revenue'].clip(upper=upper)
return df
df_result = (df
.pipe(filter_by_region, regions=['North', 'East'])
.pipe(cap_revenue, upper=1000)
)
print(df_result.shape)Combinando pipe() com métodos nativos
O poder de pipe() está em integrar-se perfeitamente aos métodos nativos do Pandas na mesma cadeia. Pode combinar .dropna(), .query(), .rename() e .pipe(custom_func) em qualquer ordem. Isso torna a cadeia concisa (usando métodos integrados sempre que possível) e flexível (usando funções personalizadas quando os métodos integrados não são suficientes).
df_result = (
df
.dropna(subset=['revenue', 'order_date'])
.query('quantity > 0')
.rename(columns={'unit_price': 'price'})
.pipe(add_revenue_per_unit)
.reset_index(drop=True)
)
print(df_result.head())Depurando uma cadeia com pipe()
Depurar uma cadeia longa pode ser difícil, pois não é possível inspecionar os estados intermediários adicionando uma instrução de impressão no meio. Uma solução é escrever uma função de depuração de passagem que imprime as informações sobre dimensões e colunas e depois retorna o DataFrame sem alterações. Insira-a em qualquer ponto da cadeia para inspecionar o estado naquela etapa sem interromper a cadeia.
def debug(df, label=''):
print(f'[{label}] shape: {df.shape}')
print(f'[{label}] columns: {df.columns.tolist()}')
return df
df_result = (
df
.pipe(drop_nulls)
.pipe(debug, label='after drop_nulls')
.pipe(filter_positive_qty)
.pipe(debug, label='after filter')
)
print('Done')Criando um fluxo completo de limpeza
Combine todas as etapas de limpeza em uma única função de fluxo usando pipe(). Encapsular a cadeia em uma função chamada clean_pipeline(df) torna o fluxo testável como uma unidade. Chame-a com um DataFrame bruto e receba um DataFrame limpo. Esse padrão está alinhado ao paradigma ETL (Extrair, Transformar, Carregar) usado na engenharia de dados em produção.
def clean_pipeline(df):
return (
df
.dropna(subset=['order_id', 'revenue'])
.drop_duplicates(subset=['order_id'])
.query('quantity > 0 and revenue >= 0')
.pipe(add_revenue_per_unit)
.reset_index(drop=True)
)
df_clean = clean_pipeline(df)
print('Clean rows:', len(df_clean))pipe() versus apply(): principais diferenças
pipe(func) passa o DataFrame inteiro para func e espera receber de volta um DataFrame (ou objeto transformado). apply(func, axis=1) passa uma linha por vez. Use pipe() para transformações no DataFrame inteiro que mantêm o mesmo formato (ou o alteram deliberadamente) e use apply() para cálculos no nível de linha ou coluna. Elas são complementares, não concorrentes.
# pipe: receives the whole DataFrame
def scale_revenue(df, factor=1.0):
df = df.copy()
df['revenue'] = df['revenue'] * factor
return df
# apply: receives one row at a time
df['revenue_x2'] = df.apply(lambda row: row['revenue'] * 2, axis=1)
df_scaled = df.pipe(scale_revenue, factor=1.1)
print('pipe scales all rows at once; apply does row-by-row')Componentes reutilizáveis do fluxo
Escreva cada etapa do fluxo como uma função pura — sem estado global, recebendo um DataFrame e retornando um DataFrame. Funções puras são fáceis de testar unitariamente: chame-as com um pequeno DataFrame de teste e verifique o formato da saída e os valores das colunas. Uma biblioteca de funções de fluxo testadas e reutilizáveis acelera significativamente a análise de novos conjuntos de dados que compartilham requisitos de limpeza semelhantes.
def normalise_strings(df, cols):
df = df.copy()
for col in cols:
df[col] = df[col].str.strip().str.lower()
return df
def parse_dates(df, cols):
df = df.copy()
for col in cols:
df[col] = pd.to_datetime(df[col])
return df
df_result = (
df
.pipe(normalise_strings, cols=['region', 'category'])
.pipe(parse_dates, cols=['order_date'])
)
print(df_result.dtypes)Registrando as etapas do fluxo com pipe()
Adicione registros estruturados dentro de cada função do fluxo para poder auditar todas as transformações em produção. Inclua a contagem de linhas de entrada, a contagem de linhas de saída e quaisquer estatísticas relevantes (por exemplo, as linhas removidas por um filtro). Isso fornece um rastreamento completo de cada execução do fluxo sem exigir um orquestrador externo de fluxos de trabalho para trilhas de auditoria básicas.
import logging
logging.basicConfig(level=logging.INFO)
def logged_dropna(df, subset):
before = len(df)
df = df.dropna(subset=subset)
after = len(df)
logging.info(f'dropna: {before - after} rows removed, {after} remaining')
return df
df_clean = df.pipe(logged_dropna, subset=['revenue'])
print('Logged pipeline complete.')Etapas condicionais em um fluxo
Às vezes, uma etapa de limpeza deve ser executada apenas com base em um sinalizador ou no conteúdo dos dados. Pode adicionar etapas condicionais a uma cadeia de pipe inserindo uma função de identidade ou transformação: ela verifica uma condição e aplica uma transformação ou retorna o DataFrame sem alterações. Assim, a estrutura da cadeia é mantida e, ao mesmo tempo, são permitidas etapas opcionais.
def maybe_cap_revenue(df, cap=None):
if cap is None:
return df
df = df.copy()
df['revenue'] = df['revenue'].clip(upper=cap)
return df
CAPPING_ENABLED = True
CAP_VALUE = 1000 if CAPPING_ENABLED else None
df_result = df.pipe(maybe_cap_revenue, cap=CAP_VALUE)
print('Conditional step applied:', CAPPING_ENABLED)Exportando o resultado do fluxo
A etapa final de uma cadeia de pipe() geralmente é uma exportação. Pode encadear uma função de exportação personalizada usando pipe() ou simplesmente chamar o método nativo de exportação do Pandas depois da cadeia. Usar uma etapa pipe(save_to_parquet) mantém a exportação documentada como parte da cadeia e garante que ela sempre seja executada no DataFrame limpo final, e não em uma versão intermediária.
def save_parquet(df, path):
df.to_parquet(path, index=False)
print(f'Saved {len(df)} rows to {path}')
return df # return df so the chain can continue if needed
df_final = (
df
.pipe(clean_pipeline)
.pipe(save_parquet, path='orders_final.parquet')
)
print('Pipeline complete.')Verificação rápida
Teste sua compreensão dos conceitos de análise de dados desta lição.
Resumo da lição
Nesta lição, você aprendeu: a usar pipe() para encadear funções personalizadas com métodos nativos do Pandas, a criar etapas de fluxo reutilizáveis, parametrizadas e testáveis como funções puras e a adicionar registros de depuração e etapas condicionais dentro de uma cadeia de pipe. A seguir, exploraremos como estruturar etapas de transformação como funções para um fluxo ETL de produção.
Perguntas Frequentes
A aula “Encadeamento de métodos com pipe()” é grátis?
Sim — o texto completo de “Encadeamento de métodos com pipe()” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Pandas & NumPy Academy, atualize para CoddyKit PRO. O curso de Pandas & NumPy Academy inclui 4 aulas no total.
O que vou aprender em “Encadeamento de métodos com pipe()”?
Escreva pipelines legíveis de transformação de dados usando pipe() para encadear funções personalizadas e métodos nativos do pandas. Você pratica Pandas & NumPy Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Pandas & NumPy Academy?
Nenhuma experiência prévia é necessária. Pandas & NumPy Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Encadeamento de métodos com pipe()”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Pandas & NumPy Academy?
Sim. Cada aula de Pandas & NumPy Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- apply() em colunas e linhas
- apply() com GroupBy
- map() e applymap() para operações elemento a elemento
- Encadeamento de métodos com pipe()