Pandas & NumPy Academy · Aula

Extraindo características temporais

Use o acessador .dt para extrair ano, mês, dia, day_of_week e hora de uma coluna datetime para a criação de variáveis.

Aula 4 de 413 etapas

Extraindo características temporais é 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.

Por que extrair características temporais?

Uma coluna datetime64 bruta é opaca para a maioria dos algoritmos de aprendizado de máquina — eles não conseguem entender que 2024-12-25 é um feriado ou que Friday contribui para vendas maiores no varejo. A engenharia de características temporais extrai componentes significativos de colunas de data e hora — ano, mês, dia, dia da semana e hora — como colunas numéricas ou categóricas separadas, que os modelos e as funções de análise podem utilizar diretamente.

O acessador .dt

Quando uma coluna de um DataFrame tem o tipo datetime64, o acessador .dt disponibiliza vetorialmente todas as propriedades e os métodos de data e hora. Em vez de aplicar uma função Python linha por linha, você escreve df['date'].dt.year, e o Pandas calcula o ano para todas as linhas em uma única operação rápida. O mesmo acessador funciona em colunas timedelta64, com propriedades diferentes.

import pandas as pd

df = pd.DataFrame({
    'event_date': pd.date_range('2024-01-01', periods=8, freq='D'),
    'revenue': [200, 350, 280, 310, 420, 380, 190, 260]
})

# Access datetime properties with .dt
print(df['event_date'].dt.year)    # 2024 for all
print(df['event_date'].dt.month)   # 1 for all
print(df['event_date'].dt.day[:5]) # 1, 2, 3, 4, 5

Extraindo componentes da data

As propriedades .dt mais usadas para componentes de data são: .dt.year, .dt.month, .dt.day, .dt.day_of_week (0=segunda-feira até 6=domingo), .dt.day_of_year, .dt.week ou .dt.isocalendar().week, .dt.quarter e .dt.days_in_month. Cada uma retorna uma Series de inteiros que pode ser usada diretamente como característica.

df['year']        = df['event_date'].dt.year
df['month']       = df['event_date'].dt.month
df['day']         = df['event_date'].dt.day
df['day_of_week'] = df['event_date'].dt.day_of_week  # 0=Mon
df['quarter']     = df['event_date'].dt.quarter
df['day_of_year'] = df['event_date'].dt.day_of_year

print(df[['event_date', 'year', 'month', 'day',
           'day_of_week', 'quarter']].head())

Extraindo componentes da hora

Para colunas de data e hora que incluem informações de horário (não apenas a data), use .dt.hour, .dt.minute, .dt.second e .dt.microsecond. Esses recursos são essenciais para análises intradiárias, modelagem do comportamento dos usuários (padrões da manhã versus da noite) e qualquer sistema em que o horário do dia influencie a variável-alvo.

df_ts = pd.DataFrame({
    'timestamp': pd.date_range('2024-01-01', periods=6, freq='4h'),
    'logins': [50, 200, 320, 280, 180, 90]
})

df_ts['hour']   = df_ts['timestamp'].dt.hour
df_ts['minute'] = df_ts['timestamp'].dt.minute
df_ts['date']   = df_ts['timestamp'].dt.date    # Python date object
df_ts['time']   = df_ts['timestamp'].dt.time    # Python time object
print(df_ts[['timestamp', 'hour', 'date']].head())

Nome do dia e nome do mês

Para obter rótulos legíveis, use .dt.day_name() e .dt.month_name() para obter nomes de texto como 'Monday' e 'January'. Eles são úteis para exibição em relatórios e para criar características categóricas que codifiquem os efeitos do dia da semana e do mês. Você também pode passar uma locale para obter nomes em outros idiomas.

df['day_name']   = df['event_date'].dt.day_name()
df['month_name'] = df['event_date'].dt.month_name()

print(df[['event_date', 'day_name', 'month_name']].head(5))
# event_date day_name month_name
# 2024-01-01   Monday    January
# 2024-01-02  Tuesday    January
# 2024-01-03  Wednesday  January

Indicador de fim de semana e de dia útil

Uma característica muito comum é um indicador booleano que informa se uma data cai em um fim de semana. day_of_week >= 5 retorna True para sábado (5) e domingo (6). Para características de calendário comercial mais sofisticadas, numpy.busdaycalendar lida com feriados, mas, na maioria dos casos, a simples separação entre dias úteis e fins de semana captura a maior parte do efeito.

df['is_weekend'] = df['event_date'].dt.day_of_week >= 5
df['is_weekday'] = ~df['is_weekend']

# Compare weekend vs weekday revenue
print(df.groupby('is_weekend')['revenue'].mean().round(1))
# is_weekend
# False    308.3  <- weekday average
# True     285.0  <- weekend average

Indicadores de início e fim do período

O acessador .dt também fornece propriedades booleanas que identificam se uma data está no início ou no fim de um período: .dt.is_month_start, .dt.is_month_end, .dt.is_quarter_start, .dt.is_quarter_end, .dt.is_year_start e .dt.is_year_end. Elas são úteis para detectar períodos de relatório, ciclos de faturamento e efeitos sazonais nas transições de período.

