Tutorial Pandas: Operaciones con fechas

Tipos de datos de fecha

En Pandas, las fechas y horas se manejan principalmente utilizando los tipos de datos datetime64 y Timedelta. Estos tipos de datos permiten realizar operaciones avanzadas de manipulación y análisis de datos temporales. A continuación, se describen en detalle estos tipos de datos y cómo se utilizan en Pandas.

Pandas utiliza el tipo de datos datetime64[ns] para representar fechas y horas con precisión de nanosegundos. Este tipo de datos es fundamental para realizar operaciones de análisis temporal de manera eficiente. 

Para convertir una columna de un DataFrame a tipo datetime, se utiliza la función pd.to_datetime(). Por ejemplo:

import pandas as pd

# Crear un DataFrame con datos de ejemplo
data = {'fecha': ['2023-01-01', '2023-02-01', '2023-03-01']}
df = pd.DataFrame(data)

# Convertir la columna 'fecha' a tipo datetime
df['fecha'] = pd.to_datetime(df['fecha'])
print(df.dtypes)

El tipo de datos Timedelta se utiliza para representar diferencias de tiempo entre dos fechas. Este tipo de datos es útil para calcular duraciones, intervalos y realizar operaciones aritméticas con fechas. Para crear una columna de tipo Timedelta, se puede utilizar la función pd.to_timedelta(). Por ejemplo:

import pandas as pd

# Crear un DataFrame con datos de ejemplo
data = {'inicio': ['2023-01-01', '2023-02-01'], 'fin': ['2023-01-10', '2023-02-10']}
df = pd.DataFrame(data)

# Convertir las columnas 'inicio' y 'fin' a tipo datetime
df['inicio'] = pd.to_datetime(df['inicio'])
df['fin'] = pd.to_datetime(df['fin'])

# Calcular la diferencia entre las fechas
df['duracion'] = df['fin'] - df['inicio']
print(df)

En el ejemplo anterior no se utiliza .to_timedelta() porque la diferencia entre dos columnas de tipo datetime (como df['fin'] - df['inicio']) automáticamente genera un objeto de tipo Timedelta.

Cuando se resta una fecha de otra en Pandas, el resultado es directamente una duración o intervalo de tiempo representado como Timedelta. Por tanto, en este caso no es necesario usar explícitamente pd.to_timedelta().

pd.to_timedelta() se utiliza principalmente cuando se quiere crear o convertir directamente a un tipo Timedelta a partir de otros tipos de datos como cadenas o números. Por ejemplo, cuando se desea convertir un número a una duración específica (días, horas, minutos) a partir de una columna que no está en formato de fecha.

Además de datetime64 y Timedelta, Pandas también soporta el tipo de datos Period para trabajar con periodos de tiempo. Un Period representa una unidad de tiempo específica, como un mes o un año. Para crear una columna de tipo Period, se puede utilizar la función pd.period_range(). Por ejemplo:

import pandas as pd

# Crear un rango de periodos mensuales
periodos = pd.period_range(start='2023-01', end='2023-06', freq='M')
print(periodos)

Es importante tener en cuenta que las operaciones con tipos de datos de fecha pueden ser sensibles al formato y la zona horaria. Pandas maneja las zonas horarias mediante el uso de la librería pytz o la funcionalidad de zona horaria de datetime. Para ajustar la zona horaria de una serie de fechas, se puede utilizar el método .tz_localize() y .tz_convert(). Por ejemplo:

import pandas as pd

# Crear una serie de fechas
fechas = pd.date_range(start='2023-01-01', periods=3, freq='D', tz='UTC')

# Convertir la zona horaria de UTC a US/Eastern
fechas = fechas.tz_convert('US/Eastern')
print(fechas)

En resumen, el manejo de tipos de datos de fecha en Pandas es fundamental para realizar análisis temporales precisos y eficientes. La conversión y manipulación de fechas utilizando datetime64, Timedelta y Period permite realizar operaciones avanzadas y obtener insights valiosos de los datos temporales.

Operaciones con fechas

Pandas ofrece una variedad de funciones y métodos para realizar operaciones con fechas de manera eficiente. Estas operaciones son esenciales para tareas de análisis temporal, como la agregación de datos por intervalos de tiempo, el cálculo de diferencias entre fechas y la manipulación de series temporales. A continuación, se presentan algunas de las operaciones más comunes con fechas en Pandas.

Para extraer componentes específicos de una fecha, como el año, el mes o el día, se pueden utilizar los atributos del tipo datetime. Por ejemplo, para obtener el año de una columna de fechas, se puede utilizar el atributo .dt.year:

import pandas as pd

# Crear un DataFrame con datos de ejemplo
data = {'fecha': ['2023-01-01', '2023-02-15', '2023-03-30']}
df = pd.DataFrame(data)

# Convertir la columna 'fecha' a tipo datetime
df['fecha'] = pd.to_datetime(df['fecha'])

# Extraer el año de la columna 'fecha'
df['año'] = df['fecha'].dt.year
print(df)

