Discussion :

[tyrtamos]

Cas calculs sont importants pour les entreprises (planification de la production) et pour les particuliers (planification des vacances), mais aussi plus généralement pour la vie sociale.

En ce qui concerne les fêtes catholiques: l'aspect religieux concerne bien sûr les catholiques, mais il ne faut pas limiter ces fêtes à la religion, au moins pour deux raisons:

- historiquement, les fêtes ont été surtout placées proches des fêtes païennes existantes pour être plus facilement acceptées par la population. Par exemple:
Saint Jean: solstice d'été proche du 21 juin
Noël: solstice d'hiver proche du 21 décembre
etc...

- actuellement, certaines fêtes ont pour beaucoup des significations non-religieuses. Par exemple:
Épiphanie: la galette des rois
Chandeleur: les crêpes
Mardi gras: le carnaval
Saint Nicolas et Noël: fête des enfants (et ni le père Noël ni le sapin de Noël ne se trouvent dans la bible)
etc...

A noter que les fêtes religieuses, pour les principales religions en France peuvent être trouvées facilement sur le net. Par exemple ici:
https://icalendrier.fr/religion/

Les jours fériés France se trouvent aussi facilement sur le net. Par exemple:
https://icalendrier.fr/feries/

Calcul de la date de Pâques

J'ai utilisé l'algorithme de Hodges qu'on peut trouver ici:
http://dates.gmarts.org/eastalg.htm#EasterHodges

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
###############################################################################
def datepaques(an):
    """Calcule la date de Pâques d'une année donnée 'an' (=nombre entier)
       (méthode de Hodges)
    """
    a = an//100
    b = an%100
    c = (3*(a+25))//4
    d = (3*(a+25))%4
    e = (8*(a+11))//25
    f = (5*a+b)%19
    g = (19*f+c-e)%30
    h = (f+11*g)//319
    j = (60*(5-d)+b)//4
    k = (60*(5-d)+b)%4
    m = (2*j-k-g+h)%7
    n = (g-h+m+114)//31
    p = (g-h+m+114)%31
    jour = p+1
    mois = n
    return jour, mois, an

Exemples de résultats:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
print(datepaques(2023))
(9, 4, 2023)
print(datepaques(2024))
(31, 3, 2024)
print(datepaques(2025))
(20, 4, 2025)

Fonctions de calcul de dates

Pour rendre les calculs plus faciles, on va se donner plusieurs fonctions en Python pour mieux manipuler les dates.

Grâce à l'excellent module Python "datetime", ces fonctions sont en même temps concises et puissantes. Et on peut les utiliser pour beaucoup d'autres calculs de dates que celles prises en compte ici.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
from datetime import date, timedelta
 
joursem = {0:"lundi", 1:"mardi", 2:"mercredi", 3:"jeudi", 4:"vendredi",
           5:"samedi", 6:"dimanche"}
 
###############################################################################
def datedelta(jour, mois, an, delta=1):
    """Retourne la date qui suit ou précède de 'delta' jour(s) la date donnée
    """
    dt = date(an, mois, jour) + timedelta(delta)
    return dt.day, dt.month, dt.year
 
###############################################################################
def datesem(jour, mois, an):
    """Retourne le jour de la semaine de la date donnée
       lundi=0, ..., dimanche=6
    """
    return date(an, mois, jour).weekday()
 
###############################################################################
def datelundi(jour, mois, an):
    """Retourne la date du lundi de la semaine du jour donné
    """
    dt = date(an, mois, jour)
    return datedelta(jour, mois, an, -dt.weekday())
 
###############################################################################
def datenbjours(jour1, mois1, an1, jour2, mois2, an2):
    """Retourne le nombre de jours entre les 2 dates données
    """
    dt1 = date(an1, mois1, jour1)
    dt2 = date(an2, mois2, jour2)
    return (dt2-dt1).days
 
