Fonction Pandas DataFrame DataFrame.interpolate()

La méthode Pandas DataFrame.interpolate() estime les valeurs manquantes à partir des valeurs voisines, selon un axe choisi. Elle peut combler un intervalle intérieur lorsque des valeurs exploitables l’encadrent ; certaines valeurs peuvent rester manquantes si les données ne fournissent pas assez d’informations. (NaN)

Syntaxe et paramètres de pandas.DataFrame.interpolate()

L’appel de la méthode suit cette forme générale :

DataFrame.interpolate(method="linear", axis=0, limit=None, inplace=False, limit_direction="forward", limit_area=None, **kwargs)

Les exemples utilisent de petits DataFrames numériques que vous pouvez adapter à vos propres données.

Interpoler les valeurs manquantes avec la méthode par défaut

Avec la valeur par défaut method="linear", pandas estime les valeurs en considérant que les positions le long de l’axe choisi sont régulièrement espacées. Dans l’exemple, la valeur entre 10 et 30 est estimée à 20, et la valeur manquante en fin de série est remplacée par 30.0 en prolongeant la dernière valeur connue.

Exécutez cet exemple :

import pandas as pd

df = pd.DataFrame({"temperature": [10.0, None, 30.0, None]})
result = df.interpolate()
print(result)

   temperature
0         10.0
1         20.0
2         30.0
3         30.0

Utilisez l’interpolation lorsque la valeur manquante doit être estimée à partir des observations voisines. pandas.DataFrame.fillna() remplace plutôt les valeurs manquantes par une valeur choisie ou selon une autre stratégie de remplissage. Le choix entre les deux méthodes dépend des données et de l’objectif.

Choisir une méthode d’interpolation

Pour des mesures numériques ordinaires dont les positions de ligne sont régulièrement espacées, conservez la valeur par défaut de method. Pour un DataFrame indexé par le temps, method="time" s’appuie sur les intervalles de temps représentés par l’index pour estimer les valeurs. Cette méthode est utile lorsque les observations ne sont pas espacées régulièrement dans le temps. L’exemple temporel ci-dessous montre la forme d’index requise.

Les méthodes disponibles et leurs exigences peuvent varier selon la version de pandas. Avant de choisir une autre méthode ou de transmettre des arguments nommés qui lui sont propres, consultez la documentation de l’API correspondant à votre version.

Choisir l’axe d’interpolation

Par défaut, axis=0 remplit les valeurs en descendant dans chaque colonne. Définissez axis=1 pour les remplir en parcourant les colonnes de chaque ligne. Par exemple, avec axis=1, une valeur manquante entre 10 et 30 sur une ligne est estimée à 20. Si une ligne ne contient aucune valeur connue, l’interpolation ne dispose d’aucune valeur de référence pour faire une estimation et laisse ses éléments manquants.

import pandas as pd

df = pd.DataFrame(
    {"morning": [10.0, None], "afternoon": [None, None], "evening": [30.0, None]},
    dtype="float64",
)
print(df.interpolate(axis=1))

   morning  afternoon  evening
0     10.0       20.0     30.0
1      NaN        NaN      NaN

Le type numérique explicite permet également de conserver un type numérique pour une colonne entièrement manquante ; l’interpolation sur la ligne peut donc s’effectuer. Dans cet exemple avec axis=1, l’espacement linéaire dépend de la position des colonnes, et non de leur nom.

Limiter les valeurs manquantes consécutives et définir leur sens de remplissage

Définissez limit pour plafonner le nombre d’entrées manquantes consécutives que pandas remplit dans chaque intervalle. limit_direction détermine le sens utilisé avec cette limite. Pour un intervalle de trois valeurs entre 0 et 40, limit=1 avec un remplissage vers l’avant remplit la première position manquante en partant du haut ; avec un remplissage vers l’arrière, la dernière position manquante est remplie en partant du bas. Les autres positions restent manquantes.

import pandas as pd

df = pd.DataFrame({"reading": [0.0, None, None, None, 40.0]})
print("Forward:")
print(df.interpolate(limit=1, limit_direction="forward"))
print("Backward:")
print(df.interpolate(limit=1, limit_direction="backward"))

Forward:
   reading
0      0.0
1     10.0
2      NaN
3      NaN
4     40.0
Backward:
   reading
0      0.0
1      NaN
2      NaN
3     30.0
4     40.0

Utilisez limit_direction="both" lorsque le remplissage depuis les deux extrémités convient, et examinez les données obtenues si l’intervalle dépasse la limite définie.

Interpoler les valeurs de données indexées par le temps

Pour une interpolation temporelle, utilisez un DatetimeIndex afin que les dates et le temps écoulé soient des valeurs de l’index, plutôt que des chaînes dans une colonne ordinaire. Le 2 janvier se situe au tiers de l’intervalle entre le 1er et le 4 janvier. La valeur interpolée se situe donc également au tiers de l’intervalle entre 10 et 30, soit 16.666667.

import pandas as pd

index = pd.to_datetime(["2024-01-01", "2024-01-02", "2024-01-04"])
df = pd.DataFrame({"value": [10.0, None, 30.0]}, index=index)
print(df.interpolate(method="time"))

                value
2024-01-01  10.000000
2024-01-02  16.666667
2024-01-04  30.000000

Conservez l’index de dates et heures pour utiliser l’interpolation temporelle ; convertir les dates en une colonne de texte ordinaire ne fournit pas les intervalles de temps dont la méthode a besoin.

Valeur renvoyée et comportement en place

Par défaut, DataFrame.interpolate() renvoie un nouveau DataFrame contenant le résultat de l’interpolation, sans modifier l’objet d’origine. Avec inplace=True, la méthode modifie le DataFrame d’origine et renvoie None ; n’affectez donc le résultat à une variable que lorsque vous utilisez le comportement par défaut.

import pandas as pd

df = pd.DataFrame({"reading": [1.0, None, 3.0]})
result = df.interpolate(inplace=True)
print(result)
print(df)

   reading
0      1.0
1      2.0
2      3.0
   reading
0      1.0
1      2.0
2      3.0

La première valeur affichée est None ; la seconde est le DataFrame modifié.