Python datetime : comment travailler avec les dates et heures en Python

Travailler avec les dates et les heures paraît simple jusqu’à ce que vous deviez gérer les formats, les fuseaux horaires, les changements d’heure ou des horodatages issus de plusieurs systèmes. À ce stade, stocker le temps comme de simples chaînes ou entiers n’est plus une option. Le module datetime de Python est justement là pour vous aider à piloter tous ces éléments de façon prévisible.

Ce guide passe en revue les classes cœurs, comment créer et manipuler des objets datetime, effectuer des opérations arithmétiques, formater et parser des valeurs, gérer les fuseaux horaires, et plus encore. Chaque section s’appuie sur la précédente pour vous permettre de progresser des bases vers des schémas plus avancés.

Classes principales du module Python datetime

Avant d’entrer dans le détail, il est utile de comprendre comment Python modélise les dates et les heures au niveau conceptuel. Le module datetime s’appuie sur un petit ensemble de classes, chacune ciblant une partie du problème. Savoir où chaque classe s’inscrit facilite nettement le reste du flux de travail.

date

Quand vous n’avez besoin que d’une date calendaire sans vous préoccuper de l’heure ou des fuseaux horaires, la classe date est celle qu’il vous faut. Elle représente l’année, le mois et le jour via des attributs familiers.

Voici les attributs :

• year

• month

• day

Et les méthodes :

• today()

• fromisoformat()

• replace()

• isoformat()

• weekday()

• isoweekday()

from datetime import date
d = date(2025, 3, 1)
print(d)

Ce code crée une date de calendrier simple. Si vous saisissez une combinaison invalide (comme February 30), Python lève une exception ValueError.

time

Certaines tâches ne concernent que l’heure du jour, par exemple un rappel à 14 h 30. La classe time est alors utile car elle stocke les heures, minutes, secondes et, si nécessaire, les microsecondes ou les informations de fuseau horaire.

Les attributs sont : hour, minute, second, microsecond, tzinfo

Les méthodes sont : replace(), isoformat()

from datetime import time
t = time(14, 30, 15)
print(t)

Cela crée une heure d’horloge sans date associée. Des valeurs invalides (comme hour=27) généreront une erreur.

datetime

La plupart des situations réelles combinent date et heure : c’est le rôle de datetime. C’est la classe la plus polyvalente du module et celle que vous utiliserez le plus souvent pour journaliser, traiter et coordonner des événements.

Les attributs incluent (en plus de ceux ci-dessus) : tzinfo

Et les méthodes : now(), utcnow(), fromisoformat(), strptime(), strftime(), astimezone(). Elle prend également en charge l’arithmétique avec timedelta, que je détaillerai plus loin.

from datetime import datetime
dt = datetime(2025, 3, 1, 14, 30)
print(dt)

Cela produit un horodatage complet avec les composantes date et heure.

timedelta

Dès que vous devez mesurer un temps écoulé ou décaler un horodatage dans le futur ou le passé, timedelta est le bon choix. Il représente une durée, pas un instant précis.

Les attributs sont : days, seconds, microseconds. Couramment utilisé pour les décalages, différences temporelles et la logique de planification.

from datetime import timedelta
delta = timedelta(days=7, hours=3)
print(delta)

Cela représente une durée de longueur fixe. C’est particulièrement utile lorsqu’on l’ajoute à ou qu’on la soustrait d’un datetime.

tzinfo

tzinfo définit l’interface de Python pour les fuseaux horaires. Vous ne les créerez pas directement, mais le système datetime les utilise dès que vous attachez ou convertissez des fuseaux horaires.

timezone

timezone est une implémentation tzinfo intégrée pour les décalages UTC fixes comme UTC ou UTC+1. Utile pour les cas simples où les règles d’heure d’été ne comptent pas.

Créer et accéder aux objets datetime Python

Une fois les classes connues, la prochaine étape est d’apprendre à en instancier. Python propose plusieurs approches selon la provenance de vos données : saisie manuelle, heure système, timestamps ou texte.

Utiliser les constructeurs de classes

Les constructeurs offrent un contrôle total sur les valeurs créées. C’est souvent la façon la plus explicite et la plus robuste de construire des objets date, time ou datetime.

from datetime import date
d = date(2025, 3, 1)
print(d)

Ici, on construit directement une date calendaire. Des valeurs invalides déclenchent immédiatement une erreur, ce qui aide à détecter les fautes tôt.

from datetime import time
t = time(14, 30, 15)
print(t)

Cela produit une valeur d’heure. Utilisez-la quand la date n’est pas nécessaire.

from datetime import datetime
dt = datetime(2025, 3, 1, 14, 30)
print(dt)

Cela crée un horodatage complet. L’ajout d’un argument tzinfo le rend conscient du fuseau horaire.

Créer à partir de timestamps