De manera similar, se pueden extraer otros componentes, como el mes (.dt.month), el día (.dt.day), la hora (.dt.hour), el minuto (.dt.minute) y el segundo (.dt.second).

Otra operación común es la de calcular diferencias entre fechas. Esto se puede lograr restando una columna de fechas de otra, lo que resulta en una columna de tipo Timedelta. Por ejemplo:

import pandas as pd

# Crear un DataFrame con datos de ejemplo
data = {'inicio': ['2023-01-01', '2023-02-01'], 'fin': ['2023-01-10', '2023-02-10']}
df = pd.DataFrame(data)

# Convertir las columnas 'inicio' y 'fin' a tipo datetime
df['inicio'] = pd.to_datetime(df['inicio'])
df['fin'] = pd.to_datetime(df['fin'])

# Calcular la diferencia entre las fechas
df['duracion'] = df['fin'] - df['inicio']
print(df)

Además de calcular diferencias, Pandas permite realizar operaciones aritméticas con fechas, como sumar o restar un número específico de días, semanas, meses o años. Para esto, se puede utilizar el objeto pd.DateOffset. Por ejemplo, para añadir 10 días a una columna de fechas:

import pandas as pd

# Crear un DataFrame con datos de ejemplo
data = {'fecha': ['2023-01-01', '2023-02-01', '2023-03-01']}
df = pd.DataFrame(data)

# Convertir la columna 'fecha' a tipo datetime
df['fecha'] = pd.to_datetime(df['fecha'])

# Añadir 10 días a cada fecha
df['fecha_mas_10_dias'] = df['fecha'] + pd.DateOffset(days=10)
print(df)

Pandas también facilita la comparación de fechas. Se pueden utilizar operadores de comparación (<, <=, >, >=, ==, !=) para filtrar datos basados en condiciones temporales. Por ejemplo, para filtrar un DataFrame y obtener solo las filas con fechas posteriores al 1 de febrero de 2023:

import pandas as pd

# Crear un DataFrame con datos de ejemplo
data = {'fecha': ['2023-01-01', '2023-02-15', '2023-03-30']}
df = pd.DataFrame(data)

# Convertir la columna 'fecha' a tipo datetime
df['fecha'] = pd.to_datetime(df['fecha'])

# Filtrar filas con fechas posteriores al 1 de febrero de 2023
df_filtrado = df[df['fecha'] > '2023-02-01']
print(df_filtrado)

Finalmente, Pandas permite la manipulación de fechas mediante la función pd.date_range(), que genera una serie de fechas con una frecuencia específica. Esto es útil para crear series temporales o rellenar datos faltantes en un rango de fechas. Por ejemplo, para crear una serie de fechas diarias:

import pandas as pd

# Crear una serie de fechas diarias
fechas = pd.date_range(start='2023-01-01', end='2023-01-10', freq='D')
print(fechas)

Estas operaciones con fechas son fundamentales para realizar análisis temporal y manipulación de datos en Pandas, permitiendo a los ingenieros de software trabajar de manera más eficiente con datos temporales.

Series temporales en Pandas

Las series temporales en Pandas son una herramienta fundamental para el análisis de datos que varían con el tiempo. Una serie temporal es una secuencia de datos ordenados cronológicamente, y Pandas proporciona una variedad de funcionalidades para manipular y analizar estas series.

Para crear una serie temporal, se utiliza el objeto pd.date_range() que genera una secuencia de fechas con una frecuencia específica. Por ejemplo, para crear una serie temporal diaria:

import pandas as pd

# Crear una serie temporal diaria
fechas = pd.date_range(start='2023-01-01', end='2023-01-10', freq='D')
serie_temporal = pd.Series(range(len(fechas)), index=fechas)
print(serie_temporal)

Las series temporales en Pandas permiten realizar una serie de operaciones avanzadas, como el resampling, el desplazamiento y la interpolación.

El resampling es la operación de convertir una serie temporal de una frecuencia a otra. Por ejemplo, cambiar una serie diaria a una serie mensual. Esto se puede hacer utilizando el método .resample(). Por ejemplo, para obtener la suma mensual de una serie diaria:

# Resamplear la serie temporal para obtener la suma mensual
serie_mensual = serie_temporal.resample('ME').sum()
print(serie_mensual)

El desplazamiento (shifting) es otra operación común en el análisis de series temporales. Permite desplazar los datos hacia adelante o hacia atrás en el tiempo. Esto es útil para calcular diferencias o crear variables rezagadas. Se puede realizar utilizando el método .shift(). Por ejemplo, para desplazar una serie temporal un día hacia adelante:

# Desplazar la serie temporal un día hacia adelante
serie_desplazada = serie_temporal.shift(1)
print(serie_desplazada)

La interpolación se utiliza para rellenar valores faltantes en una serie temporal. Pandas ofrece varios métodos de interpolación, como lineal, polinómica y spline. Para utilizar la interpolación lineal:

# Introducir valores NaN en la serie temporal
serie_temporal[2:4] = None

# Interpolar los valores faltantes
serie_interpolada = serie_temporal.interpolate(method='linear')
print(serie_interpolada)

