Parser les dates et heures en Python est souvent un casse-tête à cause des formats variés et données inconsistantes. Voici 5 fonctions DIY concrètes pour transformer ces formats chaotiques en données propres et exploitables, sans dépendre de bibliothèques lourdes.
3 principaux points à retenir.
- Manipulation directe : 5 fonctions Python simples pour gérer dates et heures réelles.
- Flexibilité : Gestion des formats relatifs, naturels, flexibles, durées, et ISO week dates.
- Autonomie : Moins de dépendances, meilleure compréhension et contrôle des données temporelles.
Comment convertir des temps relatifs en dates précises ?
Convertir des expressions telles que « 5 minutes ago » en dates précises est essentiel, surtout lorsque vous traitez des données issues des réseaux sociaux ou des logs. Ces données, souvent présentées sous forme de temps relatif, doivent être converties en objets datetime pour être exploitables. Voici une fonction Python qui utilise regex pour extraire le nombre et l’unité de temps, et qui utilise timedelta pour effectuer la conversion.
from datetime import datetime, timedelta
import re
def parse_relative_time(time_string, reference_time=None):
"""
Convertit les chaînes de temps relatif en objets datetime.
Exemples : "2 hours ago", "3 days ago", "1 week ago"
"""
if reference_time is None:
reference_time = datetime.now()
# Normaliser la chaîne
time_string = time_string.lower().strip()
# Modèle : nombre + unité de temps + "ago"
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"Impossible de parser : {time_string}")
amount = int(match.group(1))
unit = match.group(2)
# Mapper les unités aux 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':
# Approximatif : 30 jours par mois
return reference_time - timedelta(days=amount * 30)
elif unit == 'year':
# Approximatif : 365 jours par an
return reference_time - timedelta(days=amount * 365)
Cette fonction commence par normaliser la chaîne de caractères et utilise une expression régulière pour extraire le nombre et l’unité. Pour les unités supportées par timedelta, elle crée un objet timedelta et le soustrait à la référence temporelle. Concernant les mois et les années, elle fait des approximations en considérant respectivement 30 et 365 jours, ce qui est suffisant dans la plupart des cas.
Voici quelques exemples de code pour tester notre fonction :
result1 = parse_relative_time("2 hours ago")
result2 = parse_relative_time("3 days ago")
result3 = parse_relative_time("1 week ago")
print(f"2 hours ago: {result1}")
print(f"3 days ago: {result2}")
print(f"1 week ago: {result3}")
Les sorties devraient être des objets datetime correspondants à chaque expression relative. Par exemple, « 2 hours ago » pourrait renvoyer une date et une heure précises, vous permettant de travailler avec des données temporelles de manière fiable. Ce système est particulièrement utile lorsque vous devez gérer des données historiques ou tester des scénarios avec des dates spécifiques. De plus, le paramètre reference_time vous permet de personnaliser la référence temporelle, ce qui est un véritable atout pour vos projets.
Comment extraire des dates cachées dans du texte naturel ?
Dans le monde du traitement de texte, les dates sont souvent cachées parmi un océan de mots. Que ce soit dans un e-mail, un rapport ou un message, il est courant de rencontrer des phrases comme « La réunion est prévue pour le 15 janvier 2026 » ou « Veuillez répondre avant le 3 mars ». Pour extraire ces dates sans y passer des heures, vous avez besoin d’une méthode efficace. C’est là qu’intervient notre fonction Python.
Cette fonction utilise un dictionnaire des mois pour transformer des noms comme « janvier » ou « février » en leurs valeurs numériques respectives. En parallèle, elle s’appuie sur une expression régulière (regex) sophistiquée pour capter les formats typiques tels que « January 15th, 2026 » ou « March 3rd ». La gestion des suffixes ordinaux (st, nd, rd, th) est également intégrée pour éviter toute confusion. De plus, si l’année n’est pas spécifiée, la fonction par défaut l’attribue à l’année en cours, ce qui est judicieux dans la plupart des cas.
Voici un extrait de code qui illustre cette approche :
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,
'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)
Voyons quelques exemples concrets :
- Texte : « La réunion est prévue pour le 15 janvier 2026 » – Résultat : 2026-01-15
- Texte : « Veuillez répondre avant le 3 mars » – Résultat : 2026-03-03
- Texte : « Deadline : 25 décembre 2026 » – Résultat : 2026-12-25
Cette fonction est non seulement simple à utiliser, mais elle est aussi robuste face à différents formats de date. Pour ceux qui cherchent à aller encore plus loin dans le traitement des dates, je vous recommande de consulter dateparser, une bibliothèque qui simplifie encore plus la manipulation des dates. En fin de compte, savoir extraire efficacement des dates cachées dans du texte naturel peut faire toute la différence dans vos projets de traitement des données.
Comment parser plusieurs formats de dates sans se prendre la tête ?
Dans le monde réel, les formats de dates sont un véritable casse-tête. Vous avez sûrement déjà croisé des dates au format ISO, européen, américain, et j’en passe. Chaque source de données a ses propres règles, et vous devez être prêt à les affronter sans perdre votre calme. C’est là qu’une fonction robuste entre en jeu. Oubliez les solutions complexes et les frameworks lourds ; une simple fonction brute-force pourrait être votre meilleur allié.
Voici comment ça fonctionne : on crée une fonction qui teste successivement une liste de formats standards grâce à strptime. L’idée est de passer en revue les formats les plus courants, en commençant par ceux qui sont le plus souvent utilisés dans votre contexte. Par exemple, quand vous travaillez avec des données techniques, le format ISO (%Y-%m-%d) devrait être en tête de liste. Si vous savez que vos données proviennent d’un pays spécifique, vous pouvez réorganiser cette liste pour prioriser le format local.
from datetime import datetime
def parse_flexible_date(date_string):
date_string = date_string.strip()
formats = [
'%Y-%m-%d',
'%d-%m-%Y',
'%m/%d/%Y',
'%B %d, %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}")
Voyons quelques exemples concrets. Supposons que vous ayez les dates suivantes à parser :
- 2026-01-15 -> 2026-01-15 00:00:00
- 15/01/2026 -> 2026-01-15 00:00:00
- January 15, 2026 -> 2026-01-15 00:00:00
- 01/15/2026 -> 2026-01-15 00:00:00
Les résultats montrent que la fonction est capable de gérer plusieurs formats sans se prendre la tête. Ce qui est intéressant ici, c’est que cette méthode est simple à mettre en œuvre, mais elle peut être moins performante si vous avez une grande quantité de données à traiter. Si la rapidité est cruciale, envisagez des solutions plus sophistiquées, mais pour la plupart des cas d’usage, cette approche fait le job. Pour plus de détails sur la gestion de formats de dates multiples, vous pouvez consulter cet article.
Comment interpréter des durées exprimées en heures, minutes et secondes ?
Quand il s’agit de gérer des durées en Python, vous allez souvent croiser des formats comme H:M:S ou des notations textuelles du genre « 1h 30m ». Ces formats peuvent sembler simples à première vue, mais ils peuvent rapidement devenir un casse-tête si vous ne disposez pas des bons outils pour les parser. Voici une fonction qui va vous simplifier la vie en gérant ces deux cas avec brio.
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}")
Cette fonction commence par vérifier si la chaîne de durée contient un deux-points, indiquant un format H:M:S. Si c’est le cas, elle divise la chaîne et convertit les parties en timedelta. Sinon, elle s’attaque aux formats textuels comme « 1h 30m 45s » en utilisant des expressions régulières pour extraire les heures, minutes et secondes. Chaque unité est convertie en secondes, ce qui permet de créer un timedelta facile à manipuler.
Voici quelques exemples pour illustrer son fonctionnement :
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 de ces exemples vous montreront comment la fonction parvient à convertir chaque format en un timedelta exploitable. Cela est particulièrement utile dans des applications comme le suivi des performances sportives ou le traitement de vidéos, où les durées doivent être manipulées avec précision. Pour approfondir vos connaissances sur la gestion des dates et heures en Python, je vous recommande de consulter cet article : Gestion des dates avec Python.
Comment gérer les dates au format ISO semaine ?
Les dates au format ISO semaine, comme « 2026-W03-2 », sont souvent méconnues, mais elles jouent un rôle crucial dans le monde des affaires. Ce format est particulièrement utilisé dans les contextes de planification, où les entreprises doivent organiser leurs activités sur une base hebdomadaire. L’ISO week date se compose de l’année, du numéro de semaine et du jour de la semaine, ce qui peut sembler complexe au premier abord, mais une fois que vous avez compris comment cela fonctionne, c’est un jeu d’enfant à gérer.
Pour convertir une ISO week date en une date réelle, nous allons créer une fonction Python qui effectue ce calcul. La règle principale ici est que la première semaine de l’année est définie comme celle contenant le premier jeudi de l’année. Cela signifie que la semaine 1 peut commencer en décembre de l’année précédente, ce qui est un détail essentiel à garder à l’esprit lors de la conversion.
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 (1 
Cette fonction commence par diviser la chaîne de date en ses composants : l'année, la semaine et le jour. Elle vérifie ensuite que ces valeurs sont valides avant de procéder au calcul. En localisant le lundi de la première semaine de l'année, il suffit d'ajouter le nombre de semaines et de jours pour obtenir la date cible.
Voici quelques exemples d'utilisation de cette fonction :
# 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)')}")
Les résultats de ces tests donneront :
- 2024-W01-1 -> 2024-01-01 (Monday)
- 2024-W03-2 -> 2024-01-16 (Tuesday)
- 2024-W10-5 -> 2024-03-08 (Friday)
En résumé, savoir gérer les dates au format ISO semaine est essentiel pour toute entreprise qui souhaite optimiser sa planification. En intégrant cette fonction dans vos projets, vous serez en mesure de manipuler efficacement ces formats de date, ce qui facilitera la coordination des activités. Pour approfondir encore plus le sujet, vous pouvez consulter cette vidéo ici.
Vous êtes prêts à dompter toutes les dates et heures en Python, non ?
Les dates et heures sont des données traîtres, mais ces 5 fonctions DIY vous offrent une boîte à outils claire et efficace pour les parser sans dépendances lourdes. Vous gagnez en contrôle, comprenez mieux vos données, et évitez les erreurs sournoises dues à la diversité des formats. En maîtrisant ces techniques, vous simplifiez vos projets, du prototype au système en production, et vous libérez du temps pour ce qui compte vraiment : analyser et agir sur vos données temporelles.
FAQ
Pourquoi parser les dates et heures est-il compliqué en Python ?
Peut-on éviter d’utiliser des bibliothèques externes pour parser les dates ?
Comment gérer les formats ambigus comme 01/02/2026 ?
Les approximations pour mois et années sont-elles fiables ?
Comment choisir entre ces différentes fonctions dans un projet ?
A propos de l'auteur
Franck Scandolera, expert en Analytics, Data et IA, accompagne depuis des années entreprises et développeurs dans la maîtrise des données complexes, notamment temporelles. Consultant et formateur reconnu, il partage un savoir-faire pointu dans le développement Python et l’automatisation intelligente, garantissant des solutions pragmatiques et robustes adaptées aux défis réels du traitement des dates et heures.
⭐ 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.