Tutorial R: lubridate para fechas y tiempo

Creación y parseo de fechas con ymd(), mdy()

El manejo de fechas en R puede resultar complicado debido a los diferentes formatos existentes. La biblioteca lubridate simplifica enormemente este proceso, ofreciendo funciones intuitivas para crear y transformar objetos de fecha y hora.

Instalación y carga de lubridate

Antes de comenzar a trabajar con fechas, necesitamos instalar y cargar la biblioteca:

# Instalación (solo necesario una vez)
install.packages("lubridate")

# Carga de la biblioteca
library(lubridate)

Funciones de parseo según el orden de los componentes

La característica más útil de lubridate es su conjunto de funciones para convertir cadenas de texto o valores numéricos en objetos de fecha. Estas funciones se nombran según el orden en que aparecen los componentes de la fecha:

• y: año (year)
• m: mes (month)
• d: día (day)

Dependiendo del formato de entrada, utilizaremos diferentes combinaciones:

# Formato año-mes-día (ISO 8601)
fecha1 <- ymd("2023-05-15")

# Formato mes-día-año (común en EE.UU.)
fecha2 <- mdy("05/15/2023")

# Formato día-mes-año (común en Europa)
fecha3 <- dmy("15-05-2023")

# Mostramos los resultados
fecha1
fecha2
fecha3

El resultado será:

[1] "2023-05-15"
[1] "2023-05-15"
[1] "2023-05-15"

Observa cómo lubridate estandariza automáticamente todas las fechas al formato ISO 8601 (YYYY-MM-DD), independientemente del formato de entrada.

Flexibilidad en el formato de entrada

Una ventaja importante de lubridate es su flexibilidad para reconocer diferentes separadores y formatos:

# Diferentes separadores
ymd("2023-05-15")  # Con guiones
ymd("2023/05/15")  # Con barras
ymd("2023.05.15")  # Con puntos
ymd("20230515")    # Sin separadores

# Diferentes formatos para el mismo orden
mdy("May 15, 2023")
mdy("05-15-2023")
mdy("5/15/23")     # Incluso con año abreviado

Todas estas expresiones producirán el mismo objeto de fecha: 2023-05-15.

Manejo de fechas ambiguas

Cuando trabajamos con fechas como "01-02-2023", existe ambigüedad: ¿es el 1 de febrero o el 2 de enero? Por eso es crucial usar la función correcta según el formato esperado:

# Para formato mes-día-año
mdy("01-02-2023")  # 2 de enero de 2023

# Para formato día-mes-año
dmy("01-02-2023")  # 1 de febrero de 2023

# Comparación
mdy("01-02-2023") == dmy("01-02-2023")  # FALSE, son fechas diferentes

Parseo con horas, minutos y segundos

Lubridate también permite incluir información de hora junto con la fecha:

# Año-mes-día hora:minuto
ymd_hm("2023-05-15 14:30")

# Mes-día-año hora:minuto:segundo
mdy_hms("05/15/2023 14:30:45")

# Día-mes-año hora
dmy_h("15-05-2023 14")

Estas funciones crean objetos de tipo POSIXct, que representan fechas con hora.

Conversión desde valores numéricos

También podemos crear fechas a partir de valores numéricos separados:

# Con argumentos separados
ymd(2023, 5, 15)

# Con vectores
fechas_ymd <- ymd(c("2023-01-15", "2023-02-20", "2023-03-25"))
fechas_ymd

Manejo de errores y fechas inválidas

Lubridate verifica automáticamente si las fechas son válidas:

# Fecha inválida (30 de febrero)
ymd("2023-02-30")

Esto generará un mensaje de advertencia y producirá un valor NA:

Warning: 1 failed to parse.
[1] NA

Aplicación práctica: Limpieza de fechas en un conjunto de datos

Un caso de uso común es limpiar y estandarizar fechas en un conjunto de datos:

# Supongamos que tenemos fechas en diferentes formatos
fechas_mixtas <- c("2023-05-15", "05/20/2023", "25-06-2023", "2023.07.30")

# Podemos intentar parsear con diferentes funciones
fechas_limpias <- c(
  ymd(fechas_mixtas[1]),
  mdy(fechas_mixtas[2]),
  dmy(fechas_mixtas[3]),
  ymd(fechas_mixtas[4])
)

fechas_limpias

Resultado:

[1] "2023-05-15" "2023-05-20" "2023-06-25" "2023-07-30"

Conversión a otros formatos

Una vez que tenemos un objeto de fecha, podemos convertirlo a otros formatos si es necesario:

fecha <- ymd("2023-05-15")

# Convertir a formato de texto personalizado
format(fecha, "%d/%m/%Y")  # "15/05/2023"

# Convertir a Date de R base
as.Date(fecha)

