Pandas & NumPy Academy · Lección

Extraer variables temporales

Use el accessor .dt para extraer el año, el mes, el día, day_of_week y la hora de una columna datetime para la ingeniería de características.

Lección 4 de 413 pasos

Extraer variables temporales es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Pandas & NumPy Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.

¿Por qué extraer características temporales?

Una columna datetime64 sin procesar resulta opaca para la mayoría de los algoritmos de aprendizaje automático: no pueden entender que 2024-12-25 es un día festivo o que Friday impulsa un aumento de las ventas minoristas. La ingeniería de características temporales extrae componentes significativos de las columnas de fecha y hora —año, mes, día, día de la semana y hora— como columnas numéricas o categóricas independientes que los modelos y las funciones de análisis pueden utilizar directamente.

El accesor .dt

Cuando una columna de un DataFrame tiene el tipo datetime64, el accesor .dt expone vectorialmente todas las propiedades y métodos de fecha y hora. En lugar de aplicar una función de Python fila por fila, se escribe df['date'].dt.year y Pandas calcula el año para todas las filas en una única operación rápida. El mismo accesor funciona con columnas timedelta64, aunque con propiedades 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

Extraer componentes de fecha

Las propiedades de .dt más utilizadas para los componentes de fecha son: .dt.year, .dt.month, .dt.day, .dt.day_of_week (0=lunes hasta 6=domingo), .dt.day_of_year, .dt.week o .dt.isocalendar().week, .dt.quarter y .dt.days_in_month. Cada una devuelve una Series de enteros que puede utilizarse directamente 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())

Extraer componentes de hora

Para las columnas de fecha y hora que incluyen información horaria (no solo la fecha), use .dt.hour, .dt.minute, .dt.second y .dt.microsecond. Son fundamentales para el análisis intradía, el modelado del comportamiento de los usuarios (patrones de mañana frente a noche) y cualquier sistema en el que la hora del día influya en la variable objetivo.

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())

Nombre del día y del mes

Para obtener etiquetas legibles, use .dt.day_name() y .dt.month_name() para obtener nombres de texto como 'Monday' y 'January'. Resultan útiles para mostrar información en informes y para crear características categóricas que codifiquen los efectos del día de la semana o del mes. También puede pasar un parámetro locale para obtener los nombres en otros 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 fin de semana y de día laborable

Una característica muy habitual es un indicador booleano que señala si una fecha cae en fin de semana. day_of_week >= 5 devuelve True para el sábado (5) y el domingo (6). Para características más sofisticadas de calendarios laborales, numpy.busdaycalendar gestiona los días festivos, pero en la mayoría de los casos la sencilla división entre días laborables y fines de semana recoge la mayor parte del efecto.

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 del inicio y el final del periodo

El accesor .dt también proporciona propiedades booleanas que identifican si una fecha se encuentra al principio o al final de un periodo: .dt.is_month_start, .dt.is_month_end, .dt.is_quarter_start, .dt.is_quarter_end, .dt.is_year_start y .dt.is_year_end. Son útiles para detectar periodos de informes, ciclos de facturación y efectos estacionales asociados a los límites de los periodos.

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']

Codificación cíclica de características temporales

El mes y la hora son cíclicos: diciembre (12) está cerca de enero (1), y las 23:00 están cerca de las 00:00. Tratarlos como enteros lineales (1-12 o 0-23) induce a error a la mayoría de los modelos. Codifique las características cíclicas mediante transformaciones de seno y coseno: sin(2π × value / max_value) y cos(2π × value / max_value). De este modo, la estructura circular queda representada en dos columnas numéricas que los modelos pueden utilizar correctamente.

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))

Operaciones aritméticas con Timedelta

Restar dos columnas de fecha y hora produce una Series timedelta64. El accesor .dt de las Series timedelta expone .dt.days, .dt.seconds y .dt.total_seconds(). Esto permite calcular la duración de eventos, el tiempo transcurrido desde la última compra y la antigüedad en días, todo ello como columnas numéricas listas para análisis 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)

Usar las propiedades .dt del índice

Cuando la fecha y hora es el índice del DataFrame (un DatetimeIndex) en lugar de una columna, acceda a las mismas propiedades directamente en el índice, sin .dt: df.index.year, df.index.month, df.index.day_of_week, etc. Puede añadirlas directamente como columnas nuevas: 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())

Proceso completo de ingeniería de características temporales

A continuación se muestra una función completa de ingeniería de características temporales que recibe un DataFrame con una columna de fecha y hora y lo devuelve enriquecido con las características temporales más útiles. Este patrón se puede aplicar directamente al inicio de cualquier proceso de aprendizaje automático o análisis que trabaje con datos de eventos marcados temporalmente.

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())

Comprobación rápida

Compruebe su comprensión de la extracción de características temporales de las columnas de fecha y hora.

Resumen de la lección

En esta lección ha aprendido que el accesor .dt proporciona acceso vectorizado a todas las propiedades de fecha y hora; entre las características extraídas más habituales se incluyen año, mes, día, day_of_week, hora y trimestre; la codificación cíclica con seno y coseno gestiona la naturaleza circular de las horas y los meses; y la aritmética con timedelta permite calcular duraciones en días o segundos. A continuación, exploraremos la arquitectura de figuras y ejes de Matplotlib para crear gráficos con calidad de publicación.

Gratis para empezar

Aprende Python con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
30
Lecciones
120

Preguntas frecuentes

¿La lección «Extraer variables temporales» es gratis?

Sí — el texto completo de «Extraer variables temporales» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Pandas & NumPy Academy, actualiza a CoddyKit PRO. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Extraer variables temporales»?

Use el accessor .dt para extraer el año, el mes, el día, day_of_week y la hora de una columna datetime para la ingeniería de características. Practicas Pandas & NumPy Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Pandas & NumPy Academy?

No se requiere experiencia previa. Pandas & NumPy Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Extraer variables temporales»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Pandas & NumPy Academy?

Sí. Cada lección de Pandas & NumPy Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. DatetimeIndex y rangos de periodos
  2. Remuestrear series temporales
  3. Desplazamientos y variables de retardo
  4. Extraer variables temporales
← Volver a Pandas & NumPy Academy