Les timestamps Unix apparaissent dans les logs, les API et les systèmes d’exploitation. Python les convertit facilement en objets datetime lisibles.

datetime.fromtimestamp(1700000000)
datetime.utcfromtimestamp(1700000000)

La première interprète le timestamp en heure locale ; la seconde l’interprète en UTC.

Méthodes de classe pour les valeurs courantes

Quand vous avez besoin de la date ou de l’heure actuelles, Python fournit des raccourcis simples. Indispensables pour la journalisation, le suivi d’événements et les pipelines temps réel.

from datetime import datetime, date, timezone
print(date.today())
print(datetime.now())
print(datetime.now(tz=timezone.utc))  # Python 3.12+ preferred

Ces appels renvoient l’heure système actuelle en local ou en UTC selon vos besoins.

datetime.fromtimestamp(1700000000)
datetime.utcfromtimestamp(1700000000)

Ces fonctions convertissent des timestamps époque en objets datetime. Elles sont très courantes lors du parsing de valeurs issues d’API ou de bases de données.

Parser à partir de chaînes

Dans les données réelles, les horodatages sont souvent stockés en texte. Python offre des outils fiables pour convertir ces chaînes en valeurs structurées.

strptime()
from datetime import datetime
dt = datetime.strptime("2025-03-01 14:30", "%Y-%m-%d %H:%M")
print(dt)

strptime() parse une chaîne à l’aide d’un motif de format. Si la chaîne ne correspond pas exactement, Python lève une ValueError.

from datetime import datetime
dt = datetime.strptime("not-a-date", "%Y-%m-%d")

Cet exemple échouerait car l’entrée ne correspond pas au motif attendu.

fromisoformat()
datetime.fromisoformat("2025-03-01T14:30:00")

Les chaînes ISO 8601 se parséent proprement car leur structure est normalisée. C’est souvent la façon la plus simple de charger des horodatages depuis des API ou des pipelines modernes.

Réaliser des opérations arithmétiques sur les dates

Une fois vos horodatages créés, l’étape suivante consiste à les manipuler : calculer des durées, décaler des dates ou comparer des intervalles.

Timedelta pour les calculs temporels

timedelta modélise des périodes de durée fixe comme « 5 heures » ou « 2 semaines ». Idéal pour la planification, la journalisation et les comptes à rebours simples.

from datetime import datetime, timedelta
dt = datetime(2025, 3, 1, 14, 30)
new_dt = dt + timedelta(days=5)
print(new_dt)

Ici, on décale l’horodatage de cinq jours vers l’avant.

start = datetime(2025, 3, 1, 9, 0)
end = datetime(2025, 3, 1, 14, 30)
duration = end - start
print(duration.total_seconds())

La soustraction de deux datetime renvoie un timedelta, que vous pouvez convertir en secondes, jours ou heures.

Durée fixe vs arithmétique sensible au calendrier

Toutes les unités de temps ne se valent pas. La durée des mois varie, certaines années comportent un jour bissextile, et la fin de mois peut réserver des surprises. Dans ces scénarios, timedelta ne suffit pas.

dateutil.relativedelta gère une arithmétique « calendaire » :

from dateutil.relativedelta import relativedelta
from datetime import date
d = date(2025, 1, 31)
print(d + relativedelta(months=1))

Ceci gère correctement l’absence de « February 31 » en décalant la date de façon appropriée.

Formater et parser des dates

Le formatage des datetime est omniprésent : les API attendent des formats spécifiques, les utilisateurs préfèrent des textes lisibles et les logs reposent sur des chaînes d’horodatage cohérentes. Python prend en charge des formats flexibles et des représentations normalisées.

Mise en forme de chaînes avec strftime

strftime() permet de transformer des objets datetime en chaînes formatées à l’aide de codes prédéfinis.

from datetime import datetime
dt = datetime(2025, 3, 1, 14, 30)
print(dt.strftime("%A, %B %d, %Y at %H:%M"))

Cela affiche une chaîne lisible avec le jour de la semaine et le mois en toutes lettres.

dt.strftime("%Y-%m-%dT%H:%M:%S")

Cela produit une chaîne de style ISO, adaptée au stockage de données ou aux API.

Parser des chaînes avec strptime

from datetime import datetime
dt = datetime.strptime("2025-03-01 14:30", "%Y-%m-%d %H:%M")
print(dt)

Cela convertit du texte en objet datetime. Toute divergence entre chaîne et motif déclenche une erreur.

Travailler avec ISO 8601 et RFC 3339

ISO 8601 résout l’ambiguïté de nombreux formats régionaux. Python le prend en charge nativement :

from datetime import datetime
dt = datetime.fromisoformat("2025-03-01T14:30:00")
print(dt.isoformat())

C’est le format le plus sûr pour échanger des données entre systèmes, API ou bases.