Las funciones de parseo de lubridate son la base para trabajar con datos temporales en R, permitiéndonos convertir fácilmente texto o números en objetos de fecha que podemos manipular posteriormente.

Extracción de componentes (año, mes, día, hora)

Una vez que tenemos fechas correctamente formateadas con lubridate, frecuentemente necesitamos extraer componentes específicos para análisis o manipulación. Lubridate ofrece funciones intuitivas que nos permiten acceder a cada elemento temporal de manera sencilla.

Funciones básicas de extracción

Lubridate proporciona funciones específicas para extraer cada componente de una fecha:

# Creamos una fecha con hora para nuestros ejemplos
fecha_hora <- ymd_hms("2023-09-15 14:30:45")

# Extraemos componentes básicos
year(fecha_hora)    # Año
month(fecha_hora)   # Mes (como número)
day(fecha_hora)     # Día del mes
hour(fecha_hora)    # Hora
minute(fecha_hora)  # Minutos
second(fecha_hora)  # Segundos

El resultado sería:

[1] 2023
[1] 9
[1] 15
[1] 14
[1] 30
[1] 45

Estas funciones son bidireccionales, lo que significa que también pueden usarse para modificar componentes:

# Cambiamos el año de nuestra fecha
fecha_modificada <- fecha_hora
year(fecha_modificada) <- 2024
fecha_modificada

Resultado:

[1] "2024-09-15 14:30:45 UTC"

Extracción de componentes adicionales

Además de los componentes básicos, lubridate ofrece funciones para extraer información contextual sobre las fechas:

# Día de la semana (1=lunes, 7=domingo)
wday(fecha_hora)

# Día de la semana con nombres
wday(fecha_hora, label = TRUE)  # Abreviado
wday(fecha_hora, label = TRUE, abbr = FALSE)  # Completo

# Día del año (1-366)
yday(fecha_hora)

# Semana del año (1-53)
week(fecha_hora)

# Trimestre (1-4)
quarter(fecha_hora)

Ejemplo de resultado:

[1] 6
[1] vie
[1] viernes
[1] 258
[1] 37
[1] 3

Nombres de meses

Para obtener el nombre del mes en lugar del número:

# Mes como etiqueta
month(fecha_hora, label = TRUE)  # Abreviado
month(fecha_hora, label = TRUE, abbr = FALSE)  # Completo

Resultado:

[1] sep
[1] septiembre

Trabajando con vectores de fechas

Estas funciones de extracción funcionan perfectamente con vectores de fechas:

# Vector de fechas
fechas <- ymd(c("2023-01-15", "2023-05-20", "2023-12-31"))

# Extraer componentes de todas las fechas
month(fechas)
day(fechas)
wday(fechas, label = TRUE)

Resultado:

[1] 1 5 12
[1] 15 20 31
[1] dom sáb dom

Aplicaciones prácticas

Filtrado por componentes temporales

Podemos usar la extracción de componentes para filtrar datos según criterios temporales:

# Crear un data frame de ejemplo
datos <- data.frame(
  fecha = ymd(c("2023-01-15", "2023-02-20", "2023-03-25", 
                "2023-04-10", "2023-05-15")),
  valor = c(45, 62, 78, 53, 91)
)

# Filtrar registros del primer trimestre
primer_trimestre <- datos[quarter(datos$fecha) == 1, ]
primer_trimestre

# Filtrar registros de días lunes
dias_lunes <- datos[wday(datos$fecha) == 2, ]
dias_lunes

Agrupación por componentes temporales

También podemos agrupar datos según componentes de fecha:

# Crear datos más extensos
fechas_aleatorias <- seq(from = ymd("2023-01-01"), 
                         to = ymd("2023-12-31"), 
                         by = "day")
valores_aleatorios <- runif(length(fechas_aleatorias), 0, 100)

datos_diarios <- data.frame(
  fecha = fechas_aleatorias,
  valor = valores_aleatorios
)

# Calcular promedio mensual
promedios_mensuales <- aggregate(
  valor ~ month(fecha, label = TRUE), 
  data = datos_diarios, 
  FUN = mean
)

# Renombrar columna para claridad
names(promedios_mensuales)[1] <- "mes"

Extracción de zonas horarias

Si trabajamos con fechas que incluyen información de zona horaria, podemos extraerla:

# Crear fecha con zona horaria
fecha_con_tz <- ymd_hms("2023-09-15 14:30:45", tz = "Europe/Madrid")

# Extraer zona horaria
tz(fecha_con_tz)

Resultado:

[1] "Europe/Madrid"

Verificación de componentes

Lubridate también ofrece funciones para verificar características de las fechas:

# Verificar si es fin de mes
is.Date(fecha_hora)         # ¿Es un objeto Date?
is.POSIXct(fecha_hora)      # ¿Es un objeto POSIXct?
is.timepoint(fecha_hora)    # ¿Es un punto en el tiempo?

