Julia Date et heure

Julia fournit les trois fonctions suivantes pour gérer les dates et les heures via le module Dates :

  • Date: indique une date, précise au jour près, et n'affiche que la date.
  • DateTime: indique la date et l'heure, précises à la milliseconde près.
  • DateTime: indique l'heure du jour, précise à la nanoseconde près, représentant un moment spécifique dans les 24 heures d'une journée.

Avant de l'utiliser, nous devons d'abord importer le module Dates :

import Dates

Les types Date et DateTime peuvent être analysés à partir d'entiers ou de types Period.

Period est basé sur des valeurs de date et représente les années, les mois, les jours, etc. :

Period
Year
Quarter
Month
Week
Day
Hour
Minute
Second
Millisecond
Microsecond
Nanosecond

Date et DateTime sont tous les deux des sous-types du type abstrait TimeType.

Le diagramme suivant montre la relation entre les types de date ; cliquez sur l’image pour l’agrandir :

Afficher la date et l’heure :

Exemple

julia> import Dates

julia> rightnow = Dates.Time(Dates.now()) # Time
08:41:15.917

julia> theday = Dates.Date(2022,5,6) # Date
2022-05-06

julia> today_date = Dates.today()
2022-05-11

julia> Dates.now(Dates.UTC)
2022-05-11T00:44:20.136

# Format de l'heure
julia> Dates.DateTime("20220429 120000", "yyyymmdd HHMMSS")
2022-04-29T12:00:00


julia> Dates.DateTime("19/04/2022 17:42", "dd/mm/yyyy HH:MM")
2022-04-19T17:42:00

Le tableau suivant donne les codes de format de date, grâce auxquels nous pouvons formater nos dates :

Caractère Élément de date/heure
Y Représente l'année, par ex. : yyyy => 1984, yy => 84
m Représente le mois, par ex. : m => 7 ou 07
u Représente le nom abrégé du mois, par ex. : Jun
U Représente le nom complet du mois, par ex. : January
e Représente le jour abrégé de la semaine, par ex. : Mon
E Représente le jour complet de la semaine, par ex. : Monday
d Représente le jour, par ex. : 1 ou 01
H Représente l'heure, par ex. : HH => 00
M Représente la minute, par ex. : MM => 00
S Représente la seconde, par ex. : S => 00
s Représente la milliseconde, par exemple : .000

Exemple

julia> Dates.Date("Sun, 27 Sep 2022", "e, d u y")
2022-09-27

julia> Dates.DateTime("Sun, 27 Sep 2022 10:25:10", "e, d u y H:M:S")
2022-09-27T10:25:10

À travers les exemples ci-dessus, nous avons créé des objets date/heure. Ensuite, nous pouvons utiliser ces objets pour obtenir des données (y compris l'année, le mois, le jour, la minute, la seconde, l'heure, etc.) :

Exemple

julia> theday = Dates.Date(2022,5,6) # Créer un objet date
2022-05-06

# Ensuite, récupérez les données dans theday
julia> Dates.year(theday)
2022

julia> Dates.month(theday)
5

# Récupérer les données de l'heure actuelle
julia> rightnow = Dates.now()
2022-05-11T08:51:45.342

julia> Dates.minute(rightnow)
51

julia> Dates.hour(rightnow)
8

julia> Dates.second(rightnow)
45

# Obtenir le mois et le jour de la semaine
julia> Dates.dayofweek(theday)
5

julia> Dates.dayname(theday)
"Friday"

julia> Dates.yearmonthday(theday)
(2022, 5, 6)

julia> Dates.dayofweekofmonth(theday)
1

Arithmétique des dates

Nous pouvons effectuer des opérations arithmétiques sur des objets de date.

Par exemple, nous calculons le nombre de jours entre deux dates :

Exemple

julia> day1 = Dates.Date(2022,1,17)
2022-01-17

julia> day2 = Dates.Date(2022,3,23)
2022-03-23

julia> day2 - day1
65 jours

# Utiliser différentes unités de temps
julia> Dates.canonicalize(Dates.CompoundPeriod(day2 - day1))
9 semaines, 2 jours

Nous pouvons également ajouter aux dates, par exemple, calculer la date après 2 ans et 6 mois :

Exemple

julia> rightnow = Dates.now()
2022-05-11T09:01:07.946

julia> rightnow + Dates.Year(20) + Dates.Month(6)
2042-11-11T09:01:07.946

# Date après 6 jours
julia> rightnow + Dates.Day(6)
2022-05-17T09:01:07.946

Plages de dates

Julia peut créer des dates pour un intervalle spécifié à l'aide d'objets de plage itérables. Dans l'exemple donné ci-dessous, nous allons créer un itérateur qui génère le premier jour de chaque mois.

Exemple

date_range = Dates.Date(2011,1,1):Dates.Month(1):Dates.Date(2022,1,1)
Dates.Date("2011-01-01"):Dates.Month(1):Dates.Date("2022-01-01")