###############################################################################
def datechaine(jour, mois, an, sep="/", iso=False):
    """Retourne la chaine "jj/mm/aaaa" pour la date donnée avec le séparateur "sep"
       - jour, mois, an: en entiers
       - sep: séparateur ("/" par défaut)
       - iso: si True, retourne la chaine à l'envers "aaaa/mm/jj" (avantage: tri alphanumérique == tri chronologique)
    """
    if iso:
        return sep.join(["{:4d}", "{:02d}", "{:02d}"]).format(an, mois, jour)
    else:
        return sep.join(["{:02d}", "{:02d}", "{:4d}"]).format(jour, mois, an)

Principales dates catholiques et fériées

Voilà un petit code d'exemples pour calculer et afficher les dates en question:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
###############################################################################
if __name__ == '__main__':
 
    # Année choisie pour l'exemple
    an = 2023
 
    # jour de l'an
    js = datesem(1, 1, an)
    print("jour de l'an:", joursem[js], datechaine(1,1,an))
 
    # Epiphanie
    js = datesem(6, 1, an)
    print("epiphanie:", joursem[js], datechaine(6,1,an))
 
    # Chandeleur
    js = datesem(2, 2, an)
    print("chandeleur:", joursem[js], datechaine(2,2,an))
 
    # mardi gras
    jp, mp, ap = datepaques(an)
    j, m, a = datedelta(jp, mp, ap, -47)
    print("mardi gras:", "mardi", datechaine(j, m, a))
 
    # vendredi saint (jour férié en Alsace)
    jp, mp, ap = datepaques(an)
    j, m, a = datedelta(jp, mp, ap, -2)
    print("vendredi saint (férié en Alsace):", "vendredi", datechaine(j, m, a))
 
    # Pâques
    jp, mp, ap = datepaques(an)
    print("Pâques:", "dimanche", datechaine(jp, mp, ap))
 
    # lundi de Pâques
    jp, mp, ap = datepaques(an)
    j, m, a = datedelta(jp, mp, ap, 1)
    print("lundi de Pâques:", "lundi", datechaine(j, m, a))
 
    # fête du travail (1er mai)
    js = datesem(1, 5, an)
    print("fête du travail:", joursem[js], datechaine(1,5,an))
 
    # victoire des allies 1945 (8/5)
    js = datesem(8, 5, an)
    print("victoire des allies 1945:", joursem[js], datechaine(8,5,an))
 
    # Ascension
    jp, mp, ap = datepaques(an)
    j, m, a = datedelta(jp, mp, ap, 39)
    print("Ascension:", "jeudi", datechaine(j, m, a))
 
    # Pentecôte
    jp, mp, ap = datepaques(an)
    j, m, a = datedelta(jp, mp, ap, 49)
    print("Pentecôte:", "dimanche", datechaine(j, m, a))
 
    # lundi de la Pentecôte
    jp, mp, ap = datepaques(an)
    j, m, a = datedelta(jp, mp, ap, 50)
    print("lundi de la Pentecôte:", "lundi", datechaine(j, m, a))
 
    # Saint Jean (proche du 21/6 solstice d'été)
    js = datesem(24, 6, an)
    print("Saint Jean:", joursem[js], datechaine(24, 6, an))
 
    # fête nationale France
    js = datesem(14, 7, an)
    print("fête nationale France:", joursem[js], datechaine(14, 7, an))
 
    # Assomption
    js = datesem(15, 8, an)
    print("Assomption:", joursem[js], datechaine(15, 8, an))
 
    # Toussaint
    js = datesem(1, 11, an)
    print("Toussaint:", joursem[js], datechaine(1, 11, an))
 
    # Fête des morts
    js = datesem(2, 11, an)
    print("Fête des morts:", joursem[js], datechaine(2, 11, an))
 
    # Armistice 1918
    js = datesem(11, 11, an)
    print("Armistice 1918:", joursem[js], datechaine(11, 11, an))
 
    # Saint Nicolas
    js = datesem(6, 12, an)
    print("Saint Nicolas:", joursem[js], datechaine(6, 12, an))
 
    # Noël (proche du 21/12 solstice d'hiver)
    js = datesem(25, 12, an)
    print("Noël:", joursem[js], datechaine(25, 12, an))
 
    # Saint Etienne (férié en Alsace)
    js = datesem(26, 12, an)
    print("Saint Etienne (férié en Alsace):", joursem[js], datechaine(26, 12, an))

