Cet article décrit toutes les fonctionnalités majeurs offertes par la bibliothèque Pandas. J’y démontre à quel point cet outil peut vous faire économiser du temps et de nombreux efforts lors de vos projets Data Science.

J’ai divisé cet article en trois sections. Bonne lecture 🙂

Si vous souhaitez tout connaître de la bibliothèque Pandas appliquée à la Data Science, suivez cette formation ici.

 

Section 1: Introduction à la bibliothèque Pandas

Cette section vous présente la bibliothèque Pandas et met également en évidence les 2 structures de données les plus importantes de la bibliothèque.

Pandas, c’est quoi?

  • Une des bibliothèques Python les plus utilisées pour la Data Science.
  • Développé en 2008 par Wes McKinney
  • Open source
  • Implémenté à partir de C – d’où sa rapidité
  • A introduit les objets DataFrame et Series

Comment je l’installe?

Le moyen le plus simple c’est d’installer Anaconda qui comprend immédiatement toutes les bibliothèques scientifiques standard dont Pandas fait parti.

Sinon Pandas peut être installé via pip depuis PyPI: $ pip install pandas

Qu’est ce qu’un objet Series?

  • Un objet Series est de 1 dimension comme un tableau. L’objet Series est un objet de données mutable. Cela signifie qu’il peut être mis à jour, que de nouveaux éléments peuvent être ajoutés et que des éléments existants peuvent être supprimés.
  • Il peut contenir des données de tout type.
  • Il peut être instancié avec un tableau ou un dictionnaire. Les clés du dictionnaire sont utilisées pour représenter les index.
  • Le constructeur de Series peut être appelé en transmettant données, index, type de données et un indicateur booléen indiquant si nous voulons copier les données. Si nous ne spécifions pas les noms d’index, les index sont étiquetés comme des entiers à partir de 0.
  • Considérez les objets Series comme des colonnes verticales pouvant contenir plusieurs lignes.

Créer une Series

import pandas as pd

series = pd.Series(data=[111, 222, 3], index = ['un','deux','trois'])

#ou series = pd.Series([111, 222, 3])

Récupérer des données d’une Series

Nous pouvons appliquer les fonctionnalités de sélection à partir de la position de la ligne dans le tableau. On peut aussi passer le nom de l’index:

print(series['deux'])
# ou
print(series[0])

# colonnes multiples
print(series[['un','trois']])
222
111
un       111
trois      3
dtype: int64

Qu’est ce qu’un objet DataFrame?

  • La structure de données la plus utilisée dans un projet de Data Science.
  • C’est un tableau avec des lignes et des colonnes, comme une table SQL ou une feuille de calcul Excel.
  • La table peut stocker en mémoire des données dans des formats différents.
  • Offre une analyse de séries chronologiques très performantes.
  • Un DataFrame contient une ou plusieurs Series.
  • Un DataFrame est mutable.

Voici schématiquement à quoi ressemble un DataFrame:

 ColonneA ColonneBColonneCColonneD
index0
index1
index2
index3
index4

Créer un DataFrame

Il existe plusieurs façons de créer un DataFrame: à partir d’un tableau, d’un dictionnaire, d’une liste, à partir d’une Series ou même d’un autre DataFrame. Je crée généralement un DataFrame à partir d’une Series:

import pandas as pd

d = {'ColonneA' : pd.Series([111, 222, 333]),
     'ColonneB' : pd.Series([444, 555, 666])}

df = pd.DataFrame(d)

Le DataFrame ci-dessus contiendra deux colonnes nommées ColonneA et ColonneB:

  • La colonne A contiendra trois lignes: 111 222 et 333.
  • La colonne B contiendra trois lignes: 444,555 et 666.

Sélection de colonne(s)

Nous pouvons utiliser le nom de la colonne pour obtenir les données:

data = df['ColonneA']
data
0    111
1    222
2    333
Name: ColonneA, dtype: int64

Pours supprimer une colonne, on utilise la fonction pop.

Sélection de ligne(s)

Si une ligne a une étiquette, nous pouvons utiliser la fonction loc:

data = df.loc['label']

# Colonnes multiples
data = df.loc[['label1', 'label2']]

Sinon, nous pouvons également utiliser la position en utilisant la fonction iloc:

data = df.iloc[0] # retourne la ligne d'indice 0 ou position 1
data
ColonneA    111
ColonneB    444
Name: 0, dtype: int64

Pour supprimer une ligne, on utilise la fonction drop.

Dans un DataFrame, nous pouvons appliquer un certain nombre de routines, par exemple, les colonnes peuvent être fusionnées, on peut appliquer des calculs mathématiques sur les lignes et/ou colonnes, on peut travailler sur des sous-ensembles du DataFrame.

Chaque colonne est indexée.

Renommer un nom de colonne

Nous pouvons utiliser rename(columns, index, inplace = False) pour renommer les colonnes d’un DataFrame. Si inplace = True, les données sous-jacentes seront renommées, la fonction ne retourne pas un nouvel objet. Lorsqu’on a inplace = False(valeur par défaut), il effectue l’opération et renvoie une copie de l’objet.