Dans l'objet range ci-dessus, nous pouvons trouver lesquels sont des jours de la semaine. Ici, nous devons créer une fonction anonyme pour filter() qui détermine s'il s'agit d'un jour de la semaine en fonction de la date donnée :

Exemple

julia> weekdaysfromrange = filter(dy -> Dates.dayname(dy) != "Saturday" && Dates.dayname(dy) != "Sunday" , date_range)
94-element Vector{Dates.Date}:
 2011-02-01
 2011-03-01
 2011-04-01
 2011-06-01
 2011-07-01
 2011-08-01
 2011-09-01
 2011-11-01
 2011-12-01
 2012-02-01
 ⋮
 2021-02-01
 2021-03-01
 2021-04-01
 2021-06-01
 2021-07-01
 2021-09-01
 2021-10-01
 2021-11-01
 2021-12-01

Arrondir les dates et les heures

Nous utilisons souvent les fonctions round(), floor() et ceil() pour arrondir des paramètres vers le haut ou vers le bas. De même, ces fonctions peuvent également être utilisées pour arrondir des dates, afin de décaler les dates vers l'avant ou vers l'arrière dans le temps.

Exemple

julia> Dates.now()
2022-05-11T09:17:49.824

julia> Dates.format(round(Dates.DateTime(Dates.now()), Dates.Minute(15)), Dates.RFC1123Format)
"Wed, 11 May 2022 09:15:00"

ceil()La fonction ajustera la date/l'heure vers l'avant, comme indiqué ci-dessous :

Exemple

julia> theday = Dates.Date(2022,5,6)
2022-05-06

# Mois suivant
julia> ceil(theday, Dates.Month)
2022-06-01

# Année suivante
julia> ceil(theday, Dates.Year)
2023-01-01

# Semaine suivante
julia> ceil(theday, Dates.Week)
2022-05-09

Dates récurrentes

Nous pouvons trouver des dates récurrentes dans un intervalle, par exemple, tous les dimanches :

Exemple

# Créer une plage de dates
julia> date_range = Dates.Date(2011,1,1):Dates.Month(1):Dates.Date(2022,1,1)
Dates.Date("2011-01-01"):Dates.Month(1):Dates.Date("2022-01-01")
# Utiliser la fonction filter() pour exclure tous les dimanches
julia> filter(d -> Dates.dayname(d) == "Sunday", date_range)
20-element Vector{Dates.Date}:
 2011-05-01
 2012-01-01
 2012-04-01
 2012-07-01
 2013-09-01
 2013-12-01
 2014-06-01
 2015-02-01
 2015-03-01
 2015-11-01
 2016-05-01
 2017-01-01
 2017-10-01
 2018-04-01
 2018-07-01
 2019-09-01
 2019-12-01
 2020-03-01
 2020-11-01
 2021-08-01
Temps Unix

Le temps UNIX, ou temps POSIX, est une représentation du temps utilisée par les systèmes UNIX ou de type UNIX : le nombre total de secondes écoulées depuis 0:00:00 le 1er janvier 1970 UTC jusqu'à maintenant, en ignorant les secondes intercalaires.

La fonction time() renvoie la valeur Unix :

Exemple

julia> time()
1.652232489777e9

La fonction unix2datetime() convertit le temps Unix en un objet date/heure :

Exemple

julia> Dates.unix2datetime(time())
2022-05-11T01:28:23.493

Heure actuelle

Les DateTimes sont mesurés en millisecondes ; nous pouvons utiliser la fonction Dates.value pour obtenir le temps en millisecondes :

Exemple

julia> moment=Dates.now()
2022-05-11T09:31:31.037

julia> Dates.value(moment)
63787944691037

julia> moment.instant
Dates.UTInstant{Millisecond}(Millisecond(63787944691037))

Temps et surveillance

Julia nous fournit la macro@elapsed, qui renvoie le temps (en secondes) nécessaire pour exécuter une expression.

Calculez le temps nécessaire pour exécuter le code suivant :

Exemple

julia> function foo(n)
         for i in 1:n
           x = sin(rand())
         end
       end
foo (fonction générique avec 1 méthode)


julia> @elapsed foo(100000000)
1.360567967

julia> @time foo(100000000)
  1.363258 seconds

Plus d’exemples

Exemple

julia> DateTime(2013)
2013-01-01T00:00:00

julia> DateTime(2013,7)
2013-07-01T00:00:00

julia> DateTime(2013,7,1)
2013-07-01T00:00:00

julia> DateTime(2013,7,1,12)
2013-07-01T12:00:00

julia> DateTime(2013,7,1,12,30)
2013-07-01T12:30:00

julia> DateTime(2013,7,1,12,30,59)
2013-07-01T12:30:59

julia> DateTime(2013,7,1,12,30,59,1)
2013-07-01T12:30:59.001

julia> Date(2013)
2013-01-01

julia> Date(2013,7)
2013-07-01

julia> Date(2013,7,1)
2013-07-01

julia> Date(Dates.Year(2013),Dates.Month(7),Dates.Day(1))
2013-07-01

julia> Date(Dates.Month(7),Dates.Année(2013))
2013-07-01
Autres extensions