Caso práctico: Análisis de patrones temporales

Veamos cómo usar la extracción de componentes para analizar patrones temporales en datos:

# Crear datos de ventas diarias para un año
set.seed(123)  # Para reproducibilidad
fechas_ventas <- seq(from = ymd("2023-01-01"), 
                     to = ymd("2023-12-31"), 
                     by = "day")
ventas <- runif(length(fechas_ventas), 100, 1000)

datos_ventas <- data.frame(
  fecha = fechas_ventas,
  ventas = ventas
)

# Analizar ventas por día de la semana
ventas_por_dia <- aggregate(
  ventas ~ wday(fecha, label = TRUE), 
  data = datos_ventas, 
  FUN = mean
)
names(ventas_por_dia)[1] <- "dia_semana"

# Ver los resultados
ventas_por_dia

La extracción de componentes temporales es fundamental para cualquier análisis que involucre fechas, permitiéndonos descomponer la información temporal en elementos manejables que podemos utilizar para filtrar, agrupar y analizar nuestros datos de manera efectiva.

Cálculos y intervalos temporales

Una de las ventajas principales de lubridate es la facilidad con la que podemos realizar cálculos con fechas y tiempos. Mientras que en R base estos cálculos pueden resultar confusos, lubridate nos ofrece una sintaxis intuitiva y consistente para manipular intervalos temporales.

Aritmética básica con fechas

Podemos sumar o restar directamente unidades de tiempo a una fecha:

# Creamos una fecha de referencia
fecha_base <- ymd("2023-05-15")

# Sumamos días
fecha_base + days(10)

# Restamos semanas
fecha_base - weeks(2)

# Combinamos operaciones
fecha_base + months(3) - days(5)

Resultado:

[1] "2023-05-25"
[1] "2023-05-01"
[1] "2023-08-10"

Las funciones days(), weeks(), months() y years() crean duraciones que podemos usar en operaciones aritméticas:

# Diferentes unidades de tiempo
fecha_base + days(1)     # Añadir 1 día
fecha_base + weeks(2)    # Añadir 2 semanas
fecha_base + months(3)   # Añadir 3 meses
fecha_base + years(1)    # Añadir 1 año

# También funciona con horas, minutos y segundos
fecha_hora <- ymd_hms("2023-05-15 10:30:00")
fecha_hora + hours(3) + minutes(15)

Duraciones vs períodos

Lubridate distingue entre dos tipos de intervalos temporales: duraciones y períodos.

• Las duraciones representan un tiempo exacto en segundos
• Los períodos representan unidades de tiempo como las percibimos (días, meses, años)

# Duración (tiempo exacto)
duracion_1mes <- ddays(30)  # 30 días exactos

# Período (unidad de calendario)
periodo_1mes <- months(1)   # 1 mes del calendario

# Comparemos los resultados
fecha_base + duracion_1mes
fecha_base + periodo_1mes

La diferencia es importante cuando trabajamos con meses de diferente longitud o cuando hay cambios de horario:

# Fecha en enero (31 días)
enero31 <- ymd("2023-01-31")

# Sumamos un mes como duración vs período
enero31 + ddays(30)  # 30 días exactos
enero31 + months(1)  # 28 de febrero (o 29 en año bisiesto)

Intervalos entre fechas

Para calcular la diferencia entre dos fechas:

# Dos fechas
fecha_inicio <- ymd("2023-01-15")
fecha_fin <- ymd("2023-05-20")

# Diferencia como intervalo
intervalo <- interval(fecha_inicio, fecha_fin)
intervalo

# Longitud del intervalo en diferentes unidades
as.period(intervalo)
as.duration(intervalo)

Resultado:

[1] 2023-01-15 UTC--2023-05-20 UTC
[1] "4m 5d 0H 0M 0S"
[1] "10627200s (~17.43 weeks)"

Podemos extraer la duración en unidades específicas:

# Diferencia en días
as.duration(intervalo) / ddays(1)

# Diferencia en semanas
as.duration(intervalo) / dweeks(1)

# Diferencia en meses (aproximado)
as.duration(intervalo) / dmonths(1)

Funciones de diferencia simplificadas

Lubridate ofrece funciones más directas para calcular diferencias:

# Diferencia en días
difftime(fecha_fin, fecha_inicio, units = "days")

# Usando funciones específicas de lubridate
time_length(intervalo, "day")
time_length(intervalo, "week")
time_length(intervalo, "month")
time_length(intervalo, "year")

Operaciones con períodos

Los períodos son especialmente útiles para cálculos que respetan el calendario:

# Crear períodos
p1 <- years(1) + months(6) + days(15)
p1

