Discussion :

[Beginner.]

Salut,

EDIT1 : J'ai modifié ce message suite aux remarques...

Comment coderiez-vous une fonction qui calcule le nombre de jours entre deux dates d1 et d2 (non inclus) ?

Je sais qu'il existe des librairies toutes faites pour faire cela mais voyez cela comme un exercice...

EDIT2:

A titre d'info ce module datetime traite les dates de 1 à 9999 (MAXYEAR) donc il devrait satisfaire vos exigences.

Ok bon prenons donc cet intervalle pour l'exercice...

[Invité]

Bonjour,
J'aime bien réinventer la roue mais là...
Pourquoi ne pas utiliser datetime ?

Sinon une idée à la c¤n :
Tu codes un dictionnaire avec toutes les dates entre 1970 et 2050 par exemple du style : {'01/01/1970' : 0, '02/01/1970' : 1, ...}.
Ce qui te permet de calculer plus rapidement par la suite la différence entre deux dates comprises entre 1970 et 2050.

[Beginner.]

J'aime bien réinventer la roue mais là...
Pourquoi ne pas utiliser datetime ?

Ben tu peux voir ça comme un exercice... C'est bien connu qu'on fait réinventer la roue aux apprenants afin qu'ils s’exercent, qu'ils cogitent, mettent en pratique le cours théorique pour résoudre des problèmes concrets...

Sinon oui pour l'usage il vaut mieux utiliser une librairie toute faite, c'est plus prudent et plus fiable, surtout que cela prend en compte d'autres difficultés (secondes intercalaires, décalage horaire, changement d'heure...).

Au départ je pensais à des exercices plus simples autour des dates et je suis tombé sur cet os qui mine de rien n'est pas forcément aussi évident que ce que l'on peut croire au premier abord...

Tu codes un dictionnaire avec toutes les dates entre 1970 et 2050 par exemple du style : {'01/01/1970' : 0, '02/01/1970' : 1, ...}.
Ce qui te permet de calculer plus rapidement par la suite la différence entre deux dates comprises entre 1970 et 2050.

Cela me semble plus long que la solution avec la boucle que j'ai postée.

Mais c'est vrai que je pars pour l'instant du cas simple où on prend l'année a1 en entier et où on exclut l'année a2, par exemple si a1 vaut 2001 et a2 2004 alors on a 3 années complètes : 2001, 2002 et 2003. Et comme aucune de ces années n'est bissextile alors le nombre de jours entre a1 et a2 est : 365 * (a2-a1).

Et si il y a n années bissextiles entre a1 et a2 alors le nombre de jours est : 365 * (a2-a1) + n.

C'est donc plutôt simple et rapide à la base sauf pour certains cas dont j'ai parlés...

[Invité]

Ben tu peux voir ça comme un exercice...

Ok !

Cela me semble plus long que la solution avec la boucle que j'ai postée.

Sur mon ordi créer un dico de 1970 à 2050 prends 20 msec ensuite c'est de la tarte pour calculer la différence.
Je ne sais pas si cette technique porte un nom, de mon côté je vais solliciter la RAM plutôt que le processeur durant le calcul de la différence. (Si je ne dis pas de c¤nnerie)

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
def is_bissextile(annee):
    return annee % 4 == 0 and annee % 100 != 0 or annee % 400 == 0
 
def build_calendar():
    calendar = []
    #Year
    for y in range(1970, 2051):
        #Month
        for m in range(1, 13):
 
            maxi = 32
            if m in (4, 6, 9, 11):
                maxi = 31
            elif m == 2:
                maxi = 29
                if is_bissextile(y):
                    maxi = 30
            #Day        
            for d in range(1, maxi):
                calendar.append(f'{y}/{m:>02d}/{d:>02d}')
 
    dico = {k:i for i, k in enumerate(calendar)}
    return dico
 
calendar = build_calendar()
 
def diff(date1:"oldest date", date2:"newest date"):
    return calendar[date2]-calendar[date1]

#PS : Je ne sais pas si utiliser LISTE.index(date1) - LISTE.index(date2) est plus ou moins rapide que mon dictionnaire...

[Beginner.]

Salut,

Sur mon ordi créer un dico de 1970 à 2050 prends 20 msec ensuite c'est de la tarte pour calculer la différence.

Chez moi cela prend environ 28ms... Ton PC est plus rapide...

Je ne sais pas si cette technique porte un nom, de mon côté je vais solliciter la RAM plutôt que le processeur durant le calcul de la différence.

Merci pour ton exemple de solution.

#PS : Je ne sais pas si utiliser LISTE.index(date1) - LISTE.index(date2) est plus ou moins rapide que mon dictionnaire...

Bonne question.

-----

Quitte à réinventer la roue, je pense qu'il faudrait définir le but de l'exercice avec plus de rigueur. Calculer la différence entre deux dates, c'est vague. Voulez-vous simplement calculer le nombre de jours qui séparent deux dates, ou bien voulez-vous quelque chose d'autre, éventuellement de plus fin ?

Oui vous avez raison, j'ai modifié mon message. Pour l'instant, pour faire simple, il s'agit de calculer le nombre de jours...

Il faut aussi définir les contraintes d'utilisation, par exemple si vous voulez sortir de l'intervalle 1970-2038, alors les stratégies à mettre en oeuvre sont potentiellement différentes (un calcul de timestamp sur 32 bits ne suffit plus).

Pour les dates, pas de contraintes particulières mais l'intervalle le plus large possible (sans que cela devienne trop compliqué) est bienvenu... Cela peut être de l'an 1500 à l'an 3000 par exemple...

Mais faut-il obligatoirement un timestamp pour cette question/exercice ?

Comme dit précédemment, datetime est inclus par défaut dans Python et ne nécessite donc pas d'installer des packages tiers, et timedelta est très pratique.

