Pandas & NumPy Academy · Lección

Analizar fechas correctamente

Convierta cadenas de fecha a datetime64 con pd.to_datetime, gestione varios formatos y establezca un DatetimeIndex.

Lección 4 de 413 pasos

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 = second

errors='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())  # 2

parse_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:00

Fechas 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             15

pd.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-31

Comprobació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.

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

  1. Inspeccionar los tipos de datos de las columnas
  2. Conversión de tipos con astype()
  3. Tipo de datos categórico
  4. Analizar fechas correctamente
← Volver a Pandas & NumPy Academy