Ce qui affichera pour l'année 2023:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
jour de l'an: dimanche 01/01/2023
épiphanie: vendredi 06/01/2023
chandeleur: jeudi 02/02/2023
mardi gras: mardi 21/02/2023
vendredi saint (férié en Alsace): vendredi 07/04/2023
Pâques: dimanche 09/04/2023
lundi de Pâques: lundi 10/04/2023
fête du travail: lundi 01/05/2023
victoire des allies 1945: lundi 08/05/2023
Ascension: jeudi 18/05/2023
Pentecôte: dimanche 28/05/2023
lundi de la Pentecôte: lundi 29/05/2023
Saint Jean: samedi 24/06/2023
fête nationale France: vendredi 14/07/2023
Assomption: mardi 15/08/2023
Toussaint: mercredi 01/11/2023
Fête des morts: jeudi 02/11/2023
Armistice 1918: samedi 11/11/2023
Saint Nicolas: mercredi 06/12/2023
Noël: lundi 25/12/2023
Saint Étienne (férié en Alsace): mardi 26/12/2023

Et voilà le code complet:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
from datetime import date, timedelta
 
joursem = {0:"lundi", 1:"mardi", 2:"mercredi", 3:"jeudi", 4:"vendredi",
           5:"samedi", 6:"dimanche"}
 
###############################################################################
def datepaques(an):
    """Calcule la date de Pâques d'une année donnée 'an' (=nombre entier)
       (méthode de Hodges)
    """
    a = an//100
    b = an%100
    c = (3*(a+25))//4
    d = (3*(a+25))%4
    e = (8*(a+11))//25
    f = (5*a+b)%19
    g = (19*f+c-e)%30
    h = (f+11*g)//319
    j = (60*(5-d)+b)//4
    k = (60*(5-d)+b)%4
    m = (2*j-k-g+h)%7
    n = (g-h+m+114)//31
    p = (g-h+m+114)%31
    jour = p+1
    mois = n
    return jour, mois, an
 
###############################################################################
def datedelta(jour, mois, an, delta=1):
    """Retourne la date qui suit ou précède de 'delta' jour(s) la date donnée
    """
    dt = date(an, mois, jour) + timedelta(delta)
    return dt.day, dt.month, dt.year
 
###############################################################################
def datesem(jour, mois, an):
    """Retourne le jour de la semaine de la date donnée
       lundi=0, ..., dimanche=6
    """
    return date(an, mois, jour).weekday()
 
###############################################################################
def datelundi(jour, mois, an):
    """Retourne la date du lundi de la semaine du jour donné
    """
    dt = date(an, mois, jour)
    return datedelta(jour, mois, an, -dt.weekday())
 
###############################################################################
def datenbjours(jour1, mois1, an1, jour2, mois2, an2):
    """Retourne le nombre de jours entre les 2 dates données
    """
    dt1 = date(an1, mois1, jour1)
    dt2 = date(an2, mois2, jour2)
    return (dt2-dt1).days
 
###############################################################################
def datechaine(jour, mois, an, sep="/", iso=False):
    """Retourne la chaine "jj/mm/aaaa" pour la date donnée avec le séparateur "sep"
       - jour, mois, an: en entiers
       - sep: séparateur ("/" par défaut)
       - iso: si True, retourne la chaine à l'envers "aaaa/mm/jj" (avantage: tri alphanumérique == tri chronologique)
    """
    if iso:
        return sep.join(["{:4d}", "{:02d}", "{:02d}"]).format(an, mois, jour)
    else:
        return sep.join(["{:02d}", "{:02d}", "{:4d}"]).format(jour, mois, an)
 
