Analizar fechas correctamente
Convierta cadenas de fecha a datetime64 con pd.to_datetime, gestione varios formatos y establezca un DatetimeIndex.
Analizar fechas correctamente 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é es importante analizar las fechas
Los datos de fecha y hora son omnipresentes en los conjuntos de datos del mundo real: marcas de tiempo de transacciones, fechas de nacimiento, registros de eventos y periodos financieros. Cuando las fechas se almacenan como cadenas (el tipo de datos object), no puede calcular duraciones, cambiar la frecuencia por mes ni ordenar cronológicamente. Convertir las cadenas al tipo de datos datetime64 de Pandas permite acceder a toda la API de series temporales y hace posible el análisis temporal.
import pandas as pd
df = pd.DataFrame({'date': ['2024-01-15', '2024-03-20', '2024-07-04']})
print(df['date'].dtype) # object
# You cannot do arithmetic on string dates
# df['date'] + pd.Timedelta('1 day') # TypeError!
# After parsing:
df['date'] = pd.to_datetime(df['date'])
print(df['date'].dtype) # datetime64[ns]
print(df['date'] + pd.Timedelta('1 day'))Conceptos básicos de pd.to_datetime()
pd.to_datetime(series) es la función principal para convertir columnas de cadenas a datetime64. Puede reconocer automáticamente la mayoría de los formatos de fecha habituales (ISO 8601, fechas de EE. UU. y fechas europeas) sin que sea necesario indicar una cadena de formato. El resultado es una Series con el tipo de datos datetime64[ns]: precisión de nanosegundos y capacidad para almacenar marcas de tiempo desde 1677 hasta 2262.
import pandas as pd
dates = pd.Series([
'2024-01-15',
'15/01/2024',
'January 15, 2024',
'2024-01-15 08:30:00'
])
parsed = pd.to_datetime(dates)
print(parsed)
# 0 2024-01-15 00:00:00
# 1 2024-01-15 00:00:00
# 2 2024-01-15 00:00:00
# 3 2024-01-15 08:30:00
print(parsed.dtype) # datetime64[ns]Especificar el argumento format=
Cuando la inferencia automática es demasiado lenta o ambigua (por ejemplo, '01-02-03' podría ser el 2 de enero de 2003, el 1 de febrero de 2003 o el 3 de febrero de 2001), proporcione la cadena de formato exacta usando los códigos strftime de Python. Esto también es considerablemente más rápido: en conjuntos de datos grandes, analizar con un formato explícito puede ser 10 veces más rápido que la inferencia automática, porque Pandas no necesita probar varios patrones.
import pandas as pd
dates = pd.Series(['15/01/2024', '20/03/2024', '04/07/2024'])
# Explicit format: day/month/year
parsed = pd.to_datetime(dates, format='%d/%m/%Y')
print(parsed)
# 0 2024-01-15
# 1 2024-03-20
# 2 2024-07-04
# Common format codes:
# %Y = 4-digit year, %y = 2-digit year
# %m = month (01-12), %d = day (01-31)
# %H = hour (0-23), %M = minute, %S = seconderrors='coerce' para fechas incorrectas
Los conjuntos de datos reales suelen contener errores tipográficos o cadenas de marcador de posición como 'TBD', 'N/A' o '99/99/9999' en las columnas de fechas. Pasar errors='coerce' indica a pd.to_datetime() que convierta los valores que no se puedan analizar en NaT (Not a Time, el equivalente de datetime de NaN) en lugar de generar una excepción. Esto le permite identificar y gestionar las fechas incorrectas por separado.
import pandas as pd
dates = pd.Series(['2024-01-15', 'TBD', '2024-07-04', 'N/A'])
parsed = pd.to_datetime(dates, errors='coerce')
print(parsed)
# 0 2024-01-15
# 1 NaT
# 2 2024-07-04
# 3 NaT
# Detect bad dates
print('Bad date rows:', parsed.isna().sum()) # 2parse_dates en read_csv()
El momento más eficiente para analizar las fechas es durante la carga, usando el parámetro parse_dates de pd.read_csv(). Pase una lista de nombres de columnas (o índices) que deban analizarse como fechas. Esto evita un paso independiente de posprocesamiento y suele ser más rápido, porque Pandas lo gestiona durante el análisis del CSV a nivel de C.
import pandas as pd
import io
csv_data = '''order_id,order_date,ship_date
1,2024-01-15,2024-01-18
2,2024-02-20,2024-02-22
'''
df = pd.read_csv(
io.StringIO(csv_data),
parse_dates=['order_date', 'ship_date']
)
print(df.dtypes)
# order_id int64
# order_date datetime64[ns]
# ship_date datetime64[ns]El accesor .dt para componentes de fecha
Una vez que una columna tiene el tipo de datos datetime64, el accesor .dt habilita decenas de propiedades y métodos. Puede extraer .dt.year, .dt.month, .dt.day, .dt.hour, .dt.dayofweek (0 = lunes) y .dt.is_month_end. Estos elementos se usan para la ingeniería de características en la predicción de series temporales y para agrupar datos por periodo de tiempo.
import pandas as pd
df = pd.DataFrame({
'event_time': pd.to_datetime([
'2024-03-15 08:30:00',
'2024-07-04 14:00:00',
'2024-12-25 09:00:00'
])
})
df['year'] = df['event_time'].dt.year
df['month'] = df['event_time'].dt.month
df['day_of_week'] = df['event_time'].dt.day_name()
df['hour'] = df['event_time'].dt.hour
print(df[['year', 'month', 'day_of_week', 'hour']])Establecer un DatetimeIndex
En el análisis de series temporales, es habitual establecer la columna de fecha y hora como el índice del DataFrame. Con un DatetimeIndex, puede usar el filtrado basado en tiempo (df['2024'], df['2024-01':'2024-06']), cambiar la frecuencia a cualquier intervalo y acceder a toda la API de series temporales de Pandas. Use set_index() o pase index_col en read_csv.
import pandas as pd
df = pd.DataFrame({
'date': pd.to_datetime(['2024-01-01', '2024-01-02', '2024-01-03']),
'temp': [22.5, 23.0, 21.8]
})
df = df.set_index('date')
print(df)
# temp
# date
# 2024-01-01 22.5
# 2024-01-02 23.0
# 2024-01-03 21.8
# Time-based slicing
print(df['2024-01-02':'2024-01-03'])Gestionar varios formatos de fecha
Si una columna de fechas contiene una mezcla de formatos (por ejemplo, algunas filas tienen fechas ISO y otras fechas con formato estadounidense), no puede especificar una única cadena de formato. Pase format='mixed' (Pandas 2.0 o posterior) para permitir la detección del formato fila por fila, o limpie previamente la columna con expresiones regulares para normalizar todas las fechas a un único formato antes de llamar a pd.to_datetime().
import pandas as pd
mixed_dates = pd.Series([
'2024-01-15',
'03/20/2024',
'2024-07-04T10:30:00'
])
# format='mixed' handles different formats row-by-row (Pandas >= 2.0)
parsed = pd.to_datetime(mixed_dates, format='mixed')
print(parsed)
# 0 2024-01-15 00:00:00
# 1 2024-03-20 00:00:00
# 2 2024-07-04 10:30:00Fechas y horas con zona horaria
Las marcas de tiempo del mundo real suelen incluir información de zona horaria. pd.to_datetime() puede analizar cadenas con desplazamiento UTC (por ejemplo, '2024-01-15 08:30:00+05:30') y almacenarlas como datetime64 con zona horaria. Use .dt.tz_convert('UTC') para normalizar todas las marcas de tiempo a una zona horaria común y realizar comparaciones y operaciones aritméticas correctas.
import pandas as pd
dates = pd.to_datetime(['2024-01-15 08:30:00+05:30', '2024-01-15 10:00:00-08:00'])
print(dates)
# DatetimeIndex(['2024-01-15 08:30:00+05:30', '2024-01-15 10:00:00-08:00'])
# Convert both to UTC for fair comparison
utc_dates = dates.tz_convert('UTC')
print(utc_dates)
# DatetimeIndex(['2024-01-15 03:00:00+00:00', '2024-01-15 18:00:00+00:00'])Calcular diferencias entre fechas
La aritmética entre dos columnas datetime64 produce una Series de tipo Timedelta. Puede extraer el número de días, horas o segundos de un Timedelta mediante las propiedades .dt.days, .dt.seconds y .dt.total_seconds(). Esta es la forma estándar de calcular características como la edad, la duración o los días transcurridos desde el último evento.
import pandas as pd
df = pd.DataFrame({
'start': pd.to_datetime(['2024-01-01', '2024-03-10', '2024-06-15']),
'end': pd.to_datetime(['2024-01-20', '2024-04-05', '2024-06-30'])
})
df['duration_days'] = (df['end'] - df['start']).dt.days
print(df[['start', 'end', 'duration_days']])
# start end duration_days
# 0 2024-01-01 2024-01-20 19
# 1 2024-03-10 2024-04-05 26
# 2 2024-06-15 2024-06-30 15pd.date_range() para generar fechas
pd.date_range(start, end, freq=) genera una secuencia de fechas espaciadas uniformemente como un DatetimeIndex. Esto resulta útil para crear una estructura temporal completa contra la que pueda cambiar el índice de sus datos, lo que garantiza que todos los periodos del calendario aparezcan en la salida aunque no hubiera eventos ese día. Valores habituales de freq: 'D' (diario), 'ME' (fin de mes), 'h' (cada hora).
import pandas as pd
# Weekly dates for the first quarter of 2024
weekly = pd.date_range(start='2024-01-01', end='2024-03-31', freq='W')
print(weekly[:5])
# DatetimeIndex(['2024-01-07', '2024-01-14', '2024-01-21', '2024-01-28', '2024-02-04'])
# Monthly date spine
monthly = pd.date_range(start='2024-01', periods=12, freq='ME')
print(len(monthly), monthly[0], monthly[-1])
# 12 2024-01-31 2024-12-31Comprobación rápida
Compruebe su comprensión del análisis correcto de fechas en Pandas.
Resumen de la lección
En esta lección ha aprendido que pd.to_datetime() convierte columnas de cadenas a datetime64, format= especifica el patrón exacto para mejorar la velocidad y la precisión, y errors='coerce' convierte las fechas incorrectas en NaT en lugar de provocar un error. El accesor .dt extrae el año, el mes, el día y otros componentes, y establecer un DatetimeIndex permite realizar filtrado basado en tiempo. A continuación, explorará el accesor .str para realizar operaciones vectorizadas con cadenas.
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 «Analizar fechas correctamente» es gratis?
Sí — el texto completo de «Analizar fechas correctamente» 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 «Analizar fechas correctamente»?
Convierta cadenas de fecha a datetime64 con pd.to_datetime, gestione varios formatos y establezca un DatetimeIndex. 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 «Analizar fechas correctamente»?
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
- Inspeccionar los tipos de datos de las columnas
- Conversión de tipos con astype()
- Tipo de datos categórico
- Analizar fechas correctamente