Transformez une colonne de chaînes de dates en vrai temps : parsez-la, extrayez-en les parties, indexez par elle, rééchantillonnez à n’importe quelle fréquence, et lissez la tendance avec une moyenne mobile.
Travaillez les dates comme du temps dans pandas : parsez les chaînes avec pd.to_datetime, extrayez l’année, le mois et le jour de la semaine avec l’accesseur .dt, posez un DatetimeIndex pour le découpage par chaîne partielle, agrégez à la semaine, au mois (ME) et à l’année (YE) avec resample, lissez une série quotidienne bruitée avec une moyenne mobile rolling, et faites apparaître les jours manquants avec asfreq et reindex.
pd.to_datetime(df["date"]) transforme des chaînes object en datetime64[ns] — c’est seulement alors que vous pouvez soustraire des dates, en extraire des parties, rééchantillonner ou lisser. Sur une simple colonne de chaînes, tout cela échoue — et le tri ne semble correct que pour les dates ISO, par chance..dt en extrait les parties. s.dt.year, .dt.month, .dt.day_name(), .dt.dayofweek, .dt.quarter, .dt.to_period("M") — la réponse à « quel jour de la semaine est le plus fréquenté ? » est un groupby sur .dt.day_name().DatetimeIndex débloque le découpage temporel. df.set_index("date") vous permet d’écrire df.loc["2024-08"] ou df.loc["2023-06":"2023-08"] — un découpage par chaîne partielle qui ne fonctionne qu’avec un index de type datetime.resample est le groupby du temps. resample("W"), resample("ME"), resample("YE") agrègent une série quotidienne à la semaine, au mois ou à l’année. Utilisez les alias modernes ME/YE — les simples M/Y déclenchent désormais un FutureWarning.rolling lisse le bruit pour révéler la tendance. s.rolling(7).mean() est une moyenne mobile sur 7 jours ; une fenêtre plus large (30) lisse davantage. Et asfreq("D") fait apparaître les jours silencieusement manquants — que resample enjamberait autrement sans un mot.Le travail sur les séries temporelles commence presque toujours de la même façon : vous ouvrez un CSV et la colonne de dates est une chaîne de caractères — "2023-01-01", qui ressemble à une date mais est stockée comme du texte. Tant que vous ne la convertissez pas, pandas la traite comme des mots, pas comme du temps : vous ne pouvez pas la trier de façon fiable, vous ne pouvez pas soustraire une date d’une autre, vous ne pouvez pas demander « le mois » ni « agréger ceci en totaux mensuels ». Toute la boîte à outils des séries temporelles — .dt, un DatetimeIndex, resample, rolling — est verrouillée derrière une première étape, le parsing.
Cette leçon, c’est cette boîte à outils dans l’ordre où le travail se déroule réellement : parser les chaînes en vrais datetimes, utiliser l’accesseur .dt pour extraire l’année/le mois/le jour de la semaine, poser un DatetimeIndex pour pouvoir découper par le temps, resample une série quotidienne en totaux hebdomadaires/mensuels/annuels, lisser le bruit quotidien avec une moyenne mobile rolling pour voir la tendance, et enfin gérer les jours tout simplement absents de l’enregistrement.
Les données sont un enregistrement quotidien simulé sur deux ans d’un petit café — une ligne par jour sur 2023–2024, avec le nombre de customers et le revenue du jour en euros. C’est illustratif, pas des observations réelles : une série propre et maîtrisée est précisément ce qui rend resample et rolling faciles à lire, et elle porte les deux motifs que nous voulons voir — un pic de fréquentation le week-end et une croissance d’une année sur l’autre — plus un trou délibéré de cinq jours (le café a fermé pour des travaux) afin que la gestion des jours manquants à la fin soit un vrai problème, pas un jouet. Elle est livrée sous forme d’un petit CSV à côté de cette leçon : rien à télécharger et aucun accès réseau au rendu.
Cela s’appuie sur les DataFrames pandas — le chargement, groupby et fillna viennent de là et nous nous y appuyons sans les réexpliquer — et se place aux côtés des leçons sœurs Combiner : merge et join et Remodeler : pivot et melt. Chaque résultat ci-dessous a été produit par le code montré, et les blocs s’enchaînent dans l’ordre. Pour expérimenter, modifiez la cellule Essayez en direct à la fin et appuyez sur Run.
Chargez le fichier et regardez-le. Deux ans de lignes quotidiennes, une colonne date et deux nombres par jour.
import pandas as pd
sales = pd.read_csv("daily_sales.csv")
print("shape:", sales.shape)
print("date dtype:", sales["date"].dtype)
print(sales.head(3))shape: (726, 3)
date dtype: object
date customers revenue
0 2023-01-01 288 2458.07
1 2023-01-02 174 1536.29
2 2023-01-03 207 1736.19726 lignes, 3 colonnes — une par jour du 2023-01-01 au 2024-12-31 (726, pas 731, parce que cinq jours de travaux en août 2024 sont absents du fichier ; nous y reviendrons). L’indice, c’est date dtype: object — la façon dont pandas dit « texte ». Ces valeurs ressemblent à des dates, mais stockées comme des chaînes, les opérations temporelles que vous voudrez n’existent tout simplement pas. Demandez son mois à une colonne de chaînes, et elle refuse :
# .dt time operations don't exist on a string (object) column
try:
sales["date"].dt.month
except AttributeError as e:
print("AttributeError:", e)AttributeError: Can only use .dt accessor with datetimelike valuesCan only use .dt accessor with datetimelike values — pas de .dt, et de même pas de rééchantillonnage, pas de rolling, pas de soustraction de dates. (Le tri est l’exception sournoise : parce que ces chaînes sont dans l’ordre ISO YYYY-MM-DD, trier le texte coïncide par hasard avec l’ordre chronologique — mais c’est un coup de chance du format. Écrivez les dates comme 3/1/2023 et le tri textuel les mélange. Ne vous y fiez jamais ; parsez d’abord.) Le correctif tient en un seul appel.
pd.to_datetimepd.to_datetime convertit la colonne de chaînes en vrais datetimes — dtype datetime64[ns]. Cette seule conversion débloque tout ce qui suit.
sales["date"] = pd.to_datetime(sales["date"])
print("date dtype:", sales["date"].dtype)
print("span:", (sales["date"].max() - sales["date"].min()).days, "days")date dtype: datetime64[ns]
span: 730 daysMaintenant date est de type datetime64[ns], et soustraire deux datetimes donne une vraie durée — l’enregistrement s’étend sur 730 jours. L’accesseur .dt fonctionne, resample fonctionne, les comparaisons sont chronologiques, et le tri est correct par le sens plutôt que par chance.
Deux notes pratiques :
format= pour la vitesse et la sûreté. pandas déduit la disposition, ce qui convient mais est lent sur de gros fichiers et ambigu sur des formats comme 01/02/2023 (est-ce le 2 janvier ou le 1er février ?). Indiquez-la explicitement — pd.to_datetime(col, format="%Y-%m-%d"), ou format="%d/%m/%Y" pour le jour d’abord — et le parsing est à la fois plus rapide et sans ambiguïté.parse_dates= est le raccourci. Quand vous savez déjà quelles colonnes sont des dates, sautez l’étape séparée et parsez au chargement : pd.read_csv("daily_sales.csv", parse_dates=["date"]) renvoie la colonne date déjà en datetime64. Nous l’avons fait en deux étapes ici uniquement pour montrer l’avant et l’après..dt : extraire les partiesUne fois qu’une colonne est de type datetime, l’accesseur .dt expose chaque partie calendaire comme sa propre colonne — sans chirurgie de chaînes. Chacune renvoie une Series que vous pouvez utiliser dans un filtre, un groupby ou une nouvelle colonne.
d = sales["date"]
print("year: ", d.dt.year.iloc[0])
print("month: ", d.dt.month.iloc[0])
print("day: ", d.dt.day.iloc[0])
print("weekday #: ", d.dt.dayofweek.iloc[0], "(Mon=0 … Sun=6)")
print("weekday: ", d.dt.day_name().iloc[0])
print("quarter: ", d.dt.quarter.iloc[0])
print("period(M): ", d.dt.to_period("M").iloc[0])year: 2023
month: 1
day: 1
weekday #: 6 (Mon=0 … Sun=6)
weekday: Sunday
quarter: 1
period(M): 2023-01Le premier jour, 2023-01-01, se lit comme l’année 2023, le mois 1, un dimanche (dayofweek 6), le T1, et la période mensuelle 2023-01. dayofweek numérote de lundi 0 à dimanche 6 (pratique pour « est-ce le week-end ? » — dayofweek >= 5) ; day_name() donne le libellé ; to_period("M") réduit une date à son mois, ce qui est la clé naturelle d’un « regroupement par mois » (il conserve l’année, donc les années différentes restent distinctes).
Cette dernière idée répond directement à une vraie question. Quel jour de la semaine est le plus fréquenté ? Regroupez les comptes de clients par nom de jour et prenez la moyenne — une seule expression .dt comme clé de regroupement (groupby lui-même est traité dans la leçon DataFrames pandas) :
by_weekday = (
sales.groupby(sales["date"].dt.day_name())["customers"]
.mean()
.round()
.sort_values(ascending=False)
)
print(by_weekday)date
Sunday 416.0
Saturday 413.0
Wednesday 326.0
Friday 325.0
Monday 324.0
Thursday 323.0
Tuesday 323.0
Name: customers, dtype: float64Le motif est sans équivoque : le dimanche (416) et le samedi (413) dominent, et les cinq jours de semaine se tiennent serrés autour de 323–326 clients. C’est une nette hausse du week-end — environ 90 clients de plus par jour le week-end qu’en milieu de semaine — le genre de fait opérationnel (renforcer les équipes le week-end) qui tombe directement d’un seul regroupement .dt.day_name(). L’ordre dans la Series affichée est par valeur parce que nous l’avons triée ; l’ordre calendaire demanderait plutôt .dt.dayofweek comme clé.
DatetimeIndex : découper par le tempsFaites de la date l’index et pandas gagne une conscience du temps — surtout le découpage par chaîne partielle, où une chaîne de date sélectionne toute une plage. Posez l’index une fois :
ts = sales.set_index("date").sort_index()
print(type(ts.index).__name__)
print(ts.head(3))DatetimeIndex
customers revenue
date
2023-01-01 288 2458.07
2023-01-02 174 1536.29
2023-01-03 207 1736.19ts.index est désormais un DatetimeIndex (nous faisons aussi sort_index() — les opérations sur séries temporelles supposent que l’index est dans l’ordre). Avec lui, une chaîne de date partielle sélectionne tout ce qui se trouve dans cette période :
# a whole month by string
print("August 2024 rows:", ts.loc["2024-08"].shape[0])
# a range of months (inclusive on both ends)
summer = ts.loc["2023-06":"2023-08"]
print("Summer 2023 rows:", summer.shape[0], " mean customers:", round(summer["customers"].mean()))August 2024 rows: 26
Summer 2023 rows: 92 mean customers: 375ts.loc["2024-08"] renvoie 26 lignes — chaque jour de ce mois présent dans le fichier (31 moins les 5 jours de fermeture pour travaux), sélectionné par la seule chaîne "2024-08". ts.loc["2023-06":"2023-08"] attrape tout l’été (92 jours) — et notez que la plage découpée est inclusive du mois de fin, contrairement au découpage Python ordinaire. Cela ne fonctionne que sur un DatetimeIndex ; sur la simple colonne de chaînes, vous écririez des masques booléens fragiles. L’index est aussi ce dont resample a besoin ensuite.
resample : le groupby des séries temporellesresample est le groupby du temps : il range les lignes dans des cases calendaires — semaines, mois, années — et agrège chaque case. Il a besoin d’un DatetimeIndex (que nous avons maintenant). Agrégez le chiffre d’affaires quotidien en totaux mensuels avec la fréquence ME (fin de mois) :
monthly_rev = ts["revenue"].resample("ME").sum()
print(monthly_rev.head(3))date
2023-01-31 61650.69
2023-02-28 61997.43
2023-03-31 76546.79
Freq: ME, Name: revenue, dtype: float64Chaque ligne est désormais le chiffre d’affaires total d’un mois, étiqueté par la date de fin de mois : janvier 2023 a fait €61,651, février €61,997, mars €76,547 — la montée vers le printemps déjà visible. resample("ME").sum() a remplacé les 726 lignes quotidiennes par 24 lignes mensuelles en un seul appel ; remplacez .sum() par .mean() pour obtenir le chiffre d’affaires quotidien moyen au sein de chaque mois à la place.
Utilisez ME et YE, pas M et Y. Dans les versions actuelles de pandas, les simples alias "M" et "Y" sont dépréciés et déclenchent un FutureWarning — les orthographes modernes sont ME (fin de mois) et YE (fin d’année). "W" (hebdomadaire) et "D" (quotidien) sont inchangés. Agrégée à l’année, la tendance sur deux ans est frappante :
yearly_rev = ts["revenue"].resample("YE").sum()
print(yearly_rev)
growth = (yearly_rev.iloc[1] / yearly_rev.iloc[0] - 1) * 100
print(f"\nyear-over-year growth: {growth:.1f}%")date
2023-12-31 988280.68
2024-12-31 1173205.86
Freq: YE-DEC, Name: revenue, dtype: float64
year-over-year growth: 18.7%2023 a rapporté €988,281 et 2024 €1,173,206 — une hausse de 18.7% d’une année sur l’autre. Ce seul chiffre est le titre que les lignes quotidiennes cachaient ; c’est resample("YE") qui le fait ressortir. L’hebdomadaire ("W") se situe entre les deux pour une vue de grain intermédiaire — ts["revenue"].resample("W").sum() donne un total par semaine.
Voici la série mensuelle sous la forme de la figure qu’elle mérite — la tendance que vous mettriez réellement dans un rapport :
import matplotlib.pyplot as plt
monthly_rev = ts["revenue"].resample("ME").sum()
fig, ax = plt.subplots(figsize=(8, 4.5))
ax.plot(monthly_rev.index, monthly_rev.values,
color="#3a86d4", linewidth=2, marker="o", markersize=4)
ax.set_xlabel("Month")
ax.set_ylabel("Monthly revenue (€)")
ax.set_title("Monthly café revenue, 2023–2024")
ax.spines[["top", "right"]].set_visible(False)
ax.grid(axis="y", alpha=0.3)
fig.tight_layout()
plt.show()
La forme raconte l’histoire que le tableau ne faisait que suggérer : un pic estival et un creux hivernal se répètent chaque année (saisonnalité), et toute la courbe de 2024 surplombe celle de 2023 (croissance). Rééchantillonner au mois est ce qui rend les deux lisibles — 726 points quotidiens agités les enseveliraient.
rolling : lisser le bruit quotidienLes données quotidiennes sont bruitées — chaque jour oscille autour du niveau sous-jacent, si bien que la ligne au jour le jour est difficile à lire. Une moyenne mobile (rolling) remplace chaque jour par la moyenne d’une fenêtre de jours voisins, lissant l’oscillation pour laisser apparaître la tendance. s.rolling(7).mean() est une moyenne mobile sur 7 jours ; une fenêtre de 30 jours lisse encore plus.
roll7 = ts["customers"].rolling(7).mean()
roll30 = ts["customers"].rolling(30, center=True, min_periods=1).mean()
print("first 8 of the 7-day rolling mean:")
print(roll7.head(8).round(1))first 8 of the 7-day rolling mean:
date
2023-01-01 NaN
2023-01-02 NaN
2023-01-03 NaN
2023-01-04 NaN
2023-01-05 NaN
2023-01-06 NaN
2023-01-07 214.3
2023-01-08 213.3
Name: customers, dtype: float64Lisez l’en-tête attentivement : les six premières valeurs sont NaN. Un rolling(7) glissant a besoin de sept jours avant de pouvoir en moyenner sept, donc la première fenêtre complète tombe sur la 7e ligne (~214.3 clients). Deux réglages contrôlent ce comportement de bordure :
min_periods= — le nombre minimal d’observations requis pour émettre une valeur. rolling(7, min_periods=1) commence à moyenner immédiatement (à partir des jours dont il dispose jusque-là), échangeant une fenêtre pleinement formée contre l’absence de NaN en tête. Notre ligne à 30 jours utilise min_periods=1, elle a donc zéro NaN.center=True — aligne la fenêtre sur le milieu de son étendue au lieu du bord glissant. Une moyenne centrée suit la vraie tendance sans le décalage d’une demi-fenêtre que porte une moyenne glissante, au prix d’avoir besoin de jours futurs (elle ne peut donc pas servir à des chiffres « jusqu’à aujourd’hui » en direct). Nous centrons la ligne à 30 jours parce qu’elle sert uniquement à voir la tendance.Voici maintenant l’image canonique : le comptage quotidien brut, fin et pâle, avec les deux moyennes mobiles posées par-dessus.
fig, ax = plt.subplots(figsize=(9, 4.5))
ax.plot(ts.index, ts["customers"], color="#b0b7c3", linewidth=0.7,
alpha=0.7, label="Daily (raw)")
ax.plot(roll7.index, roll7, color="#6ba3e0", linewidth=1.3, label="7-day average")
ax.plot(roll30.index, roll30, color="#1f4e79", linewidth=2.2, label="30-day average")
ax.set_xlabel("Date")
ax.set_ylabel("Customers per day")
ax.set_title("Daily café customers with 7-day and 30-day moving averages")
ax.spines[["top", "right"]].set_visible(False)
ax.legend(frameon=False, loc="upper left")
fig.tight_layout()
plt.show()
La ligne grise brute est presque illisible à elle seule — les pics du week-end et la dispersion quotidienne dominent. La moyenne sur 7 jours efface exactement ce cycle hebdomadaire (une fenêtre de 7 jours moyenne un exemplaire de chaque jour de la semaine), laissant une courbe plus nette ; la moyenne centrée sur 30 jours va plus loin, révélant la douce vague saisonnière — une large montée estivale, un creux hivernal — qui grimpe globalement de 2023 à 2024. C’est tout l’intérêt d’une moyenne mobile : choisissez la fenêtre pour correspondre au bruit que vous voulez faire disparaître (7 jours pour le cycle hebdomadaire, ~30 pour la tendance mensuelle).
asfreqLe café a fermé pendant cinq jours en août 2024, et ces lignes sont tout simplement absentes du fichier — pas NaN, juste pas là. C’est là que resample peut tromper en silence : il range par le calendrier, donc un resample mensuel enjambe le trou silencieusement, comme si ces jours n’avaient jamais compté. Pour voir le trou, il faut rendre les dates manquantes explicites. asfreq("D") réindexe sur un calendrier quotidien complet, insérant des lignes NaN pour chaque jour absent :
full = ts.asfreq("D")
print("rows before asfreq:", ts.shape[0], " after:", full.shape[0])
print("missing customer values:", int(full["customers"].isna().sum()))
print(full.loc["2024-08-11":"2024-08-17", "customers"])rows before asfreq: 726 after: 731
missing customer values: 5
date
2024-08-11 500.0
2024-08-12 NaN
2024-08-13 NaN
2024-08-14 NaN
2024-08-15 NaN
2024-08-16 NaN
2024-08-17 468.0
Freq: D, Name: customers, dtype: float64asfreq("D") a fait passer le tableau de 726 à 731 lignes — les cinq jours d’août manquants sont désormais présents en tant que NaN explicites (du 2024-08-12 au 2024-08-16). Maintenant le trou est visible et dénombrable, au lieu d’être silencieusement sauté. Une fois le trou explicite, vous décidez comment le traiter :
NaN — honnête, et correct pour une moyenne (NaN est ignoré). C’est généralement le bon choix : le café a réellement eu zéro activité, et inventer des nombres fausserait l’enregistrement.ffill() — reporter la dernière valeur observée (full["customers"].ffill()), pour quand une lecture manquante signifie « inchangé depuis la dernière fois ».interpolate() — tracer une droite en travers du trou (full["customers"].interpolate()), raisonnable pour une quantité variant en douceur que vous devez tracer sans coupure.La leçon, c’est la réindexation elle-même : resample/groupby opèrent sur les lignes qui existent, si bien qu’un trou disparaît de leur sortie. asfreq (ou le plus général reindex sur un pd.date_range) est la façon de forcer chaque case du calendrier à être présente, transformant une absence invisible en une décision visible et délibérée.
Choisissez la fréquence de rééchantillonnage et la fenêtre de rolling à partir de la question, pas par habitude :
| Votre question | Utilisez | L’appel |
|---|---|---|
| Total/moyenne par semaine | resample("W") |
ts["x"].resample("W").sum() |
| Figure de rapport mensuel | resample("ME") |
ts["x"].resample("ME").sum() |
| Croissance d’une année sur l’autre | resample("YE") |
ts["x"].resample("YE").sum() |
| Retirer un cycle hebdomadaire | Moyenne mobile sur 7 jours | ts["x"].rolling(7).mean() |
| Voir la tendance saisonnière | Moyenne mobile sur ~30 jours | ts["x"].rolling(30, center=True, min_periods=1).mean() |
| Trouver/faire apparaître les jours manquants | asfreq (ou reindex) |
ts.asfreq("D") |
Règle empirique : resample quand vous voulez moins de lignes, plus grossières (un total par période) ; rolling quand vous voulez les mêmes lignes, lissées. Et chaque fois qu’un trou dans le calendrier pourrait compter, asfreq("D") d’abord, pour que resample ne le cache pas.
Les blocs ci-dessus se sont exécutés au moment du build. Modifiez celui-ci et appuyez sur Run pour travailler vous-même la série du café — il s’exécute dans votre navigateur via Pyodide (aucune installation). Le premier Run télécharge pandas une fois (~20 Mo), puis c’est mis en cache et instantané.
Une colonne de dates coincée en texte, ou une série quotidienne trop bruitée à lire ? Collez un df.head() et demandez à Prova « parse cette colonne de dates, agrège-la en totaux mensuels et ajoute une moyenne mobile sur 7 jours » — ou « pourquoi mon resample('M') déclenche-t-il un avertissement, et pourquoi le trou dans mes dates disparaît-il ? » Elle écrit les appels pd.to_datetime, resample("ME") et rolling(...).mean(), signale les alias M/Y dépréciés, et montre l’asfreq("D") qui fait apparaître vos jours manquants. Parce que le runtime est juste là, vous l’exécutez et lisez vous-même la table rééchantillonnée, au lieu de faire confiance à un resample qui a silencieusement enjambé un trou. The runtime is the judge. Demandez à Prova →
Vous travaillez en R, ou dans les deux langages ? Les mêmes gestes existent dans le monde R. Le parsing avec pd.to_datetime, c’est ymd() / parse_date_time() de lubridate. Un resample, c’est un arrondi à un intervalle puis un regroupement — lubridate::floor_date(date, "month") puis un summarise() groupé (ou tsibble/slider). Un rolling(7).mean() de pandas, c’est rollmean() de zoo ou slide_dbl() de slider. Les concepts — parser d’abord, extraire avec un accesseur, ranger à une fréquence plus grossière, lisser avec une fenêtre — se transposent directement ; voir la série Manipulation de données R pour le versant tidyverse.
Vos dates se trient ou se comparent bizarrement — ou .dt lève une erreur. La colonne est encore une chaîne (dtype object). Les opérations temporelles n’existent pas sur du texte : .dt, resample, rolling et la soustraction de dates échouent toutes ou se comportent mal, et les chaînes non-ISO (3/1/2023) se trient même mal. Corrigez-le une fois en haut avec pd.to_datetime(df["date"]) (ou parse_dates=["date"] dans read_csv), puis vérifiez que df["date"].dtype affiche datetime64[ns].
resample("M") affiche un FutureWarning. Les simples alias d’offset "M" (mois) et "Y" (année) sont dépréciés dans les versions actuelles de pandas — utilisez "ME" (fin de mois) et "YE" (fin d’année) à la place. "W" (hebdomadaire) et "D" (quotidien) ne sont pas affectés. Ce n’est qu’un avertissement aujourd’hui, mais il deviendra une erreur, donc passez à ME/YE dès maintenant.
resample (ou rolling) se plaint de l’index, ou renvoie n’importe quoi. resample a besoin d’un DatetimeIndex — posez-le avec df.set_index("date") d’abord, ou passez la colonne directement avec df.resample("ME", on="date"). Et faites toujours sort_index() avant une fenêtre rolling : sur un index en désordre, la fenêtre moyenne les mauvais voisins, donnant une « moyenne mobile » silencieusement fausse.
Un trou dans vos dates a disparu de la sortie. resample et groupby ne voient que les lignes qui existent, si bien que les jours absents sont silencieusement enjambés plutôt que montrés. Réindexez sur un calendrier complet avec ts.asfreq("D") (ou reindex(pd.date_range(start, end, freq="D"))) pour insérer des lignes NaN explicites pour les jours manquants — puis décidez de les laisser en NaN, ffill() ou interpolate().
Utilisez pd.to_datetime : df["date"] = pd.to_datetime(df["date"]) transforme une colonne object (texte) en datetime64[ns]. Pour la vitesse et pour éviter l’ambiguïté, indiquez la disposition avec format= — par ex. pd.to_datetime(col, format="%Y-%m-%d"), ou format="%d/%m/%Y" pour les dates avec le jour en premier. Si vous connaissez les colonnes de dates au chargement, faites-le en une étape : pd.read_csv(path, parse_dates=["date"]). Confirmez que ça a marché en vérifiant que df["date"].dtype affiche datetime64[ns].
Posez un DatetimeIndex (df.set_index("date")), puis appelez resample("ME") avec une agrégation : ts["revenue"].resample("ME").sum() pour les totaux mensuels, ou .mean() pour la moyenne mensuelle. Utilisez ME (fin de mois), pas l’ancien "M", qui déclenche désormais un FutureWarning. Si vous ne voulez pas de DatetimeIndex, rééchantillonnez directement sur la colonne : df.resample("ME", on="date")["revenue"].sum(). Pour des totaux de fin d’année utilisez resample("YE"), et pour l’hebdomadaire resample("W").
Utilisez .rolling(window).mean() : ts["customers"].rolling(7).mean() est une moyenne mobile sur 7 jours. Une fenêtre plus large lisse davantage (rolling(30)). Deux options contrôlent les bords : min_periods=1 commence à émettre une valeur immédiatement au lieu de laisser des NaN en tête jusqu’à la première fenêtre complète, et center=True centre la fenêtre sur chaque point (aucun décalage) au lieu de la faire traîner derrière. Triez l’index d’abord (sort_index()) pour que la fenêtre moyenne les bons voisins.
Une fois la colonne en datetime, utilisez l’accesseur .dt : df["date"].dt.year et df["date"].dt.month renvoient des colonnes d’entiers que vous pouvez filtrer ou regrouper. Pour le jour de la semaine, utilisez .dt.day_name() (libellé) ou .dt.dayofweek (lundi 0 … dimanche 6) ; pour le trimestre, .dt.quarter. Pour construire une clé « regroupement par mois » qui garde les années distinctes, utilisez .dt.to_period("M"), qui réduit une date à sa période mensuelle du style 2024-08.
Deux façons propres. Si la date est l’index, resample : ts["revenue"].resample("ME").sum() donne une ligne par mois calendaire. Sinon, regroupez sur une clé de mois construite avec l’accesseur .dt : df.groupby(df["date"].dt.to_period("M"))["revenue"].sum(). Préférez to_period("M") à .dt.month seul — .dt.month fusionne le même mois d’années différentes (tous les janviers ensemble), tandis que to_period("M") garde 2023-01 et 2024-01 distincts.
Utilisez la série du café de la cellule Essayez en direct ci-dessus (sales = pd.read_csv("daily_sales.csv"), parsée avec pd.to_datetime, indexée par date).
Tâche 1. Rééchantillonnez les customers quotidiens en totaux hebdomadaires ("W"), puis ajoutez une moyenne mobile sur 4 semaines de ces totaux hebdomadaires et affichez les six premières semaines côte à côte. La moyenne mobile est-elle en retard sur la ligne hebdomadaire brute, et pourquoi ?
weekly = ts["customers"].resample("W").sum(), puis weekly.rolling(4).mean(). Mettez les deux dans un petit DataFrame pour les afficher ensemble. Rappelez-vous qu’un rolling(4) glissant a besoin de quatre semaines avant d’émettre sa première valeur.
weekly = ts["customers"].resample("W").sum()
smoothed = weekly.rolling(4).mean()
out = pd.DataFrame({"weekly": weekly, "roll4": smoothed})
print(out.head(6).round(0))La colonne roll4 est NaN pour les trois premières semaines (une fenêtre glissante de 4 semaines ne peut pas se remplir avant la 4e semaine), puis elle apparaît — et elle est en retard sur la ligne hebdomadaire brute, parce qu’une moyenne glissante est toujours tirée vers les semaines plus anciennes encore présentes dans sa fenêtre. Ajoutez center=True pour supprimer ce retard quand vous voulez seulement voir la tendance.
Vérification rapide. Vous exécutez ts["revenue"].resample("M").sum() et pandas affiche un FutureWarning. Que vous dit-il, et que devez-vous changer ?
Le simple alias mensuel "M" est déprécié — pandas le supprimera dans une version future. Passez à "ME" (fin de mois) : ts["revenue"].resample("ME").sum(). Le résultat est identique aujourd’hui ; vous ne faites que passer à l’orthographe non dépréciée (de même "Y" → "YE" pour la fin d’année). "W" et "D" sont inchangés.
Vous savez maintenant mener une colonne de chaînes de dates jusqu’à une série temporelle : la parser avec pd.to_datetime (l’unique étape qui débloque le reste), en extraire les parties calendaires avec l’accesseur .dt, poser un DatetimeIndex pour le découpage par chaîne partielle, resample les lignes quotidiennes en hebdomadaire/mensuel/annuel avec les alias modernes ME/YE, et lisser le bruit avec une moyenne mobile rolling dont vous choisissez la fenêtre selon le motif que vous voulez voir. Et vous connaissez les deux pièges discrets — le dtype chaîne qui bloque toute opération temporelle, et un trou de calendrier que resample enjambe en silence jusqu’à ce que asfreq("D") le rende explicite. Parsez d’abord, indexez par la date, et le reste du workflow de séries temporelles se met en place.
groupby et le fillna derrière le résumé par jour de la semaine et la gestion du trou · Combiner : merge et join — amener une seconde table aux côtés de votre série · Remodeler : pivot et melt — une table rééchantillonnée est souvent pivotée ensuite en matrice de rapport.Prouvez que vous savez le faire. Maîtrisez toute la série Manipulation de données en Python — suivez votre parcours, construisez des projets et obtenez un certificat.
Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.
dès 15 $/mois facturé annuellement
✓ Vous êtes Pro — continuez. The runtime is the judge.
@online{2026,
author = {},
title = {pandas séries temporelles : to\_datetime, resample \&
rolling},
date = {2026-07-17},
url = {https://www.datanovia.com/learn/programming/python-data-wrangling/dates-time-series},
langid = {fr}
}