###############################################################################
if __name__ == '__main__':
 
    # Année choisie pour l'exemple
    an = 2023
 
    # jour de l'an
    js = datesem(1, 1, an)
    print("jour de l'an:", joursem[js], datechaine(1,1,an))
 
    # Epiphanie
    js = datesem(6, 1, an)
    print("epiphanie:", joursem[js], datechaine(6,1,an))
 
    # Chandeleur
    js = datesem(2, 2, an)
    print("chandeleur:", joursem[js], datechaine(2,2,an))
 
    # mardi gras
    jp, mp, ap = datepaques(an)
    j, m, a = datedelta(jp, mp, ap, -47)
    print("mardi gras:", "mardi", datechaine(j, m, a))
 
    # vendredi saint (jour férié en Alsace)
    jp, mp, ap = datepaques(an)
    j, m, a = datedelta(jp, mp, ap, -2)
    print("vendredi saint (férié en Alsace):", "vendredi", datechaine(j, m, a))
 
    # Pâques
    jp, mp, ap = datepaques(an)
    print("Pâques:", "dimanche", datechaine(jp, mp, ap))
 
    # lundi de Pâques
    jp, mp, ap = datepaques(an)
    j, m, a = datedelta(jp, mp, ap, 1)
    print("lundi de Pâques:", "lundi", datechaine(j, m, a))
 
    # fête du travail (1er mai)
    js = datesem(1, 5, an)
    print("fête du travail:", joursem[js], datechaine(1,5,an))
 
    # victoire des allies 1945 (8/5)
    js = datesem(8, 5, an)
    print("victoire des allies 1945:", joursem[js], datechaine(8,5,an))
 
    # Ascension
    jp, mp, ap = datepaques(an)
    j, m, a = datedelta(jp, mp, ap, 39)
    print("Ascension:", "jeudi", datechaine(j, m, a))
 
    # Pentecôte
    jp, mp, ap = datepaques(an)
    j, m, a = datedelta(jp, mp, ap, 49)
    print("Pentecôte:", "dimanche", datechaine(j, m, a))
 
    # lundi de la Pentecôte
    jp, mp, ap = datepaques(an)
    j, m, a = datedelta(jp, mp, ap, 50)
    print("lundi de la Pentecôte:", "lundi", datechaine(j, m, a))
 
    # Saint Jean (proche du 21/6 solstice d'été)
    js = datesem(24, 6, an)
    print("Saint Jean:", joursem[js], datechaine(24, 6, an))
 
    # fête nationale France
    js = datesem(14, 7, an)
    print("fête nationale France:", joursem[js], datechaine(14, 7, an))
 
    # Assomption
    js = datesem(15, 8, an)
    print("Assomption:", joursem[js], datechaine(15, 8, an))
 
    # Toussaint
    js = datesem(1, 11, an)
    print("Toussaint:", joursem[js], datechaine(1, 11, an))
 
    # Fête des morts
    js = datesem(2, 11, an)
    print("Fête des morts:", joursem[js], datechaine(2, 11, an))
 
    # Armistice 1918
    js = datesem(11, 11, an)
    print("Armistice 1918:", joursem[js], datechaine(11, 11, an))
 
    # Saint Nicolas
    js = datesem(6, 12, an)
    print("Saint Nicolas:", joursem[js], datechaine(6, 12, an))
 
    # Noël (proche du 21/12 solstice d'hiver)
    js = datesem(25, 12, an)
    print("Noël:", joursem[js], datechaine(25, 12, an))
 
    # Saint Etienne (férié en Alsace)
    js = datesem(26, 12, an)
    print("Saint Etienne (férié en Alsace):", joursem[js], datechaine(26, 12, an))