# Operaciones con períodos
p2 <- months(3) + days(10)
p1 + p2
p1 - p2

# Multiplicación de períodos
p2 * 2

Resultado:

[1] "1y 6m 15d 0H 0M 0S"
[1] "1y 9m 25d 0H 0M 0S"
[1] "1y 3m 5d 0H 0M 0S"
[1] "6m 20d 0H 0M 0S"

Secuencias de fechas

Podemos crear secuencias de fechas con intervalos regulares:

# Secuencia por días
seq(ymd("2023-01-01"), ymd("2023-01-10"), by = "day")

# Secuencia por semanas
seq(ymd("2023-01-01"), ymd("2023-03-01"), by = "week")

# Secuencia por meses
seq(ymd("2023-01-01"), ymd("2023-12-31"), by = "month")

# Usando períodos de lubridate
seq(ymd("2023-01-01"), ymd("2023-12-31"), by = months(3))

Redondeo de fechas

Lubridate permite redondear fechas a unidades específicas:

fecha_hora <- ymd_hms("2023-05-15 14:28:35")

# Redondear hacia abajo (floor)
floor_date(fecha_hora, "minute")  # Redondea a minuto
floor_date(fecha_hora, "hour")    # Redondea a hora
floor_date(fecha_hora, "day")     # Redondea a día
floor_date(fecha_hora, "month")   # Redondea a mes

# Redondear hacia arriba (ceiling)
ceiling_date(fecha_hora, "hour")

# Redondear al más cercano (round)
round_date(fecha_hora, "hour")

Resultado:

[1] "2023-05-15 14:28:00 UTC"
[1] "2023-05-15 14:00:00 UTC"
[1] "2023-05-15 UTC"
[1] "2023-05-01 UTC"
[1] "2023-05-15 15:00:00 UTC"
[1] "2023-05-15 14:00:00 UTC"

Caso práctico: Análisis de plazos

Veamos un ejemplo de cómo usar los cálculos temporales para analizar plazos en un proyecto:

# Fechas de inicio de tareas
inicios <- ymd(c("2023-03-10", "2023-04-05", "2023-05-20"))

# Duración estimada en días
duraciones <- c(15, 30, 20)

# Calcular fechas de finalización
finalizaciones <- inicios + days(duraciones)

# Crear data frame
tareas <- data.frame(
  tarea = c("Diseño", "Desarrollo", "Pruebas"),
  inicio = inicios,
  duracion = duraciones,
  fin = finalizaciones
)

# Mostrar tabla
tareas

# Calcular duración total del proyecto
duracion_proyecto <- interval(min(inicios), max(finalizaciones))
time_length(duracion_proyecto, "day")

Trabajando con días laborables

Para cálculos más realistas, a veces necesitamos considerar solo días laborables:

# Instalar y cargar paquete adicional
# install.packages("bizdays")
library(bizdays)

# Crear calendario (lunes a viernes)
create.calendar("MiCalendario", weekdays = c("saturday", "sunday"))

# Calcular días laborables entre fechas
bizdays(ymd("2023-05-01"), ymd("2023-05-31"), "MiCalendario")

# Añadir días laborables a una fecha
add.bizdays(ymd("2023-05-01"), 10, "MiCalendario")

Manejo de zonas horarias en cálculos

Al realizar cálculos con fechas que tienen zonas horarias, debemos tener cuidado:

# Crear fechas con diferentes zonas horarias
fecha_madrid <- ymd_hms("2023-05-15 10:00:00", tz = "Europe/Madrid")
fecha_ny <- ymd_hms("2023-05-15 10:00:00", tz = "America/New_York")

# Diferencia real entre las horas
difftime(fecha_madrid, fecha_ny, units = "hours")

# Convertir a la misma zona horaria antes de comparar
fecha_ny_en_madrid <- with_tz(fecha_ny, "Europe/Madrid")
difftime(fecha_madrid, fecha_ny_en_madrid, units = "hours")

Cálculos con fechas recurrentes

Podemos identificar fechas que cumplen ciertos patrones recurrentes:

# Crear un rango de fechas para un año
fechas_2023 <- seq(ymd("2023-01-01"), ymd("2023-12-31"), by = "day")

# Encontrar todos los lunes
lunes_2023 <- fechas_2023[wday(fechas_2023) == 2]

# Encontrar el primer día de cada mes
primeros_mes <- fechas_2023[day(fechas_2023) == 1]

# Encontrar el último día de cada mes
ultimos_mes <- ceiling_date(fechas_2023, "month") - days(1)
ultimos_mes <- unique(ultimos_mes)

Los cálculos e intervalos temporales son herramientas fundamentales para el análisis de datos con componente temporal, permitiéndonos responder preguntas sobre duraciones, frecuencias y patrones a lo largo del tiempo de manera eficiente y precisa.