Gérer les fuseaux horaires

Les fuseaux horaires introduisent certaines des difficultés les plus piégeuses en programmation temporelle. Python aide en distinguant les objets datetime naïs des objets conscients d’un fuseau et en fournissant des outils adaptés aux zones du monde réel.

Objets datetime naïs vs conscients

Un datetime naïf n’a pas de fuseau horaire :

from datetime import datetime
naive_dt = datetime(2025, 3, 1, 14, 30)
print(naive_dt.tzinfo)  # None

Un datetime conscient inclut un décalage de fuseau :

from datetime import timezone, timedelta
aware_dt = naive_dt.replace(tzinfo=timezone(timedelta(hours=1)))
print(aware_dt)

Mélanger des valeurs naïves et conscientes lors de comparaisons ou de calculs entraîne généralement des erreurs.

Utiliser le module zoneinfo

Le module zoneinfo de Python donne accès aux fuseaux horaires IANA du monde réel :

from zoneinfo import ZoneInfo
from datetime import datetime
dt = datetime(2025, 3, 1, 14, 30, tzinfo=ZoneInfo("Europe/Paris"))
print(dt)

La conversion de fuseau est simple :

dt.astimezone(ZoneInfo("America/New_York"))

Cela exprime le même instant dans un autre fuseau local.

Convertir entre fuseaux horaires

Vous pouvez convertir n’importe quel horodatage conscient vers un autre fuseau avec astimezone() :

from zoneinfo import ZoneInfo
dt_ny = dt.astimezone(ZoneInfo("America/New_York"))
print(dt_ny)

Une bonne pratique courante consiste à stocker les horodatages en UTC et ne convertir qu’à l’affichage.

Comparer et filtrer des dates

Les comparaisons interviennent dans presque tous les workflows : trier des logs, filtrer des événements ou déterminer si quelque chose s’est produit avant ou après un seuil.

from datetime import datetime
a = datetime(2025, 3, 1, 12, 0)
b = datetime(2025, 3, 1, 15, 0)
print(a < b)  # True

Les comparaisons sensibles aux fuseaux tiennent compte des décalages :

from datetime import datetime
from zoneinfo import ZoneInfo
dt1 = datetime(2025, 3, 1, 12, 0, tzinfo=ZoneInfo("Europe/London"))
dt2 = datetime(2025, 3, 1, 7, 0, tzinfo=ZoneInfo("America/New_York"))
print(dt1 == dt2)  # True — same moment in time

Le filtrage de collections s’exprime naturellement :

dates = [
    datetime(2025, 3, 1, 10),
    datetime(2025, 2, 20, 9),
    datetime(2025, 3, 1, 8)
]
cutoff = datetime(2025, 3, 1)
filtered = [d for d in dates if d >= cutoff]
print(filtered)

La normalisation en UTC est utile pour travailler à travers plusieurs zones.

Cas d’usage plus avancés

Datetime intervient dans bien d’autres workflows au-delà du simple parsing et de l’arithmétique. Voici quelques schémas fréquents.

Timestamps Unix

Les timestamps Unix mesurent les secondes écoulées depuis le 1er janvier 1970 (UTC). Ils sont très utilisés en programmation système et dans les API.

from datetime import datetime
dt = datetime.fromtimestamp(1700000000)
print(dt)

Les millisecondes et microsecondes nécessitent un redimensionnement :

ts_ms = 1700000000000
dt_ms = datetime.fromtimestamp(ts_ms / 1000)

ts_us = 1700000000000000
dt_us = datetime.fromtimestamp(ts_us / 1_000_000)

Planification et minuteries

Des bibliothèques comme schedule s’appuient sur les valeurs datetime pour déterminer quand exécuter des tâches. Que vous déclenchiez des fonctions toutes les quelques secondes ou que vous prévoyiez un événement unique plus tard dans la journée, datetime fournit la base de ces comparaisons.

Modèles pour l’analyse de données

On extrait souvent des attributs datetime pour le groupement et l’analyse temporelle :

dt = datetime(2025, 3, 1, 14, 30)
print(dt.year)
print(dt.isocalendar())

Dans pandas, le rééchantillonnage par période est très courant :

import pandas as pd
df = pd.DataFrame({
    "value": [10, 12, 15],
    "timestamp": pd.to_datetime([
        "2025-03-01",
        "2025-03-02",
        "2025-03-08"
    ])
}).set_index("timestamp")

print(df.resample("W").sum())

Conclusion

Pour aller plus loin avec datetime, consultez cette vidéo de notre cours Working with Dates and Times in Python de Max Shrom et Data Types for Data Science in Python de Jason Myers.

Vous pouvez également consulter notre tutoriel Converting Strings to Dates as datetime Objects si vous avez besoin d’un coup de pouce pour convertir des chaînes.