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)
- attention, df.apply ne marche pas par élément, mais seulement par ligne ou par colonne.
- 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.