dates_series = pd.Series(
    pd.date_range('2024-01-28', periods=10, freq='D')
)

print(dates_series[dates_series.dt.is_month_start].values)
# ['2024-02-01']

print(dates_series[dates_series.dt.is_month_end].values)
# ['2024-01-31']

Codificação cíclica de características temporais

Mês e hora são cíclicos — dezembro (12) está próximo de janeiro (1), e 23:00 está próximo de 00:00. Tratá-los como inteiros lineares (1-12 ou 0-23) induz a maioria dos modelos ao erro. Codifique as características cíclicas usando transformações de seno e cosseno: sin(2π × value / max_value) e cos(2π × value / max_value). Isso incorpora a estrutura circular em duas colunas numéricas que os modelos podem utilizar corretamente.

import numpy as np

# Cyclical encoding for month (1-12)
df['month_sin'] = np.sin(2 * np.pi * df['month'] / 12)
df['month_cos'] = np.cos(2 * np.pi * df['month'] / 12)

# Cyclical encoding for day of week (0-6)
df['dow_sin'] = np.sin(2 * np.pi * df['day_of_week'] / 7)
df['dow_cos'] = np.cos(2 * np.pi * df['day_of_week'] / 7)

print(df[['month', 'month_sin', 'month_cos']].head().round(3))

Operações aritméticas com timedelta

Subtrair duas colunas de data e hora produz uma Series timedelta64. O acessador .dt em uma Series timedelta disponibiliza .dt.days, .dt.seconds e .dt.total_seconds(). Isso permite calcular durações de eventos, o tempo desde a última compra e a idade em dias — tudo como colunas numéricas prontas para análises posteriores.

df_orders = pd.DataFrame({
    'order_date':    pd.to_datetime(['2024-01-01', '2024-02-10', '2024-03-05']),
    'delivery_date': pd.to_datetime(['2024-01-04', '2024-02-13', '2024-03-12'])
})

# Compute delivery time in days
df_orders['delivery_days'] = (
    df_orders['delivery_date'] - df_orders['order_date']
).dt.days
print(df_orders)

Usando propriedades .dt do índice

Quando a data e hora está no índice do DataFrame (um DatetimeIndex), e não em uma coluna, acesse as mesmas propriedades diretamente no índice, sem .dt: df.index.year, df.index.month, df.index.day_of_week etc. Você pode adicioná-las diretamente como novas colunas: df['month'] = df.index.month.

df_indexed = df.set_index('event_date')

# Access components directly on the DatetimeIndex
print(df_indexed.index.month[:3])  # [1, 1, 1]
print(df_indexed.index.day_of_week[:3])  # [0, 1, 2]

# Add as new columns
df_indexed['month']   = df_indexed.index.month
df_indexed['weekday'] = df_indexed.index.day_of_week
print(df_indexed.head())

Fluxo completo de engenharia de características temporais

Aqui está uma função completa de engenharia de características temporais que recebe um DataFrame com uma coluna de data e hora e o retorna enriquecido com as características temporais mais úteis. Esse padrão pode ser aplicado diretamente no início de qualquer fluxo de processamento de aprendizado de máquina ou análise que trabalhe com dados de eventos marcados com data e hora.

def add_temporal_features(df, date_col):
    dt = df[date_col].dt
    df['year']       = dt.year
    df['month']      = dt.month
    df['day']        = dt.day
    df['day_of_week'] = dt.day_of_week
    df['quarter']    = dt.quarter
    df['is_weekend'] = dt.day_of_week >= 5
    df['month_sin']  = (2 * 3.14159 * dt.month / 12).__round__(4)
    df['month_cos']  = (2 * 3.14159 * dt.month / 12).__round__(4)
    return df

result = add_temporal_features(df.copy(), 'event_date')
print(result.columns.tolist())

Verificação rápida

Teste sua compreensão sobre a extração de características temporais de colunas de data e hora.

Responda na aula interativa

Recapitulação da lição

Nesta lição, você aprendeu que o acessador .dt fornece acesso vetorizado a todas as propriedades de data e hora; entre as características extraídas mais comuns estão ano, mês, dia, day_of_week, hora e trimestre; a codificação cíclica com seno e cosseno lida com a natureza circular das horas e dos meses; e as operações aritméticas com timedelta permitem calcular durações em dias ou segundos. A seguir, exploraremos a arquitetura de figuras e eixos do Matplotlib para criar gráficos com qualidade de publicação.

Grátis para começar

Aprenda Python com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 30
Aulas: 120

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Extraindo características temporais” é grátis?

Sim — o texto completo de “Extraindo características temporais” é 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 “Extraindo características temporais”?

Use o acessador .dt para extrair ano, mês, dia, day_of_week e hora de uma coluna datetime para a criação de variáveis. 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 “Extraindo características temporais”?

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

← Voltar para Pandas & NumPy Academy