Datascience avec Python - Pandas Part. 2

C'est article est la suite directe de celui ci : Datascience avec Python - Pandas Part. 1, il vaut mieux donc le lire si jamais ce n'est pas encore fait !

Nous allons voir quelques fonctionnalités supplémentaires de Pandas utiles pour la datascience, relatives à la manipulation de DataFrames.

Rechercher dans un DataFrame

Il existe deux méthodes de recherche dans un DataFrame :

• Recherche par index (avec .loc)
• Recherche numérique (avec .iloc)

Nous allons voir des exemples pour ces trois méthodes :

>>> df = pd.DataFrame(np.random.randn(4, 4),
... index=['a', 'b', 'c', 'd'], columns=['W', 'X', 'Y', 'Z'])
>>> df.loc['a']
W   -0.685810
X    1.080100
Y   -0.182362
Z   -0.345655
Name: a, dtype: float64

On passe simplement l'index de la ligne qu'on souhaite récupérer à loc. Attention, on utilise des crochets, et non des parenthèses avec loc, avec iloc aussi d'ailleurs :

>>> df.iloc[0]
W   -0.685810
X    1.080100
Y   -0.182362
Z   -0.345655
Name: a, dtype: float64

Cette fois ci, on passe le numéro de la ligne qu'on souhaite récupérer. Ici, nous récupérons la première ligne, qui est celle d'index 'a', donc le résultat est le même que plus haut.

Vous pouvez également utiliser iloc pour localiser une valeur précise d'un DataFrame, il faut pour cela préciser un deuxième paramètre :

>>> df.iloc[0, 1]
1.0801001659502196

On récupère une unique valeur, qui est celle située sur la première ligne, et la deuxième colonne.

Slices de DataFrames

Vous connaissez déjà les slices de listes. Eh bien, les DataFrames suivent le même principe, et vous pouvez en réaliser des slices aussi :

>>> df.iloc[0:2, 1:4]
         X         Y         Z
a  1.08010 -0.182362 -0.345655
b -1.37358 -1.281428  0.404348

Le premier paramètre est toujours l'index des lignes, et le second les colonnes.

Filtrer des DataFrames

Il est possible de filtrer des DataFrames en utilisant la méthode filter :

>>> df.filter(items=['X', 'Z'])
          X         Z
a  1.080100 -0.345655
b -1.373580  0.404348
c -0.709096  1.534505
d  0.375666 -1.868358

Par défaut, on doit passer en paramètre les noms des colonnes qu'on souhaite récupérer. Mais on peut passer un paramètre supplémentaire pour préciser si on souhaite filtrer selon les lignes ou les colonnes :

>>> df.filter(items=['a', 'b'], axis=0)
          W        X         Y         Z
a -0.685810  1.08010 -0.182362 -0.345655
b -0.892771 -1.37358 -1.281428  0.404348

axis = 0 est utilisé pour travailler selon les lignes, et axis = 1 selon les colonnes :

>>> df.filter(items=['W', 'Y'], axis=1)
          W         Y
a -0.685810 -0.182362
b -0.892771 -1.281428
c -0.378246 -0.611104
d -1.180025 -1.062157

Par défaut, axis vaut 1.

En fait, filtrer les DataFrames est une autre façon de réaliser des slices de DataFrames.

Transformation de DataFrames

La transformation de DataFrames consiste à réaliser des opérations sur l'ensemble des données d'un DataFrame. Par exemple passer toutes les valeurs d'un DataFrame au carré. Pour cela, il suffit d'utiliser la méthode transform et de lui passer en paramètre la fonction qu'on souhaite exécuter pour chaque valeur. On peut également préciser un paramètre axis qui permet soit de travailler sur les colonnes, soit sur les lignes. Par défaut, on travaille sur tout le DataFrame.

>>> df.transform(lambda x: abs(x))
          W         X         Y         Z
a  0.685810  1.080100  0.182362  0.345655
b  0.892771  1.373580  1.281428  0.404348
c  0.378246  0.709096  0.611104  1.534505
d  1.180025  0.375666  1.062157  1.868358

Il est également possible de passer des chaînes de caractères en paramètre. Pandas est intelligent et comprendra de quoi vous lui parlez !