Oui je sais bien qu'il y a des librairies toutes faites mais voyez cela comme un exercice.

Et c'est vrai que la question que j'avais en tête au départ, avant celle de la différence en deux dates, c'était : "Comment coderiez-vous une fonction qui calcule le nombre d'années bissextiles entre deux années a1 et a2 (non inclus) ?".

J'ai du coup ouvert un autre fil pour cette question : Nombre d'années bissextiles entre deux années et j'ai modifié la question de ce présent fil...

Et j'y ai d'ailleurs ajouter la question 2, pour cette question/exercice est-ce que l'usage d'une librairie est plus efficace ?

[Invité]

Petite adaptation :

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
def is_bissextile(annee):
    return annee % 4 == 0 and annee % 100 != 0 or annee % 400 == 0
 
def build_calendar(d1,d2):
    y1, y2 = int(d1[:4]), int(d2[:4])+1
    calendar = []
    #Year
    for y in range(y1, y2):
        #Month
        for m in range(1, 13):
 
            maxi = 32
            if m in (4, 6, 9, 11):
                maxi = 31
            elif m == 2:
                maxi = 29
                if is_bissextile(y):
                    maxi = 30
            #Day        
            for d in range(1, maxi):
                calendar.append(f'{y}/{m:>02d}/{d:>02d}')
 
    dico = {k:i for i, k in enumerate(calendar)}
    return dico
 
test_ram = {} #A SUPPRIMER
def diff(date1:"oldest date", date2:"newest date"):
    calendar = build_calendar(date1, date2)
    global test_ram #A SUPPRIMER
    test_ram = calendar #A SUPPRIMER
    return calendar[date2]-calendar[date1]

Quelques 222 Mo de RAM et environ 1.1 seconde, pour un diff('1111/01/01','5000/01/01'). L'idée ensuite serait de ne pas recharger le calendrier à chaque fois !

[binarygirl]

Pour les dates, pas de contraintes particulières mais l'intervalle le plus large possible (sans que cela devienne trop compliqué) est bienvenu... Cela peut être de l'an 1500 à l'an 3000 par exemple...

C'est pas hyper-précis mais bon

Mais faut-il obligatoirement un timestamp pour cette question/exercice ?

Non, mais c'est une approche possible. Mais pour cela il faut justement avoir une idée du degré de précision voulu et de l'amplitude des dates. On peut faire quelque chose de simple, astucieux si on sait à l'avance les valeurs extrêmes à traiter.
En gros, on essaie de réaliser un arbitrage entre souplesse, performance et simplicité.
Si j'ai cité 2038 ce n'est pas par hasard, faites une recherche sur le bug Y2K38 par curiosité.

En clair, si vous développez un programme pour une caisse de retraite, vous aurez besoin d'une amplitude de 100 ans et plus pour calculer correctement les retraites des individus. Mais pas d'un millénaire ou plus. On est donc dans un cas de figure différent.

Et j'y ai d'ailleurs ajouter la question 2, pour cette question/exercice est-ce que l'usage d'une librairie est plus efficace ?

Qu'entend-on par efficace ?
Si on parle de simplicité et rapidité (mettre un truc en route rapidement à moindre effort), il ne faut pas réinventer la roue sans raison valable, donc on utilise la lib qui va bien.

Si on parle de performance, on ne peut pas le savoir à l'avance, tout dépend de votre implémentation. Il y a des modules en Python comme timeit qui permettent de mesurer le temps d'exécution.
Il est d'ailleurs fortement conseillé de mesurer les performances de son propre code. Donc n'hésitez pas à comparer le résultat final avec celui obtenu en utilisant les modules natifs comme datetime.

Il n'est pas impossible que votre fonction "faite maison" performe mieux qu'un module éprouvé comme datetime, dans un cadre très restreint, à condition que le code soit bien construit et optimisé.

A titre d'info ce module datetime traite les dates de 1 à 9999 (MAXYEAR) donc il devrait satisfaire vos exigences.

Par contre, si vous devez traiter les dates dans le passé avant J-C, on rentre dans une autre problématique et ce n'est pas pour rien que le scope de l'exercice doit être défini clairement.

[josmiley]

Bonjour,
J'aime bien réinventer la roue mais là...
Pourquoi ne pas utiliser datetime ?

Sinon une idée à la c¤n :
Tu codes un dictionnaire avec toutes les dates entre 1970 et 2050 par exemple du style : {'01/01/1970' : 0, '02/01/1970' : 1, ...}.
Ce qui te permet de calculer plus rapidement par la suite la différence entre deux dates comprises entre 1970 et 2050.

C'est pas bête ça, j'y aurais jamais pensé.

[binarygirl]

Bonjour,

Quitte à réinventer la roue, je pense qu'il faudrait définir le but de l'exercice avec plus de rigueur. Calculer la différence entre deux dates, c'est vague. Voulez-vous simplement calculer le nombre de jours qui séparent deux dates, ou bien voulez-vous quelque chose d'autre, éventuellement de plus fin ?
Il faut aussi définir les contraintes d'utilisation, par exemple si vous voulez sortir de l'intervalle 1970-2038, alors les stratégies à mettre en oeuvre sont potentiellement différentes (un calcul de timestamp sur 32 bits ne suffit plus).

Le code sera plus ou moins complexe en fonction de ces critères d'utilisation. Mais tant que vous n'avez pas clairement défini le "scope", chacun va interpréter le problème à sa manière.
D'expérience, il n'y a rien de pire que les projets mal définis car ils ne sont jamais finis puisque les attentes ne sont pas clairement exprimées !

Comme dit précédemment, datetime est inclus par défaut dans Python et ne nécessite donc pas d'installer des packages tiers, et timedelta est très pratique.