Réindexer

Si vous voulez réindexer (changer les étiquettes de ligne / colonne), alors nous pouvons utiliser la fonction reindex.

Itérer sur les colonnes d’un DataFrame

Pour parcourir les colonnes d’un DataFrame, nous pouvons faire:

for column in df:
  print(column)
ColonneA
ColonneB

Nous pouvons également parcourir les éléments d’un DataFrame:

for column,items in df.iteritems():
    print(column, items)
ColonneA 0    111
1    222
2    333
Name: ColonneA, dtype: int64
ColonneB 0    444
1    555
2    666
Name: ColonneB, dtype: int64

Pour parcourir les lignes:

for index_of_row, row in df.iterrows():
    print(index_of_row, row)
0 ColonneA    111
ColonneB    444
Name: 0, dtype: int64
1 ColonneA    222
ColonneB    555
Name: 1, dtype: int64
2 ColonneA    333
ColonneB    666
Name: 2, dtype: int64

itertuples() est utilisé pour afficher chaque ligne en tant qu’objet:

for row in df.itertuples():
    print(row)
Pandas(Index=0, ColonneA=111, ColonneB=444)
Pandas(Index=1, ColonneA=222, ColonneB=555)
Pandas(Index=2, ColonneA=333, ColonneB=666)

Un DataFrame est très puissant. Nous pouvons facilement trier les éléments par lignes et par colonnes.

Trier par ligne(s)

Nous pouvons trier par index de lignes en implémentant:

sorted_dataframe = dataframe.sort_index()

Trier par colonne(s)

Nous pouvons utiliser la méthode sort_index(axis = 1) pour trier par colonnes.

Nous pouvons également utiliser sort_values(by =’lis of columns’) pour trier par nombre de colonnes:

sorted_dataframe = dataframe.sort_values(by='ColonneA')

Les fonctions qu’on applique sur des string peuvent également l’être sur des colonnes / lignes d’un DataFrame, telles que lower(), upper(), len(), strip(), etc…

 

Section 2: Fonctionnalités de base Pandas (A connaître absolument)

Cette section fournit un aperçu des fonctionnalités indispensables offertes par Pandas. La plupart des cas d’utilisation courants de la manipulation de données peuvent être traités par les fonctionnalités de base que je décrirai ici:

Lire un fichier CSV

Commençons par la tâche la plus courante qui consiste à lire un fichier csv et à en créer un DataFrame:

import pandas as pd

dataFrame = pd.read_csv("fichier.csv",index_col=['ColonneA'])

Lire un fichier Excel

Nous pouvons lire un fichier Excel dans un DataFrame:

dataFrame = pd.read_excel('fichier_Excel.xlsx', index_col=['ColonneA'])

Nous pouvons également charger un feuillet du fichier Excel dans un DataFrame:

dataFrame = pd.read_excel(open('fichier_Excel.xlsx', 'rb'), sheet_name='Sheet1')

Head

On utilise head(n) pour retourner les n premières lignes d’un DataFrame:

r = dataFrame.head(10) # retourne les 1à premières lignes du dataframe

Tail

On utilise tail(n) pour retourner les n dernières lignes d’un DataFrame:

r = dataFrame.tail(10) # retourne les 10 dernières lignes du dataframe

Transposée

Pour échanger les lignes par les colonnes colonnes et vice versa, on utilise l’attribut T:

transposed = dataFrame.T

Il existe également des attributs clés à appliquer sur un DataFrame, tels que:

  • shape – retourne la dimension du DataFrame (nombre de lignes et colonnes)
  • size – nombre d’éléments
  • ndim – nombre d’axes

Describe

Pour obtenir un résumé rapide de votre DataFrame (moyenne, écart type, minimum, maximum et d’autres informations pour chacune des colonnes du DataFrame), on utilise la méthode describe():

dataFrame.describe()

Un DataFrame offre également un certain nombre de fonctions statistiques telles que:

  • abs() – valeurs absolues
  • mean() – Valeurs moyennes. On a aussi median() et mode()
  • min() – valeur minimale (et max())
  • count(), std() – écart type, prod() – pour calculer le produit des valeurs et cumsum() pour calculer les sommes cumulées, etc…

Parfois, nous voulons appliquer nos propres fonctions…

Fonction sur un DataFrame

Pour appliquer une fonction personnalisée à toutes les colonnes d’un DataFrame, on utilise la méthode pipe():

def myCustom(a,b):
 return a-b

dataFrame.pipe(myCustom, 1) # la dernier paramètre 1 est la valeur de b dans la fonction myCustom

Fonction sur une ligne/colonne

Si vous souhaitez appliquer une fonction à une ligne ou à une colonne, utilisez apply():

Ceci appliquera la fonction myCustom à toutes les colonnes:

def myCustom(a):
 return a-1

