Fonctions sur les dataframes

Arrondir :

numpy.round(df, 2) : arrondi à 2 chiffres significatifs
on peut aussi faire : df['A'].round(4)

df['A'] = df['A'].abs() : pour avoir la valeur absolue

Calcul de fonctions d'aggrégations sur un dataframe :

on prend toujours le dataframe :

df = pandas.DataFrame({'A': [1.1, 2.7, 5.3], 'B': [2, 10, 9], 'C': [3.3, 5.4, 1.5], 'D': [4, 7, 15]},
                      index = ['a1', 'a2', 'a3'])
      A   B    C   D
a1  1.1   2  3.3   4
a2  2.7  10  5.4   7
a3  5.3   9  1.5  15

df.mean() : renvoie une Series des moyennes de chaque colonne (en ignorant les NaN) :
```
A    3.033333
B    7.000000
C    3.400000
D    8.666667
    
```
df.mean(skipna = False) : si il y a un NaN sur la ligne, la valeur sortie est NaN. Le défaut est True
df.mean(axis = 1) : calcule les moyennes par ligne plutôt que par colonne.
fonctions similaires à mean :
- min, max
- median : la médiane.
- std : la déviation standard (écart-type) qui par défaut est normalisée avec N-1 (mais on peut le changer avec le paramètre ddof qui vaut 1 par défaut : df.std(ddof = 0)).
- var : la variance normalisée avec N-1
- mad : la MAD.
- sum, prod : la somme, le produit.
Moyenne pondérée avec un dataframe : si df = pandas.DataFrame({'G': ['a', 'a', 'b', 'b', 'b'], 'val': [1, 2, 3, 4, 5], 'w': [2, 3, 1, 2, 4]})
df.groupby('G').apply(lambda x: numpy.average(x['val'], weights = x['w'])).reset_index() renvoie ici :
```
   G         0
0  a  1.600000
1  b  4.428571
    
```

Transformer un dataframe pour avoir des moyennes par ligne ou par colonne à 0 :

enlever à chaque ligne la moyenne de la ligne : df.sub(df.mean(axis = 1), axis = 0)
enlever à chaque colonne la moyenne de la colonne : df.sub(df.mean(axis = 0), axis = 1) (mais df.sub(df.mean()) suffit).
normaliser que pour chaque ligne ait la même somme : df.div(df.sum(axis = 1), axis = 0)

Quand on fait la somme d'un dataframe par colonne :

le résultat est une series.
pour avoir un dataframe avec les mêmes colonnes qu'à l'origine : pandas.DataFrame({'sum': df.sum()).transpose() (l'index de la ligne sera donc 'sum').

Index du maximum :

df.idxmin() : renvoie une Série qui donne pour chaque colone l'index où la valeur est minimale.
df.idxmin(axis = 1) : renvoie une Série qui donne pour ligne la colonne où la valeur est minimale.
df.idxmax : même chose pour le max.

quantile :

df.quantile(0.9) : renvoie la valeur seuil telle que 90% des valeurs sont en dessous.
on peut faire aussi : df.quantile([0.25, 0.5, 0.75])) : renvoie pour chaque variable en colonne les valeurs des différents quantile en ligne.
df['A'].quantile(0.75) : calcule le 3ème quantile sur la colonne A.

Somme cumulée sur un dataframe :

df2 = df.cumsum() : df2 a pour la 2ème ligne la somme des 2 premières de lignes de df, comme 3ème ligne la somme des 3 premières lignes de df, ...
df2 = df.cumsum(axis = 1) ou df2 = df.cumsum(axis = 'columns') : même chose, mais sur les colonnes
cumprod : idem que cumsum, mais pour les produits.

Application d'une fonction à un dataframe :

si df = pandas.DataFrame({'A': [1, 2, 3], 'B': [9, 8, 7]}) :
```
   A  B
0  1  9
1  2  8
2  3  7
    
```
alors df.apply(lambda x: x + 1) renvoie :
```
   A   B
0  2  10
1  3   9
2  4   8
    
```
(apply prend une fonction qui prend en argument une série)
on peut aussi appeler une fonction qui calcule un aggrégat : df.apply(lambda x: x.max()) : donne :
```
A    3
B    9
    
```
on peut aussi calculer sur les lignes plutôt que les colonnes : df.apply(lambda x: x.max(), axis = 1)
si la fonction n'est pas vectorisée, on doit utiliser applymap : df.applymap(lambda x: len(str(x)))

One hot encoding (transformation en valeurs binaires) : si df a des colonnes A et B qui sont de type object (des catégories), on peut créer un dataframe avec autant de colonnes avec des 0 et 1 pour A que de valeurs dans la colonne A et pareil pour B :

dfEncoded = pandas.get_dummies(df, columns = ['A', 'B'], dtype = float)
les noms des colonnes sont alors A_value1, A_value2, etc ... et A_value1 vaut 1 si la valeur était value1, sinon 0
dfEncoded = pandas.get_dummies(df, prefix = {'A': 'a', 'B': 'b'}, columns = ['A', 'B'], drop_first = True, dtype = float) : utilise comme noms de colonnes a_value (plutôt que A_value) et ne crée pas de colonne pour la première des valeur de chaque colonne A et B (car cette valeur peut être déduite des n - 1 autres colonnes).

df.corr() : renvoie un dataframe avec les corrélations entre chaque paire de colonne :

le dataframe renvoyé est donc de dimension nbrCol x nbrCol.
method = 'pearson' : corrélation de pearson (le défaut), sinon, il y aussi spearman et kendall.
les valeurs à NA sont ignorées.

programmer en python, tutoriel python, graphes en python, Aymeric Duclert