Bonnes fêtes!

[papajoker]

bonjour

Merci pour le code.

J'ai du mal à comprendre la logique pour les dates calculées depuis pâques...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

j, m, a = datedelta(jp, mp, ap, -47)

Exemple pris au hasard ! Ici, tu injectes des constantes qui sortent de ? Et pour une année bissextile ou non, le même écart va exister ?

J'ai donc l'impression que les dates ne vont pas êtres obligatoirement bonnes quelle que soit l'année (sauf pâques et celles non calculées)

Note:
Vu: "datelundi()" dans le code mais non utilisé. Et justement, à chaque fois que l'on utilise datedelta() c'est pour calculer un jour de semaine (donc ma première idée c'est de lui passer ce jour de semaine en plus et si pas bon jour, inc? ou dec? jusqu'au bon jour. Ou au moins vérifier que l'on retourne le bon jour de la semaine)


-----------

beaucoup moins d'intérêt ici, pour la partie main, je suis plus adepte d'une boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    jours = {
        "jour de l'an": {"date": (1, 1)},
        "epiphanie": {"date": (6, 1)},
        "chandeleur": {"date": (2, 2)},
        "mardi gras": {"offset": -47, "jour": "mardi"},
        "Pentecôte": {"offset": 49, "jour": "dimanche"},
    }
 
    for jour, data in jours.items():
        if offset := data.get('offset'):
            jp, mp, ap = datepaques(an)
            j, m, a = datedelta(jp, mp, ap, offset)  # plus sympa si fonction retourne en plus le jour de semaine, évite de le mettre dans les constantes
            print(jour, data.get('jour'), datechaine(j, m, a))
        else:
            js = datesem(data['date'][0], data['date'][1], an)
            print(jour, joursem[js], datechaine(data['date'][0],data['date'][1],an))

[tyrtamos]

Bonjour

bonjour

J'ai du mal à comprendre la logique pour les dates calculées depuis pâques...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

j, m, a = datedelta(jp, mp, ap, -47)

Exemple pris au hasard ! Ici, tu injectes des constantes qui sortent de ? Et pour une année bissextile ou non, le même écart va exister ?

J'ai donc l'impression que les dates ne vont pas êtres obligatoirement bonnes quelle que soit l'année (sauf pâques et celles non calculées)

Je n'ai rien inventé! Certaines dates de fêtes religieuses sont liées à la date de Pâques, et pour le Mardi Gras, c'est ici:
https://icalendrier.fr/religion/fete...es/mardi-gras/

Ces écarts sont les mêmes que l'année soit bissextile ou pas. Par ailleurs, j'aurais été étonné, et même choqué, que le module Python datetime ne tienne pas compte des années bissextiles! Tu aurais pu aussi vérifier que la date du Mardi gras calculée pour 2024, année bissextile, correspond bien à celle du site web.

"datelundi()" dans le code mais non utilisé.

C'est une fonction "bonus"! J'aurais pu en mettre d'autres, très utiles, sans être utilisées ici.

Et justement, à chaque fois que l'on utilise datedelta() c'est pour calculer un jour de semaine

Là, je ne comprends pas. Datedelta permet de calculer une date postérieure ou antérieure à une date donnée. Voir le docstring:

Retourne la date qui suit ou précède de 'delta' jour(s) la date donnée

[papajoker]

Ces écarts sont les mêmes que l'année soit bissextile ou pas.

C'est justement cela ma question, moi je ne comprenais pas ! une histoire d'algo simplement.

choqué, que le module Python datetime ne tienne pas compte des années bissextiles!

Non
En fait c'est mon raisonnement qui était faux ! je n'ai jamais mis en doute datetime ou datedelta.
pâques est toujours un dimanche, donc si inc ou dec de 7, je tombe toujours sur un dimanche (année bissextile ou pas, il n'y a pas 8 jours par semaine)
Ces valeurs d'incrémentations fonctionnent/sont calculées de cette manière (cela n'a pas fait bip dans ma tête). pour un lundi , on incrémente de 1 jour, puis on incrémente ou décrémente de X semaines.

Et justement, à chaque fois que l'on utilise datedelta() c'est pour calculer un jour de semaine

Là, je ne comprends pas. Datedelta permet de calculer une date postérieure ou antérieure à une date donnée. Voir le docstring:

je disais juste que ta datedelta() est utilisé uniquement lorsque l'on a justement un jour à rechercher (Les autres fêtes, tu ne fais pas ce calcul), d'ou l'intérêt de lui passer ce jour de semaine en paramètre et/ou de l'avoir en retour. (voir mon code plus bas)

Tu aurais pu aussi vérifier que la date du Mardi gras calculée pour 2024, année bissextile, correspond bien à celle du site web.

j'ai fait une petite modif pour tester que le jour de la semaine soit bon (aucune Exception)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
def datedelta(jour, mois, an, delta=1, jour_semaine="lundi"):
    """Retourne la date qui suit ou précède de 'delta' jour(s) la date donnée
    """
    dt = date(an, mois, jour) + timedelta(delta)
    le_jour = joursem[dt.weekday()]
    if le_jour != jour_semaine:
        raise Exception(f"pas trouvé le bon jour {jour_semaine} mais : {le_jour}")
    return dt.day, dt.month, dt.year, le_jour
 
if __name__ == '__main__':
 
    # "jour" est inutile puisque retourné par datedelta() et ici que pour tests
    jours = {
        #"chandeleur": {"date": (2, 2)},
        "mardi gras": {"offset": -47, "jour": "mardi"},
        "lundi de Pâques": {"offset": 1, "jour": "lundi"},
        "Ascension": {"offset": 39, "jour": "jeudi"},
        "Pentecôte": {"offset": 49, "jour": "dimanche"},
        "lundi de la Pentecôte": {"offset": 50, "jour": "lundi"},
    }
 
    for an in range(2023,2040):
        print("-"*36)
        print(an)
        for jour, data in jours.items():
            if offset := data.get('offset'):
                jp, mp, ap = datepaques(an)
                j, m, a, jour_semaine = datedelta(jp, mp, ap, offset, data.get('jour'))
                print(jour, data.get('jour'), '/', jour_semaine, datechaine(j, m, a))
            else:
                js = datesem(data['date'][0], data['date'][1], an)
                print(jour, joursem[js], datechaine(data['date'][0],data['date'][1],an))
        print("-"*36)

[tyrtamos]

Bonjour

j'ai fait une petite modif pour tester que le jour de la semaine soit bon (aucune Exception)

On peut toujours modifier les codes pour les adapter aux problèmes qu'on a, mais je ne suis pas fana de celle proposée. A chaque fois qu'on n'est pas intéressé par le jour de semaine, la fonction fera un calcul supplémentaire inutile. Et ici, dans toutes les dates liées à la date de Pâques, le jour de semaine est connu par avance: le jeudi de l’Ascension tombera forcément un jeudi! Et c'est facile à calculer: Mardi-gras étant à 47 jours avant Pâques, c'est 6 semaines (47//7) et 5 jours (47%7) avant Pâques. Et les 5 jours correspondent bien à l'écart en jours, en remontant, entre le dimanche et le mardi.

[papajoker]

Existe une librairie python 3 équivalente qui peut être intéressante, écrite pour le service public.

https://github.com/etalab/jours-feri...ce/tree/master

note: trouvée sur code.gouv.fr

[tyrtamos]

Bonjour

Merci papajoker, c'est très intéressant. Le fait que ce soit défini par l'état amène des aspects légaux (code du travail) et une normalisation des appellations que je n'avais pas.