dataFrame.apply(myCustom)

Si vous souhaitez appliquer une fonction à chaque ligne:

On fixe axis = 1 par exemple:

dataFrame.apply(myCustom, axis=1)

A chaque colonne, axis = 0:

dataFrame.apply(myCustom, axis=0) # la valeur par défaut est 0

 

Section 3: Fonctionnalités Pandas plus avancées

Pandas est une bibliothèque fantastique pour effectuer des tâches d’analyse de données. Nous verrons dans cette section certaines fonctionnalités utiles dans dans la mise en place d’un projet de Data Science.

Sur un tel projet, nous sommes souvent confrontés à des données manquantes. Pour gérer les données manquantes, nous pouvons remplacer une valeur vide par une valeur prédéfinie ou compléter par la valeur précédente ou suivante.

Vérifier les valeurs manquantes

dataFrame.notnull()

Supprimer les valeurs manquantes

dataFrame.dropna()

Remplir les valeurs manquantes (les remplacer directement)

dataFrame.fillna(ScalarValue)

Nous pouvons également passer un dictionnaire et utiliser la méthode replace() pour remplacer les éléments par la valeur remplacée.

Remplir les valeurs manquantes – en amont ou en aval

dataFrame.fillna(method='backfill') #ffill pour remplir en aval

Comparaison des éléments en pourcentage

Nous pouvons comparer les éléments d’un DataFrame et calculer un pourcentage de variation de chaque élément avec son élément précédent:

dataFrame.pct_change() # par colonne
dataFrame.pct_change(axis=1) # par ligne

Calcul de l’écart-type

On peut faire std**2 pour trouver la variance de chaque colonne

dataFrame.std() #std de chaque colonne

Calcul de la covariance

Pour calculer la covariance entre deux colonnes d’un DataFrame:

dataFrame.cov() # entre toutes les colonnes
dataFrame['colonneA'].cov(dataFrame['colonneB']) # entre 2 colonnes

Calcul de la corrélation

dataFrame.corr() # entre toutes les colonnes

dataFrame['colonneA'].corr(dataFrame['colonneB']) # entre 2 colonnes

Colonnes d’agrégation

Un certain nombre de fonctions peuvent être appliquées à plusieurs colonnes d’un DataFrame à l’aide de la fonction aggregat():

dataFrame.aggregate({'NomColonne': function})

Grouper des lignes

On peut utiliser la fonction groupby():

groupedDataFrame = dataFrame.groupby('NomColonne')

# Grouper plusieurs colonnes
groupedDataFrame = dataFrame.groupby(['ColonneA', 'ColonneB')

Pour voir les groupes:

groupedDataFrame.groups

Pour sélectionner un groupe:

groupedDataFrame.get_group(key)

Filtrer

On peut exécuter filter(function) pour filtrer des lignes:

dataFrame.filter(myCustomFunction) #myCustomFunction takes in a parameter and returns a value

Fusionner

La fusion de deux DataFrames est probablement l’une des tâches les plus importantes en Data Science. Pandas propose des fonctionnalités permettant de joindre plusieurs DataFrames sur la base de jointures gauche, droite, intérieure et extérieure.

La fonction à appliquer pour cela est merge(). Elle prend en paramètre le DataFrame de gauche, le DataFrame de droite, le paramètre on définissant les colonnes à joindre et le paramètre how décrivant le type de jointure: left (gauche), right (droite), outer (extérieur) ou inner (intérieur).

Remarque: Si nous voulons choisir différentes colonnes dans les DataFrames de gauche et de droite, nous pouvons utiliser les paramètres left_on et right_on et spécifier les noms des colonnes. Les colonnes peuvent être une liste de colonnes.

merged = pd.merge(left,right,left_on='name',right_on='id', how='left')

Unir deux DataFrames

Pour concaténer 2 DataFrames, on utilise la fonction concat():

pd.concat([df1, df2])

Opérations sur les dates

Pandas a des fonctionnalités pour calculer les dates dans un DataFrame. On peut utiliser:

pd.date_range(début, fin)

Graphiques

Les DataFrames offrent des options pour tracer des graphiques. Nous pouvons tracer des courbes, des boîtes à moustaches, des surfaces, des nuages de points, des graphiques empilés, des diagrammes à barres, des histogrammes, etc…

dataFrame.plot.bar() # retourne un diagramme à barres

dataFrame.diff.hist(bins=10) # retourne un histogramme

dataFrame.plot.scatter() # retourne un graphique de nuage de points

 

Conclusion

Cet article représente seulement un aperçu de la puissance de la bibliothèque Pandas. Mais ça représente une bonne boîte à outils des “indispensables”.

Si vous souhaitez allez plus loin, je vous propose un article d’analyse de données à l’aide de la bibliothèque Pandas, cliquez ici pour le lire.

Et si vous souhaitez maîtriser complètement Pandas ainsi que Numpy appliqués à la Data Science, je vous invite à suivre ma formation d’Analyse et Visualisation de données.