Extraire des caractéristiques temporelles
Utilisez l’accesseur .dt pour extraire l’année, le mois, le jour, day_of_week et l’heure d’une colonne datetime afin de créer des variables.
Extraire des caractéristiques temporelles est une leçon Pandas & NumPy Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Pandas & NumPy Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Pandas & NumPy Academy comprend 4 leçons au total.
Pourquoi extraire des variables temporelles ?
Une colonne brute de type datetime64 est opaque pour la plupart des algorithmes d’apprentissage automatique : ils ne peuvent pas comprendre que 2024-12-25 est un jour férié ou que Friday entraîne une hausse des ventes au détail. La création de variables temporelles extrait des composants significatifs des colonnes de dates et heures — année, mois, jour, jour de la semaine, heure — pour en faire des colonnes numériques ou catégorielles distinctes, que les modèles et les fonctions d’analyse peuvent exploiter directement.
L’accesseur .dt
Lorsqu’une colonne d’un DataFrame possède le type datetime64, l’accesseur .dt expose vectoriellement toutes les propriétés et méthodes liées aux dates et heures. Au lieu d’appliquer une fonction Python ligne par ligne, vous écrivez df['date'].dt.year et Pandas calcule l’année pour chaque ligne en une seule opération rapide. Le même accesseur fonctionne avec les colonnes timedelta64, qui disposent de propriétés différentes.
import pandas as pd
df = pd.DataFrame({
'event_date': pd.date_range('2024-01-01', periods=8, freq='D'),
'revenue': [200, 350, 280, 310, 420, 380, 190, 260]
})
# Access datetime properties with .dt
print(df['event_date'].dt.year) # 2024 for all
print(df['event_date'].dt.month) # 1 for all
print(df['event_date'].dt.day[:5]) # 1, 2, 3, 4, 5Extraire les composants d’une date
Les propriétés .dt les plus utilisées pour les composants d’une date sont : .dt.year, .dt.month, .dt.day, .dt.day_of_week (0 = lundi jusqu’à 6 = dimanche), .dt.day_of_year, .dt.week ou .dt.isocalendar().week, .dt.quarter et .dt.days_in_month. Chacune renvoie une Series d’entiers pouvant être utilisée directement comme variable.
df['year'] = df['event_date'].dt.year
df['month'] = df['event_date'].dt.month
df['day'] = df['event_date'].dt.day
df['day_of_week'] = df['event_date'].dt.day_of_week # 0=Mon
df['quarter'] = df['event_date'].dt.quarter
df['day_of_year'] = df['event_date'].dt.day_of_year
print(df[['event_date', 'year', 'month', 'day',
'day_of_week', 'quarter']].head())Extraire les composants horaires
Pour les colonnes de dates et heures qui contiennent des informations horaires, et pas uniquement une date, utilisez .dt.hour, .dt.minute, .dt.second et .dt.microsecond. Ces propriétés sont essentielles pour l’analyse intrajournalière, la modélisation du comportement des utilisateurs (tendances du matin et du soir) et tout système où l’heure de la journée influence la variable cible.
df_ts = pd.DataFrame({
'timestamp': pd.date_range('2024-01-01', periods=6, freq='4h'),
'logins': [50, 200, 320, 280, 180, 90]
})
df_ts['hour'] = df_ts['timestamp'].dt.hour
df_ts['minute'] = df_ts['timestamp'].dt.minute
df_ts['date'] = df_ts['timestamp'].dt.date # Python date object
df_ts['time'] = df_ts['timestamp'].dt.time # Python time object
print(df_ts[['timestamp', 'hour', 'date']].head())Nom du jour et nom du mois
Pour obtenir des libellés lisibles, utilisez .dt.day_name() et .dt.month_name() afin d’obtenir des noms sous forme de chaînes comme 'Monday' et 'January'. Ces fonctions sont utiles pour l’affichage dans des rapports et pour créer des variables catégorielles représentant les effets du jour de la semaine ou du mois. Vous pouvez également transmettre une locale pour obtenir les noms dans d’autres langues.
df['day_name'] = df['event_date'].dt.day_name()
df['month_name'] = df['event_date'].dt.month_name()
print(df[['event_date', 'day_name', 'month_name']].head(5))
# event_date day_name month_name
# 2024-01-01 Monday January
# 2024-01-02 Tuesday January
# 2024-01-03 Wednesday JanuaryIndicateur de week-end et de jour ouvré
Une variable très courante est un indicateur booléen précisant si une date tombe un week-end. day_of_week >= 5 renvoie True pour le samedi (5) et le dimanche (6). Pour des variables plus élaborées liées au calendrier ouvré, numpy.busdaycalendar gère les jours fériés ; cependant, dans la plupart des cas, la simple distinction entre jours de semaine et week-end suffit à capturer l’essentiel de l’effet.
df['is_weekend'] = df['event_date'].dt.day_of_week >= 5
df['is_weekday'] = ~df['is_weekend']
# Compare weekend vs weekday revenue
print(df.groupby('is_weekend')['revenue'].mean().round(1))
# is_weekend
# False 308.3 <- weekday average
# True 285.0 <- weekend averageIndicateurs de début et de fin de période
L’accesseur .dt fournit également des propriétés booléennes qui indiquent si une date se situe au début ou à la fin d’une période : .dt.is_month_start, .dt.is_month_end, .dt.is_quarter_start, .dt.is_quarter_end, .dt.is_year_start et .dt.is_year_end. Elles sont utiles pour détecter les périodes de reporting, les cycles de facturation et les effets saisonniers aux limites des périodes.
dates_series = pd.Series(
pd.date_range('2024-01-28', periods=10, freq='D')
)
print(dates_series[dates_series.dt.is_month_start].values)
# ['2024-02-01']
print(dates_series[dates_series.dt.is_month_end].values)
# ['2024-01-31']Encodage cyclique des variables temporelles
Le mois et l’heure sont des valeurs cycliques : décembre (12) est proche de janvier (1), et 23 h est proche de 0 h. Les traiter comme des entiers linéaires (1 à 12 ou 0 à 23) induit la plupart des modèles en erreur. Encodez les variables cycliques à l’aide de transformations sinusoïdales et cosinusoïdales : sin(2π × value / max_value) et cos(2π × value / max_value). Cette méthode représente la structure circulaire dans deux colonnes numériques que les modèles peuvent utiliser correctement.
import numpy as np
# Cyclical encoding for month (1-12)
df['month_sin'] = np.sin(2 * np.pi * df['month'] / 12)
df['month_cos'] = np.cos(2 * np.pi * df['month'] / 12)
# Cyclical encoding for day of week (0-6)
df['dow_sin'] = np.sin(2 * np.pi * df['day_of_week'] / 7)
df['dow_cos'] = np.cos(2 * np.pi * df['day_of_week'] / 7)
print(df[['month', 'month_sin', 'month_cos']].head().round(3))Opérations arithmétiques sur les durées
Soustraire deux colonnes de dates et heures produit une Series timedelta64. L’accesseur .dt appliqué à une Series de durées expose .dt.days, .dt.seconds et .dt.total_seconds(). Vous pouvez ainsi calculer la durée d’événements, le temps écoulé depuis le dernier achat et l’âge en jours, le tout sous forme de colonnes numériques prêtes pour une analyse ultérieure.
df_orders = pd.DataFrame({
'order_date': pd.to_datetime(['2024-01-01', '2024-02-10', '2024-03-05']),
'delivery_date': pd.to_datetime(['2024-01-04', '2024-02-13', '2024-03-12'])
})
# Compute delivery time in days
df_orders['delivery_days'] = (
df_orders['delivery_date'] - df_orders['order_date']
).dt.days
print(df_orders)Utiliser les propriétés .dt d’un index
Lorsque la date et l’heure constituent l’index du DataFrame (un DatetimeIndex) plutôt qu’une colonne, accédez directement aux mêmes propriétés sur l’index, sans .dt : df.index.year, df.index.month, df.index.day_of_week, etc. Vous pouvez les ajouter directement comme nouvelles colonnes : df['month'] = df.index.month.
df_indexed = df.set_index('event_date')
# Access components directly on the DatetimeIndex
print(df_indexed.index.month[:3]) # [1, 1, 1]
print(df_indexed.index.day_of_week[:3]) # [0, 1, 2]
# Add as new columns
df_indexed['month'] = df_indexed.index.month
df_indexed['weekday'] = df_indexed.index.day_of_week
print(df_indexed.head())Pipeline complet de création de variables temporelles
Voici une fonction complète de création de variables temporelles qui prend un DataFrame contenant une colonne de dates et heures et renvoie ce DataFrame enrichi des variables temporelles les plus utiles. Ce modèle s’applique directement au début de tout pipeline d’apprentissage automatique ou d’analyse travaillant sur des données d’événements horodatés.
def add_temporal_features(df, date_col):
dt = df[date_col].dt
df['year'] = dt.year
df['month'] = dt.month
df['day'] = dt.day
df['day_of_week'] = dt.day_of_week
df['quarter'] = dt.quarter
df['is_weekend'] = dt.day_of_week >= 5
df['month_sin'] = (2 * 3.14159 * dt.month / 12).__round__(4)
df['month_cos'] = (2 * 3.14159 * dt.month / 12).__round__(4)
return df
result = add_temporal_features(df.copy(), 'event_date')
print(result.columns.tolist())Vérification rapide
Vérifiez votre compréhension de l’extraction de variables temporelles à partir de colonnes de dates et heures.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que l’accesseur .dt permet d’accéder vectoriellement à toutes les propriétés des dates et heures ; que les variables couramment extraites comprennent l’année, le mois, le jour, le jour de la semaine, l’heure et le trimestre ; que l’encodage cyclique avec le sinus et le cosinus gère la nature circulaire des heures et des mois ; et que les opérations arithmétiques sur les durées permettent de calculer des durées en jours ou en secondes. Nous allons maintenant découvrir l’architecture des figures et des axes de Matplotlib pour créer des graphiques de qualité professionnelle.
Apprends Python avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 30
- Leçons
- 120
Questions Fréquemment Posées
La leçon « Extraire des caractéristiques temporelles » est-elle gratuite ?
Oui — le texte complet de « Extraire des caractéristiques temporelles » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Pandas & NumPy Academy, passe à CoddyKit PRO. Le cours Pandas & NumPy Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Extraire des caractéristiques temporelles » ?
Utilisez l’accesseur .dt pour extraire l’année, le mois, le jour, day_of_week et l’heure d’une colonne datetime afin de créer des variables. Tu pratiques Pandas & NumPy Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Pandas & NumPy Academy ?
Aucune expérience préalable n'est requise. Pandas & NumPy Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Extraire des caractéristiques temporelles » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Pandas & NumPy Academy ?
Oui. Chaque leçon Pandas & NumPy Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- DatetimeIndex et intervalles de périodes
- Rééchantillonner des séries temporelles
- Décalages et variables retardées
- Extraire des caractéristiques temporelles