Además, Pandas permite trabajar con series temporales que contienen datos de diferentes zonas horarias. Para ajustar la zona horaria de una serie temporal, se utilizan los métodos .tz_localize() y .tz_convert(). Por ejemplo, para convertir una serie temporal a la zona horaria US/Eastern:

# Crear una serie temporal con zona horaria UTC
serie_temporal_utc = serie_temporal.tz_localize('UTC')

# Convertir la serie temporal a la zona horaria US/Eastern
serie_temporal_est = serie_temporal_utc.tz_convert('US/Eastern')
print(serie_temporal_est)

Pandas también permite realizar operaciones de rolling (ventana móvil), que son útiles para calcular estadísticas móviles, como medias o sumas móviles. Esto se puede hacer utilizando el método .rolling(). Por ejemplo, para calcular una media móvil de 3 días:

# Calcular una media móvil de 3 días
media_movil = serie_temporal.rolling(window=3).mean()
print(media_movil)

Finalmente, Pandas ofrece herramientas para trabajar con fechas y horas, como la extracción de componentes temporales (año, mes, día, etc.) y la manipulación de periodos de tiempo con el objeto Period. Por ejemplo, para extraer el mes de una serie temporal:

# Extraer el mes de la serie temporal
mes = serie_temporal.index.month
print(mes)

Estas funcionalidades avanzadas permiten manipular y analizar series temporales de manera eficiente, facilitando el análisis de tendencias, estacionalidades y otros patrones temporales en los datos.

Resampling

El resampling es una técnica utilizada en Pandas para cambiar la frecuencia de una serie temporal. Este proceso puede implicar tanto la agregación de datos de una frecuencia más alta a una más baja (downsampling) como la interpolación de datos de una frecuencia más baja a una más alta (upsampling). A continuación, se presentan los conceptos clave y ejemplos prácticos de cómo utilizar el resampling en Pandas.

Para realizar el resampling en Pandas, se utiliza el método .resample(), que permite especificar la nueva frecuencia deseada. Este método se aplica a una serie temporal o a una columna de un DataFrame que contiene datos temporales.

Downsampling

El downsampling consiste en reducir la frecuencia de una serie temporal agregando los datos. Por ejemplo, si se tiene una serie con datos diarios y se desea convertirla en una serie mensual, se puede utilizar el método .resample() junto con una función de agregación como .sum(), .mean(), etc.

import pandas as pd

# Crear una serie temporal diaria
fechas = pd.date_range(start='2023-01-01', end='2023-01-31', freq='D')
serie_temporal = pd.Series(range(len(fechas)), index=fechas)

# Resamplear la serie temporal para obtener la suma mensual
serie_mensual = serie_temporal.resample('ME').sum()
print(serie_mensual)

Upsampling

El upsampling consiste en aumentar la frecuencia de una serie temporal, generalmente mediante la interpolación de datos. A diferencia del downsampling, el upsampling requiere un método de relleno para llenar los valores generados en la nueva frecuencia. Se puede especificar el método de relleno utilizando .ffill() (forward fill) o .bfill() (backward fill).

import pandas as pd

# Crear una serie temporal mensual
fechas = pd.date_range(start='2023-01-01', end='2023-04-01', freq='ME')
serie_temporal = pd.Series(range(len(fechas)), index=fechas)

# Resamplear la serie temporal para obtener datos diarios y llenar los valores faltantes
serie_diaria = serie_temporal.resample('D').ffill()
print(serie_diaria)

Resampling con funciones personalizadas

Además de las funciones de agregación predefinidas, Pandas permite aplicar funciones personalizadas al resampleo. Esto se logra utilizando el método .apply() junto con una función definida por el usuario.

import pandas as pd

# Crear una serie temporal diaria
fechas = pd.date_range(start='2023-01-01', end='2023-01-10', freq='D')
serie_temporal = pd.Series(range(len(fechas)), index=fechas)

# Definir una función personalizada para el resampling
def custom_agg(x):
    return x.max() - x.min()

# Resamplear la serie temporal utilizando la función personalizada
serie_resampleada = serie_temporal.resample('3D').apply(custom_agg)
print(serie_resampleada)

Consideraciones adicionales

Al realizar resampling, es importante tener en cuenta la alineación de los datos y los intervalos de tiempo. Pandas ofrece parámetros adicionales en el método .resample() para ajustar el comportamiento del resampleo, como label y closed, que determinan cómo se etiquetan y cierran los intervalos de tiempo.

import pandas as pd

# Crear una serie temporal diaria
fechas = pd.date_range(start='2023-01-01', end='2023-01-10', freq='D')
serie_temporal = pd.Series(range(len(fechas)), index=fechas)

# Resamplear la serie temporal con etiquetas y cierres personalizados
serie_resampleada = serie_temporal.resample('3D', label='left', closed='left').sum()
print(serie_resampleada)

El resampling es una técnica esencial en el análisis de series temporales, permitiendo cambiar la resolución temporal de los datos para adaptarse a diferentes necesidades analíticas.