Introdução ao pacote TidierDates.jl

Manipulação de Dados
Datas e Horas
Pacotes
Tidy

Um guia introdutório sobre o pacote TidierDates.jl! Aprenda a manipular datas e horários em Julia com uma gramática inspirada no lubridate (R), integrada ao ecossistema Tidier.jl.

Autores
Afiliação

Henrique Anunciação Velloso Silva

Universidade Estadual de Campinas

Esther Cleveston

Universidade Estadual de Campinas

Data de Publicação

26 de março de 2026

Introdução

O TidierDates.jl é um pacote da linguagem Julia, integrante da biblioteca Tidier.jl, que fornece funções no estilo tidyverse para lidar com datas e tempos.

Ele facilita operações comuns como extração de componentes de datas (ano, mês, dia, hora, etc.), operações com períodos, criação de sequências temporais e muito mais.

Inspirado na sintaxe do R (lubridate + dplyr), o pacote torna a manipulação de datas clara, expressiva e consistente.

Além disso, este pacote foi projetado para funcionar com o TidierData.jl, mas também pode funcionar de forma independente. Caso ainda não saiba como usar o pacote TidierData.jl, clique aqui para acessar o nosso blog!

Carregando pacotes

using DataFrames
using Dates
using TidierData
using TidierDates

Criando datas

O TidierDates.jl oferece funções que reconhecem diferentes formatos de datas em texto e os convertem para objetos Date ou DateTime. São extremamente flexíveis, aceitando formatos mistos como "4th of July, 2005" ou "08092019".

df = DataFrame(Texto = ["01-02-2020"])
1×1 DataFrame
 Row │ Texto
     │ String
─────┼────────────
   1 │ 01-02-2020

@chain df begin
    @mutate(
        Data1 = dmy("01-02-2020"),    # dia-mês-ano
        Data2 = mdy("July 4, 2005"),  # mês-dia-ano
        Data3 = ymd("2019/08/09")     # ano-mês-dia
    )
end
1×4 DataFrame
 Row │ Texto       Data1       Data2       Data3
     │ String      Date        Date        Date
─────┼────────────────────────────────────────────────
   1 │ 01-02-2020  2020-02-01  2005-07-04  2019-08-09
df
1×1 DataFrame
 Row │ Texto
     │ String
─────┼────────────
   1 │ 01-02-2020

Nesse exemplo, utilizamos as funções dmy(), mdy() e ymd() do pacote TidierDates.jl para converter strings de datas em objetos Date do Julia, seguindo diferentes ordens de componentes:

  • dmy(Texto) → interpreta a string como dia-mês-ano (ex.: "01-02-2020" vira 1 de fevereiro de 2020);
  • mdy("July 4, 2005") → interpreta como mês-dia-ano (ex.: "July 4, 2005" vira 4 de julho de 2005);
  • ymd("2019-08-09") → interpreta como ano-mês-dia (ex.: "2019-08-09" vira 9 de agosto de 2019).

O uso dessas funções garante que datas escritas em diferentes formatos sejam convertidas em objetos Date, permitindo, posteriormente, cálculos e manipulações, caso necessário.

Incluindo hora, minuto e segundo

df_horas = DataFrame(Evento = ["A", "B"],
                     Texto = ["2023-03-15 10:45:32", "15/04/2024 22:10:05"])
2×2 DataFrame
 Row │ Evento  Texto
     │ String  String
─────┼─────────────────────────────
   1 │ A       2023-03-15 10:45:32
   2 │ B       15/04/2024 22:10:05

@chain df_horas begin
    @mutate(
        DataHora1 = ymd_hms("2023-03-15 10:45:32"),
        DataHora2 = dmy_hms("15/04/2024 22:10:05")
    )
end
2×4 DataFrame
 Row │ Evento  Texto                DataHora1            DataHora2
     │ String  String               DateTime             DateTime
─────┼───────────────────────────────────────────────────────────────────────
   1 │ A       2023-03-15 10:45:32  2023-03-15T10:45:32  2024-04-15T22:10:05
   2 │ B       15/04/2024 22:10:05  2023-03-15T10:45:32  2024-04-15T22:10:05

