# Pandas fillna() : la méthode pour gérer les valeurs NaN dans vos DataFrames

La fonction Python Pandas `DataFrame.fillna()` est utilisée pour **remplacer les valeurs manquantes dans un DataFrame**. Cela est utile dans de nombreux cas pour faciliter les processus de nettoyage de données ou pour effectuer des analyses.

Definition Une valeur NaN (« *Not a Number* ») représente une donnée manquante ou indéfinie dans un DataFrame Pandas. Elle survient lorsque des données sont absentes ou qu’une opération ne peut pas produire un résultat valide. Pandas utilise NaN pour indiquer ces absences, permettant ainsi de les gérer efficacement avec des fonctions comme `fillna()`.

## Pandas `fillna()` : comment se présente la syntaxe de la méthode ?

La fonction `fillna()` prend **jusqu’à cinq paramètres** et est syntaxiquement structurée comme suit :

```python
DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None)
```

### Quels sont les paramètres pertinents ?

Le comportement de `DataFrame.fillna()` de Pandas peut être adapté à l’aide de différents paramètres :

<table>
  <thead>
    <tr>
      <th><strong>Paramètres</strong></th>
      <th><strong>Description</strong></th>
      <th><strong>Valeur par défaut</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`value`</td>
      <td>Une valeur mise à l’échelle ou un dictionnaire Python ou une série pour remplacer les NaNs</td>
      <td>`None`</td>
    </tr>
    <tr>
      <td>`method`</td>
      <td>Indique la méthode de remplissage ; remplissage avant (`ffill`) ou remplissage arrière (`bfill`)</td>
      <td>`None`</td>
    </tr>
    <tr>
      <td>`axis`</td>
      <td>Détermine l’axe le long duquel l’opération est effectuée (`0` ou `index` pour les lignes, `1` ou `columns` pour les colonnes)</td>
      <td>`0`</td>
    </tr>
    <tr>
      <td>`inplace`</td>
      <td>Si `True`, les modifications sont effectuées directement dans le DataFrame d’origine</td>
      <td>`False`</td>
    </tr>
    <tr>
      <td>`limit`</td>
      <td>Entier limitant le nombre de valeurs NaN à remplacer</td>
      <td>`None`</td>
    </tr>
  </tbody>
</table>

Note Dans les versions futures, le paramètre `method` **ne sera probablement plus supporté**. Les programmeurs pourront alors avoir recours à `obj.ffill()` ou `obj.bfill()`. Ces deux fonctions ont le même effet que le paramètre `method` correspondant.

## Dans quels cas applique-t-on la méthode `DataFrame.fillna()` de Pandas ?

La fonction Pandas `fillna()` peut être utilisée de différentes manières :

### Remplacer des valeurs NaN par une valeur fixe

Dans un premier temps, on définit un DataFrame :

```python
import pandas as pd
# Exemple de DataFrame avec différentes valeurs
data = {
    'A' : [1, 2, None, 4],
    'B' : [None, 2, 3, 4],
    'C' : [1, None, 3, 4]
}
df = pd.DataFrame(data)
print(df)
```

Le DataFrame que nous venons de définir se présente comme suit :

```none
A    B    C
0  1.0  NaN  1.0
1  2.0  2.0  NaN
2  NaN  3.0  3.0
3  4.0  4.0  4.0
```

Note Notez que dans Python Pandas, la valeur `None` est interprétée comme `NaN` dans les DataFrames et Series, notamment pour les colonnes de types numériques ou flottants.

Pour remplacer maintenant les valeurs manquantes par la valeur 0, on peut utiliser la fonction Pandas `fillna()` :

```python
# Remplacer les valeurs manquantes par la valeur 0
df_filled = df.fillna(0)
print(df_filled)
```

Au final, chaque NaN a été remplacé par la valeur 0 passée à la fonction :

```none
A    B    C
0  1.0  0.0  1.0
1  2.0  2.0  0.0
2  0.0  3.0  3.0
3  4.0  4.0  4.0
```

### Utilisation de la méthode de remplissage vers l’avant `ffill`

Si les valeurs NaN doivent être remplies avec les valeurs précédentes de chaque colonne, on peut utiliser la méthode `ffill` qui est passée en paramètre à la fonction :

```python
# Remplacement de toutes les valeurs NaN par la valeur précédente
df_ffill = df.fillna(method='ffill')
print(df_ffill)
```

Dans cet exemple, les valeurs NaN des colonnes A et C ont été remplacées par les valeurs précédentes de la même colonne. Comme il n’y avait pas de valeur précédente dans la colonne B, la valeur NaN y est restée :

```none
A    B    C
0  1.0  NaN  1.0
1  2.0  2.0  1.0
2  2.0  3.0  3.0
3  4.0  4.0  4.0
```

### Utilisation ligne par ligne de la méthode de remplissage arrière `bfill`

Les valeurs NaN peuvent également être remplacées par les valeurs suivantes de la même ligne. Pour cela, il ne suffit pas d’utiliser la méthode `bfill`, il est également nécessaire de définir le paramètre `axis` à 1 :

```python
df_bfill = df.fillna(method='bfill', axis=1)
print(df_bfill)
```

Les valeurs NaN de la première et de la troisième ligne ont été remplacées par leurs successeurs respectifs. Il ne reste une valeur NaN que dans la première colonne, car aucune valeur suivante n’est disponible dans cette ligne.

```none
A    B    C
0  1.0  1.0  1.0
1  2.0  2.0  NaN
2  3.0  3.0  3.0
3  4.0  4.0  4.0
```


This is a markdown version of: [https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/python-pandas-dataframe-fillna/](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/python-pandas-dataframe-fillna/) for AI/LLM consumption.