Parser les dates et heures en Python peut vite devenir un cauchemar avec des formats variés et des données imprévisibles. Voici 5 fonctions DIY incontournables pour transformer ces formats en données exploitables, sans galérer ni surcharger votre code.
3 principaux points à retenir.
- Maîtrisez les formats relatifs et naturels : transformez « 2 jours ago » ou « March 3rd » en objets datetime.
- Gérez la diversité : parsez plusieurs formats standards avec un seul outil intelligent.
- Décodez durées et dates ISO : convertissez durées complexes et semaines ISO en données exploitables.
Comment convertir les dates relatives en objets datetime en Python
Dans le monde des données, la conversion de dates relatives comme « 5 minutes ago » en objets datetime est cruciale. Pourquoi ? Parce que lorsque vous traitez des informations issues des réseaux sociaux ou d’applications, ces formats de date sont omniprésents. Vous devez donc les transformer en quelque chose de manipulable par votre code.
La fonction parse_relative_time est conçue pour cela. Elle utilise des expressions régulières pour extraire le nombre et l’unité de temps. Voici comment cela fonctionne :
from datetime import datetime, timedelta
import re
def parse_relative_time(time_string, reference_time=None):
"""
Convertit des chaînes de temps relatives en objets datetime.
Exemples : "2 hours ago", "3 days ago", "1 week ago"
"""
if reference_time is None:
reference_time = datetime.now()
# Normalisation de la chaîne
time_string = time_string.lower().strip()
# Expression régulière pour capturer le nombre et l'unité
pattern = r'(\d+)\s*(second|minute|hour|day|week|month|year)s?\s*ago'
match = re.match(pattern, time_string)
if not match:
raise ValueError(f"Cannot parse: {time_string}")
amount = int(match.group(1))
unit = match.group(2)
# Mappage des unités vers les kwargs de timedelta
unit_mapping = {
'second': 'seconds',
'minute': 'minutes',
'hour': 'hours',
'day': 'days',
'week': 'weeks',
}
if unit in unit_mapping:
delta_kwargs = {unit_mapping[unit]: amount}
return reference_time - timedelta(**delta_kwargs)
elif unit == 'month':
# Approximation : 30 jours par mois
return reference_time - timedelta(days=amount * 30)
elif unit == 'year':
# Approximation : 365 jours par an
return reference_time - timedelta(days=amount * 365)
La fonction commence par normaliser la chaîne de caractères, puis utilise une expression régulière pour capturer le nombre et l’unité de temps. Si elle ne trouve pas de correspondance, elle lève une exception. Pour les unités gérées directement par timedelta, elle soustrait le temps approprié au temps de référence. Pour les mois et les années, elle fait une approximation, car un mois n’a pas toujours 30 jours et une année peut avoir 365 ou 366 jours.
Le paramètre reference_time est particulièrement intéressant. Il vous permet de spécifier un temps « maintenant » différent, ce qui est utile pour les tests ou lorsque vous traitez des données historiques. Par exemple :
result1 = parse_relative_time("2 hours ago")
print(f"2 hours ago: {result1}") # Affiche l'heure exacte correspondant à "2 hours ago"
En utilisant cette fonction, vous pouvez facilement transformer des chaînes de texte en objets datetime exploitables dans votre code, ce qui est essentiel pour toute application qui manipule des données temporelles. Pour voir d’autres exemples et approfondir vos connaissances, consultez cette vidéo ici.
Comment extraire les dates des textes en langage naturel
Vous êtes-vous déjà retrouvé à fouiller dans un texte à la recherche d’une date ? Des phrases comme « La réunion est prévue pour le 15 janvier 2026 » peuvent sembler simples, mais isoler ces dates peut rapidement devenir un casse-tête, surtout lorsque le texte est long ou mal structuré. C’est là qu’intervient la fonction extract_date_from_text, qui rend cette tâche beaucoup plus gérable.
Cette fonction utilise un dictionnaire pour associer les noms des mois à leurs valeurs numériques, tout en combinant une expression régulière puissante pour capturer les mois, les jours et l’année optionnelle. Par exemple, elle peut facilement reconnaître des formats comme « 15 janvier » ou « 25 déc. 2023 ». Vous vous demandez comment cela fonctionne ? La magie réside dans la gestion des suffixes ordinaux (st, nd, rd, th) qui peuvent apparaître après les jours, et la fonction utilise l’année courante par défaut lorsque l’année n’est pas spécifiée.
import re
from datetime import datetime
def extract_date_from_text(text, current_year=None):
if current_year is None:
current_year = datetime.now().year
months = {
'january': 1, 'jan': 1,
'february': 2, 'feb': 2,
'march': 3, 'mar': 3,
'april': 4, 'apr': 4,
'may': 5,
'june': 6, 'jun': 6,
'july': 7, 'jul': 7,
'august': 8, 'aug': 8,
'september': 9, 'sep': 9, 'sept': 9,
'october': 10, 'oct': 10,
'november': 11, 'nov': 11,
'december': 12, 'dec': 12
}
pattern = r'(january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|sept|october|oct|november|nov|december|dec)\s+(\d{1,2})(?:st|nd|rd|th)?(?:,?\s+(\d{4}))?'
matches = re.findall(pattern, text.lower())
if not matches:
return None
month_str, day_str, year_str = matches[0]
month = months[month_str]
day = int(day_str)
year = int(year_str) if year_str else current_year
return datetime(year, month, day)
Pour illustrer, testons la fonction avec quelques exemples :
text1 = "La réunion est prévue pour le 15 janvier 2026"
text2 = "Veuillez répondre d'ici le 3 mars"
text3 = "Échéance : 25 déc. 2026"
date1 = extract_date_from_text(text1)
date2 = extract_date_from_text(text2)
date3 = extract_date_from_text(text3)
print(f"De '{text1}': {date1}")
print(f"De '{text2}': {date2}")
print(f"De '{text3}': {date3}")
Le résultat est clair :
De 'La réunion est prévue pour le 15 janvier 2026': 2026-01-15 00:00:00
De 'Veuillez répondre d'ici le 3 mars': 2026-03-03 00:00:00
De 'Échéance : 25 déc. 2026': 2026-12-25 00:00:00
Cette méthode est à la fois simple et robuste, vous permettant d’extraire des dates sans avoir besoin de solutions compliquées. Pour une démonstration visuelle de ce type de parsing, regardez cette vidéo. Vous verrez à quel point il est facile de travailler avec des dates en Python.
Comment gérer plusieurs formats de dates sans se prendre la tête
Face à la diversité des formats de dates et heures que vous pouvez rencontrer dans vos projets, qu’il s’agisse de formats ISO, européens, américains, ou même écrits en toutes lettres, il devient crucial d’adopter une approche brute-force. La fonction parse_flexible_date que nous allons explorer permet de gérer efficacement cette variété sans vous tirer les cheveux.
Voici les formats que nous allons tester :
- %Y-%m-%d (ex: 2026-01-15)
- %Y/%m/%d (ex: 2026/01/15)
- %d-%m-%Y (ex: 15-01-2026)
- %d/%m/%Y (ex: 15/01/2026)
- %m/%d/%Y (ex: 01/15/2026)
- %d.%m.%Y (ex: 15.01.2026)
- %Y%m%d (ex: 20260115)
- %B %d, %Y (ex: January 15, 2026)
- %b %d, %Y (ex: Jan 15, 2026)
- %d %B %Y (ex: 15 January 2026)
- %d %b %Y (ex: 15 Jan 2026)
L’ordre de ces formats n’est pas anodin. Nous avons placé le format ISO (%Y-%m-%d) en premier, car il est le plus courant dans les contextes techniques. Les formats ambigus comme %d/%m/%Y et %m/%d/%Y viennent plus tard dans la liste, car ils peuvent mener à des erreurs d’interprétation. Si vous savez que vos données utilisent un format particulier de manière constante, n’hésitez pas à ajuster cet ordre pour optimiser les performances.
La fonction utilise datetime.strptime dans un bloc try-except pour tenter chaque format. Si un format échoue, la fonction continue simplement avec le suivant, vous évitant ainsi de vous retrouver bloqué par des erreurs de parsing.
from datetime import datetime
def parse_flexible_date(date_string):
date_string = date_string.strip()
formats = [
'%Y-%m-%d',
'%Y/%m/%d',
'%d-%m-%Y',
'%d/%m/%Y',
'%m/%d/%Y',
'%d.%m.%Y',
'%Y%m%d',
'%B %d, %Y',
'%b %d, %Y',
'%d %B %Y',
'%d %b %Y',
]
for fmt in formats:
try:
return datetime.strptime(date_string, fmt)
except ValueError:
continue
raise ValueError(f"Unable to parse date: {date_string}")
Cette méthode est particulièrement utile dans les projets réels où les données sont hétérogènes. En utilisant une approche brute-force, vous vous assurez que la plupart des formats de date que vous rencontrez seront gérés sans effort. Si vous souhaitez approfondir vos connaissances sur la gestion des dates en Python, vous pouvez consulter cet article.
Comment parser les durées en Python en différents formats
Lorsqu'il s'agit de gérer des durées en Python, il est crucial de convertir des formats comme « 1h 30m 45s » ou « 2:45:30 » en objets timedelta. Cela permet d'effectuer des calculs précis et d'éviter les erreurs qui peuvent survenir avec des formats de chaîne non standard. La fonction parse_duration que nous allons examiner est conçue pour détecter d'abord les formats séparés par des deux-points (H:M:S ou M:S), puis utilise des expressions régulières (regex) pour extraire les heures, les minutes et les secondes à partir de divers formats texte, y compris ceux qui contiennent des valeurs décimales.
Voici la fonction parse_duration :
from datetime import timedelta import re def parse_duration(duration_string): """ Parse duration strings into timedelta objects. Handles formats like: - "1h 30m 45s" - "2:45:30" (H:M:S) - "90 minutes" - "1.5 hours" """ duration_string = duration_string.strip().lower() # Try colon format first (H:M:S or M:S) if ':' in duration_string: parts = duration_string.split(':') if len(parts) == 2: # M:S format minutes, seconds = map(int, parts) return timedelta(minutes=minutes, seconds=seconds) elif len(parts) == 3: # H:M:S format hours, minutes, seconds = map(int, parts) return timedelta(hours=hours, minutes=minutes, seconds=seconds) # Try unit-based format (1h 30m 45s) total_seconds = 0 # Find hours hours_match = re.search(r'(\d+(?:\.\d+)?)\s*h(?:ours?)?', duration_string) if hours_match: total_seconds += float(hours_match.group(1)) * 3600 # Find minutes minutes_match = re.search(r'(\d+(?:\.\d+)?)\s*m(?:in(?:ute)?s?)?', duration_string) if minutes_match: total_seconds += float(minutes_match.group(1)) * 60 # Find seconds seconds_match = re.search(r'(\d+(?:\.\d+)?)\s*s(?:ec(?:ond)?s?)?', duration_string) if seconds_match: total_seconds += float(seconds_match.group(1)) if total_seconds > 0: return timedelta(seconds=total_seconds) raise ValueError(f"Unable to parse duration: {duration_string}")Testons maintenant cette fonction avec différentes chaînes de durée :
durations = [ "1h 30m 45s", "2:45:30", "90 minutes", "1.5 hours", "45s", "2h 15m" ] for duration in durations: parsed = parse_duration(duration) print(f"{duration:15} -> {parsed}")Les résultats montrent que la fonction gère efficacement les durées partielles et est robuste face à des entrées utilisateur variées. Par exemple, une chaîne comme « 45s » sera correctement interprétée comme 0:00:45. Cela signifie que vous pouvez faire confiance à cette fonction pour traiter des durées dans des applications réelles, que ce soit pour des trackers de temps ou des lecteurs vidéo. Pour une compréhension plus approfondie des conversions entre chaînes et objets datetime, vous pouvez consulter cet article ici.
Comment interpréter les dates au format ISO semaine en Python
Les dates au format ISO semaine, comme « 2026-W03-2 », sont particulièrement utilisées dans le milieu professionnel pour la planification basée sur les semaines. Ce format est utile car il permet de s’assurer que tout le monde parle le même langage lorsqu’il s’agit de programmer des réunions ou des échéances. Mais comment ça fonctionne exactement ?
La règle de la semaine 1 est cruciale : elle est définie comme la semaine contenant le premier jeudi de l’année. Cela signifie que la première semaine de l’année peut commencer en décembre de l’année précédente si le 1er janvier tombe un vendredi, un samedi ou un dimanche. En ce qui concerne la numérotation des jours, elle est simple : 1 correspond à lundi et 7 à dimanche. Dans ce contexte, « 2026-W03-2 » signifie le mardi de la troisième semaine de l’année 2026.
Pour manipuler ces formats en Python, nous allons utiliser la fonction parse_iso_week_date. Cette fonction découpe la chaîne de caractères, valide la syntaxe et calcule la date correspondante. Elle commence par trouver le lundi de la semaine 1 à partir du 4 janvier, puis elle ajoute le nombre de semaines et de jours spécifiés.
from datetime import datetime, timedelta def parse_iso_week_date(iso_week_string): """ Parse ISO week date format: YYYY-Www-D Example: "2024-W03-2" = Week 3 of 2024, Tuesday """ parts = iso_week_string.split('-') if len(parts) != 3 or not parts[1].startswith('W'): raise ValueError(f"Invalid ISO week format: {iso_week_string}") year = int(parts[0]) week = int(parts[1][1:]) # Remove 'W' prefix day = int(parts[2]) if not (1Pour tester cette fonction, on peut l’appliquer sur quelques exemples :
# Test ISO week dates iso_dates = [ "2024-W01-1", # Week 1, Monday "2024-W03-2", # Week 3, Tuesday "2024-W10-5", # Week 10, Friday ] for iso_date in iso_dates: parsed = parse_iso_week_date(iso_date) print(f"{iso_date} -> {parsed.strftime('%Y-%m-%d (%A)')}")Cette méthode est particulièrement pertinente dans les environnements professionnels où la planification hebdomadaire est la norme. Pour voir cette approche en action, vous pouvez consulter cette vidéo ici.
Prêt à dompter les dates et heures dans vos projets Python ?
Ces cinq fonctions DIY vous donnent la clé pour transformer des formats de dates et heures embrouillés en données propres et exploitables. Que ce soit pour des durées, des dates relatives, naturelles, flexibles ou ISO, vous disposez d’outils précis, adaptables et légers. Finies les heures perdues à bricoler du parsing bancal : vous gagnez en fiabilité et en contrôle, sans dépendre de lourdes bibliothèques. Au final, c’est votre productivité et la qualité de vos projets qui s’envolent.
FAQ
Comment gérer les formats de date inconnus en Python ?
La fonction parse_flexible_date teste plusieurs formats standards en séquence jusqu'à trouver une correspondance. Cette méthode simple et efficace évite d'écrire un parser spécifique pour chaque format inconnu.Peut-on parser des durées exprimées en texte libre ?
Oui, la fonction parse_duration reconnait aussi bien les formats colonisés (H:M:S) que les durées exprimées en heures, minutes, secondes avec ou sans décimales, grâce à des expressions régulières ciblées.Pourquoi approximons-nous les mois et années dans les dates relatives ?
Python ne gère pas directement les mois et années dans timedelta. On utilise donc des approximations (30 jours/mois, 365 jours/an) qui suffisent dans la plupart des cas, sauf pour des calculs ultra précis.Comment extraire une date d’un texte sans connaître sa position ?
La fonction extract_date_from_text utilise une regex pour détecter les motifs de date dans le texte, puis convertit le premier résultat en objet datetime, même si la date est noyée dans une phrase complexe.Qu’est-ce qu’une date ISO semaine et pourquoi la parser ?
Une date ISO semaine (ex : 2026-W03-2) indique une semaine et un jour précis selon la norme ISO, utilisée en business pour la planification. La parser permet de convertir ce format en date calendaire classique exploitable en Python.
A propos de l'auteur
Franck Scandolera cumule des années d’expérience en Analytics, Data et automatisation IA, notamment dans le développement d’applications basées sur OpenAI API et LangChain. Consultant et formateur reconnu, il accompagne les entreprises dans la maîtrise des données et l’intégration intelligente de l’IA dans leurs workflows. Basé en France, il partage ses expertises pointues pour rendre la Data accessible et efficace.
⭐ Analytics engineer, Data Analyst et Automatisation IA indépendant ⭐
- Ref clients : Logis Hôtel, Yelloh Village, BazarChic, Fédération Football Français, Texdecor…
Mon terrain de jeu :
- Data Analyst & Analytics engineering : tracking avancé (GTM server, e-commerce, CAPI, RGPD), entrepôt de données (BigQuery, Snowflake, PostgreSQL, ClickHouse), modèles (Airflow, dbt, Dataform), dashboards décisionnels (Looker, Power BI, Metabase, SQL, Python).
- Automatisation IA des taches Data, Marketing, RH, compta etc : conception de workflows intelligents robustes (n8n, App Script, scraping) connectés aux API de vos outils et LLM (OpenAI, Mistral, Claude…).
- Engineering IA pour créer des applications et agent IA sur mesure : intégration de LLM (OpenAI, Mistral…), RAG, assistants métier, génération de documents complexes, APIs, backends Node.js/Python.