Aqui usamos as funções *_hms() (ymd_hms, dmy_hms, mdy_hms) para converter strings em objetos DateTime, incluindo hora, minuto e segundo.

Arredondamento de datas

df2 = DataFrame(DataHora = [DateTime("2023-03-15T10:45:32"),
                            DateTime("2023-03-15T22:17:05")]);

df2 = @chain df2 begin
    @mutate(
        Aprox_Hora = floor_date(DataHora, "hour"),
        Aprox_Dia = floor_date(DataHora, "day"),
        Arredonda_5min = round.(DataHora, Minute(5)),
    )
end
2×4 DataFrame
 Row │ DataHora             Aprox_Hora           Aprox_Dia            Arredond ⋯
     │ DateTime             DateTime             DateTime             DateTime ⋯
─────┼──────────────────────────────────────────────────────────────────────────
   1 │ 2023-03-15T10:45:32  2023-03-15T10:00:00  2023-03-15T00:00:00  2023-03- ⋯
   2 │ 2023-03-15T22:17:05  2023-03-15T22:00:00  2023-03-15T00:00:00  2023-03-
                                                                1 column omitted

  • floor_date() → arredonda para baixo (ex.: hora cheia, dia, mês);

  • round_date() → arredonda para o mais próximo múltiplo de tempo (ex.: 5 minutos, 1 hora, etc.).

Diferença entre datas

df3 = DataFrame(
    Inicio = [Date("2023-01-01"), Date("2023-05-15")],
    Fim    = [Date("2023-01-20"), Date("2023-06-01")]
)
2×2 DataFrame
 Row │ Inicio      Fim
     │ Date        Date
─────┼────────────────────────
   1 │ 2023-01-01  2023-01-20
   2 │ 2023-05-15  2023-06-01

@chain df3 begin
    @mutate(
        Diferenca = Fim - Inicio
    )
end
2×3 DataFrame
 Row │ Inicio      Fim         Diferenca
     │ Date        Date        Day
─────┼───────────────────────────────────
   1 │ 2023-01-01  2023-01-20  19 days
   2 │ 2023-05-15  2023-06-01  17 days

A subtração direta entre objetos Date retorna um número de dias (Day). O TidierDates.jl também disponibiliza funções auxiliares como difftime() para cálculos mais explícitos de diferenças em segundos, minutos, horas ou dias.

Ini = Dates.now()
2026-03-26T08:57:26.895
sleep(5)
Fim = Dates.now()
2026-03-26T08:57:32.034
difftime(Fim, Ini, "seconds")
5.139

Manipulando apenas tempo (h:m:s)

df4 = DataFrame(Horario = ["10:15:30", "23:59:59"])
2×1 DataFrame
 Row │ Horario
     │ String
─────┼──────────
   1 │ 10:15:30
   2 │ 23:59:59

@chain df4 begin
    @mutate(
        Tempo = hms(Horario)
    )
end
2×2 DataFrame
 Row │ Horario   Tempo
     │ String    Time
─────┼────────────────────
   1 │ 10:15:30  10:15:30
   2 │ 23:59:59  23:59:59

A função hms() converte strings de horários em objetos de tempo (hora, minuto, segundo), úteis em análises de logs ou séries temporais com granularidade horária.

Considerações finais

O TidierDates.jl é um pacote essencial para trabalhar com datas e horários em Julia.

Com ele, é possível:

  • Converter strings em datas/horas (ymd, dmy_hms, etc.);

  • Arredondar datas para diferentes granularidades (floor_date, round_date);

  • Calcular diferenças entre datas (difftime, operadores diretos);

  • Trabalhar diretamente com horários (hms).

Tudo isso de forma simples e legível.

Referências

Blog inspirado na documentação disponibilizada pelos autores do pacote, a qual pode ser acessada pelo link https://tidierorg.github.io/TidierDates.jl/dev/.

Nota

Ferramentas de IA foram utilizadas para correção ortográfica e aprimoramento do texto.