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.
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, 5Extraer 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 JanuaryIndicador 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 averageIndicadores 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.
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
- DatetimeIndex y rangos de periodos
- Remuestrear series temporales
- Desplazamientos y variables de retardo
- Extraer variables temporales