>>> df.transform('sqrt')
    W         X   Y         Z
a NaN  1.039279 NaN       NaN
b NaN       NaN NaN  0.635884
c NaN       NaN NaN  1.238751
d NaN  0.612916 NaN       NaN

On peut également passer une liste de fonctions en paramètre :

>>> pow2 = lambda x: x**2
>>> df.transform(['abs', pow2])
          W                   X                   Y                   Z
        abs  <lambda>       abs  <lambda>       abs  <lambda>       abs  <lambda>
a  0.685810  0.470335  1.080100  1.166616  0.182362  0.033256  0.345655  0.119477
b  0.892771  0.797040  1.373580  1.886721  1.281428  1.642059  0.404348  0.163497
c  0.378246  0.143070  0.709096  0.502817  0.611104  0.373448  1.534505  2.354705
d  1.180025  1.392458  0.375666  0.141125  1.062157  1.128178  1.868358  3.490761

Multi Index

Il est possible d'appliquer une hiérarchie d'index à un DataFrame :

>>> index = pd.MultiIndex.from_product([['A0', 'A1'], ['B0', 'B1']])
>>> df.set_index(index, inplace=True)
>>> df
              W         X         Y         Z
A0 B0 -0.685810  1.080100 -0.182362 -0.345655
   B1 -0.892771 -1.373580 -1.281428  0.404348
A1 B0 -0.378246 -0.709096 -0.611104  1.534505
   B1 -1.180025  0.375666 -1.062157 -1.868358
>>> df.loc['A0']
           W        X         Y         Z
B0 -0.685810  1.08010 -0.182362 -0.345655
B1 -0.892771 -1.37358 -1.281428  0.404348
>>> df.loc['A0'].loc['B0']
W   -0.685810
X    1.080100
Y   -0.182362
Z   -0.345655

Bon, j'avoue ça devient un peu compliqué, on va donc s'arrêter là, mais sachez qu'il existe d'autres façons pour manipuler les index multiples, par exemple en utilisant l'objet pd.IndexSlice.

Fonctions d'Agrégation

Les fonctions d'agrégation permettent d'appliquer des opérations et d'obtenir un nouveau DataFrame. Regardez cet exemple :

>>> df = pd.DataFrame(np.random.randn(6, 4),
... index=['a', 'b', 'c', 'd', 'e', 'f'], columns=['W', 'X', 'Y', 'Z'])
>>> df
          W         X         Y         Z
a -0.479467  0.789129 -0.048831 -0.480756
b  0.035190  0.133753  1.024468 -1.195560
c  0.216062 -1.002952 -2.619329 -1.175844
d -0.300054  0.375230  1.268467 -0.730578
e  0.321306  1.207144  0.362257  0.280210
f -0.894699 -0.978659  0.836635  0.608449
>>> df.count()
W    6
X    6
Y    6
Z    6
dtype: int64
>>> df.iloc[0, 0] = np.nan
>>> df.count()
W    5
X    6
Y    6
Z    6
>>> df.count(axis=1)
a    3
b    4
c    4
d    4
e    4
f    4
dtype: int64

df.count permet d'obtenir un DataFrame contenant le nombre de valeurs dans chaque ligne, ou chaque colonne en fonction du paramètre axis.

Il existe un tas de fonction d'agrégation, à vous de les essayer :

• count()
• value_count()
• mean()
• median()
• sum()
• min()
• max()
• std()
• var()
• describe()
• sem()

Le mot de la fin

C'est tout pour cet article, on a vu tout ce qu'il y a à savoir sur Pandas pour la datascience. Bon, pas tout à fait, il existe d'autres fonctionnalités, mais un peu trop complexes pour nous, par exemple on peut fusionner des DataFrames en précisant le mode de jointure, ou alors la manipulation d'index multiples, etc... Vous apprendrez ces fonctionnalités lorsque vous en aurez besoin !

Si l'article vous a plu et que vous souhaitez faire un retour, ou alors si vous avez des questions, n'hésitez pas à me contacter ou à laisser un commentaire.

On se retrouve dans un prochain article pour la suite de votre apprentissage de la datascience avec Python !