Maîtrisez l’analyse des données avec Pandas Python

Vous souhaitez mener des analyses de données avec Python ? Panda Python vous évoque quelque chose ?

Il faut savoir que la tâche principale attendue pour les Data Analysts ou les Business Analysts en entreprise est l’analyse de données. Cela implique notamment, le croisement de données à large échelle, l’uniformisation de données, les jointures, la validation de données sur la base de contraintes sémantiques, ou encore la connexion aux bases de données distantes.

Toutes ces tâches sont très difficiles et requièrent généralement l’utilisation de multiples bibliothèques : le SQL, le JDBC, une API de manipulation de JSON comme Jackson databind, etc…

Python met à portée l’analyse complexe de données grâce à une seule API : Panda Python. Sous son nom d’animal, Pandas est une puissante bibliothèque polyvalente qui va vous permettre de réaliser facilement des analyses complexes de données.

Si vous souhaitez travailler dans le Big Data, spécialement en tant que Data Analyst, ou si vous souhaitez simplement être capable d’effectuer des recettes pour valider les résultats des applications de votre entreprise, alors Pandas est LA bibliothèque à maîtriser.

Dans ce tutoriel exhaustif, nous allons vous aider à démarrer sur Pandas.

Panda : une bibliothèque incontournable pour le traitement de données en Python

Je suis certain que vous vous posez la question pourquoi le nom Panda ? Ferait-il référence à ces animaux mignons qui ressemble à des ours ?  Non pas du tout ! Le nom « Pandas », fait référence à la fois à « Panel Data » et à « Python Data Analysis » mais cela n’a rien à avoir avec l’animal.

Pandas est une bibliothèque open-source permettant la manipulation et l’analyse de données de manière simple et intuitive en Python. Elle a été développée par Wes McKinney en 2008 alors qu’il travaillait chez AQR Capital Management. À la fin de l’année 2009, elle a été mise en open source et est aujourd’hui activement utilisée dans le domaine de la Big data et de la data science car celle-ci offre des performances et une productivité élevée à ces utilisateurs.

L’une des forces de Panda est qu’il se base sur la très populaire bibliothèque NumPy. Elle fournit diverses structures de données et opérations pour le traitement de données numériques et de séries chronologiques. En plus de cela, les données produites par Panda sont souvent utilisées comme données en entrée pour les fonctions de plotting de Matplotlib, l’analyse statistique en SciPy, les algorithmes de machine learning en Scikit-learn. Les data scientists l’utilisent pour le chargement, le traitement et l’analyse des données tabulaires (données stockées sous format .csv, .tsv ou .xlsx) à l’aide de requêtes de type SQL.

Pourquoi utiliser Panda Python ?

Maintenant que le mystère est levé sur ce que c’est que Pandas et son importance dans le domaine de la data, nous détaillerons dans cette partie les principaux points forts de cet outil.

Ce qui fait la force de Panda est qu’elle :

• fournit une structure de donnée appelée Dataframe rapide et efficace pour la manipulation des données avec indexation intégrée ;
• dispose d’outils pour lire et écrire dans des fichiers de différents formats (.csv, .txt, .xlsx, .sql, .hdf5, etc…) ;
• offre une flexibilité pour traiter les données de type hétérogènes ou manquantes ;
• est open source ;
• fournit une documentation très détaillée et facile à lire ;
• est utilisée dans une grande variété de domaines universitaires et commerciaux, notamment la finance, les neurosciences, l’économie, les statistiques, la publicité, l’analyse Web.

Démarrez avec Panda Python

Dans cette partie de l’article nous allons vous montrer comment installer pandas et nous étudierons les différentes structures qu’il propose.

Pour une meilleure maîtrise de la bibliothèque, vous devez avoir une connaissance de base sur le langage de programmation python. Nous avons un article qui traite particulièrement de ce sujet.

Installation de Pandas

La façon la plus simple d’installer non seulement Panda, mais aussi Python et ses packages les plus populaires (IPython, NumPy, Matplotlib, ...) est avec Anaconda, une distribution Python multiplateforme (Linux, macOS, Windows) pour l’analyse de données et le calcul scientifique.

Après avoir exécuté le programme d’installation, vous aurez accès à Pandas et au reste de l’écosystème SciPy sans avoir besoin d’installer un autre logiciel, ce qui rend l’outil pratique. Les instructions d’installation pour Anaconda sont disponibles ici.

Nous utiliserons dans la suite de cet article l’outil Jupyter Notebook pour écrire nos codes. Il est intégré directement dans Anaconda.

Après l’installation de Pandas et pour commencer à l’utiliser, vous devez l’importer dans votre script comme suit :

import pandas as pd

Ici, pd est considéré comme un alias de Pandas. Cependant, il n’est pas nécessaire d’importer la bibliothèque en utilisant un alias, cela permet simplement d’écrire moins de code à chaque fois qu’une méthode ou une propriété est appelée.

Alors démarrons sans plus tarder à étudier les structures de données proposées par Pandas pour la manipulation et l’analyse de données.

Les principales structures de données de Python Panda

Pandas fournit généralement deux structures de données pour manipuler les données, ce sont : les Series et les Dataframe.

Les series

Une série est un tableau étiqueté unidimensionnel pouvant contenir tout type de données (entiers, chaînes de caractères, nombres à virgule flottante, objets Python, etc.). Les étiquettes des axes représentent l’index de la série. Pour être plus simple, une série n’est rien d’autre qu’une colonne dans une feuille Excel. La méthode de base pour créer une série est la suivante :

ser = pd.Series(data,  index=index)

data peut être un dictionnaire Python, un ndarray (tableau multi-dimensionnel de NumPy) ou même une valeur scalaire.

L’index passé en argument est une liste d’étiquettes correspondant à chaque ligne de la série.

Création d’un objet Series grâce à un dictionnaire

Nous pouvons créer une série à partir d’un dictionnaire. L’index de cette série aura automatiquement les étiquettes correspondant aux clés du dictionnaire

Voyons par exemple la création d’un objet Series représentant la note obtenue d’un élève pour trois matières dans le code qui suit :

import pandas as pd

notes = {"Mathématiques": 19, "Français": 12, "Dessin": 15}
ser = pd.Series(notes)

print(ser)

print (ser.index) #affiche l'index de la série

print (ser.array) #affiche la data de la série

print("Meilleure note {}".format(ser["Mathématiques"]))

#vérifie si l'étiquette Sciences Physiques est présente dans l'index 
a = "Sciences Physiques" in ser 

print(a)

Le résultat de ces instructions est le suivant :

Mathématiques    19
Français         12
Dessin           15
dtype: int64
Index(['Mathématiques', 'Français', 'Dessin'], dtype='object')

[19, 12, 15]
Length: 3, dtype: int64
Meilleure note 19
False

Une série crée à partir d’un dictionnaire peut voir un index de taille différente de la taille du dictionnaire. Génial non ?

Maintenant, voyons cela avec un exemple concret avec ce code :

import pandas as pd

notes = {"Mathématiques": 19, "Français": 12, "Dessin": 15}
ser = pd.Series(notes, index=["Mathématiques", "Français", "Sciences Physiques", "Dessin" ])
ser

Le résultat de celui-ci est :

Mathématiques         19.0
Français              12.0
Sciences Physiques     NaN
Dessin                15.0
dtype: float64

Création d’un objet Series grâce à un ndarray

Si data est un ndarray, l’index passé en paramètre doit être de la même longueur que data. Si aucun index n’est passé, un index sera créé avec les valeurs [0, …, len(data) – 1].

Prenons un autre exemple en créant un objet Series représentant le nombre d’habitants de trois pays :

import numpy as np
import pandas as pd

ser = pd.Series(np.array([67060000, 83020000, 328200000]), index=["France", "Allemagne", "Etats-Unis"])
ser

Vous allez obtenir le résultat suivant en exécutant le code ci-dessus :

France         67060000
Allemagne      83020000
Etats-Unis    328200000
dtype: int32

Création d’un objet Series grâce à une valeur scalaire

Si le paramètre data est une valeur scalaire, un index doit être fourni. La valeur sera répétée pour correspondre à la longueur de l’index.

Illustrons cela par l’exemple qui suit :

import pandas as pd
ser = pd.Series(5.0, index=["a", "b", "c", "d"])
ser

a    5.0
b    5.0
c    5.0
d    5.0
dtype: float64

L’attribut name d’un objet Series

Par défaut, une série ne possède pas de nom mais il possible de la nommer grâce à l’attribut name. Voyons cela tout de suite :

import pandas as pd
import numpy as np
data = np.array([67060000, 83020000, 328200000])
ser = pd.Series(data, index=["France", "Allemagne", "Etats-Unis"], name="Série nombre d'habitants")
ser

Vous aurez donc le nom de la Serie comme ceci :

France         67060000
Allemagne      83020000
Etats-Unis    328200000
Name: Série nombre d'habitants, dtype: int32

Vous vous demandez peut-être comment modifier le nom de la série. C’est simple ! On utilise juste la méthode rename()

import pandas as pd
import numpy as np
data = np.array([67060000, 83020000, 328200000])
ser = pd.Series(data, index=["France", "Allemagne", "Etats-Unis"], name="Série nombre d'habitants")
print(ser)

ser2 = ser.rename("Nb habitants") #ser et ser2 sont deux objets différents

print(ser2) 

La Dataframe : la structure de données la plus puissante de Pandas

La Dataframe est une structure de données qui organise les données en lignes et en colonnes, ce qui en fait une structure de données bidimensionnelle. Vous pouvez l’imaginer comme une feuille de calcul ou une table SQL, ou encore un dictionnaire d’objets Series. C’est généralement l’objet pandas le plus utilisé. Comme une série, un Dataframe peut être construit à partir de nombreux types différents :

•     Un dict de ndarrays 1D, listes, dicts, ou Series ;
•     Un numpy.ndarray bidimensionnelle ;
•     Un ndarray strucuré ;
•     Une série ;
•     Ou encore un autre Dataframe.

La méthode de base pour créer une Dataframe est la suivante :

df= pd.Dataframe(data,  index=index, columns=columns)

Ici, l’index représente l’ensemble des étiquettes de lignes et columns l’ensemble des étiquettes de colonnes.

Alors qu’est-ce qui fait vraiment la puissance de cette structure ?

La Dataframe Pandas est puissante car :

• Elle peut facilement charger des données provenant de différentes sources de données et de différents formats de données ;
• Elle vous permet de réaliser facilement des statistiques et répondre à des questions sur les données, telles que : Quelle est la moyenne, la médiane, le maximum ou le minimum de chaque colonne ?  Y a-t-il une corrélation entre la colonne A et la colonne B ? À quoi ressemble la distribution des données de la colonne C ? ;
• Elle facilite également le nettoyage les données en supprimant les valeurs manquantes et en filtrant les lignes ou les colonnes selon certains critères
• Elle permet de visualiser les données avec l’aide de Matplotlib. Tracez des barres, des lignes, des histogrammes, des bulles, etc. ;
• Elle permet de stocker les données nettoyées et transformées dans un CSV, un autre fichier ou une base de données.
• Vous pouvez définir vos propres fonctions Python pour certaines tâches de calcul et les appliquez aux données de vos Dataframes.

Création d’une Dataframe à partir d’un dictionnaire de séries

L’index du Dataframe résultant sera l’union des index des différentes Series.  Voyons cela avec l’exemple suivant :

import pandas as pd
notes = {
         "Mathématiques": pd.Series([18.0, 20.0, 17.0], index=["Sylvie", "Gilles", "Sylvain"]),
         "Sciences Physiques": pd.Series([15.0, 7.0, 10.0,20.0],index=["Sylvie", "Gilles", "Sylvain", "Thomas"]),
    }

df = pd.Dataframe(notes)
df

Le tableau suivant représente le résultat :

Les étiquettes des lignes et des colonnes sont accessibles respectivement en accédant aux attributs index et columns de la façon suivante :

import pandas as pd
notes = {
         "Mathématiques": pd.Series([18.0, 20.0, 17.0], index=["Sylvie", "Gilles", "Sylvain"]),
         "Sciences Physiques": pd.Series([15.0, 7.0, 10.0,20.0],index=["Sylvie", "Gilles", "Sylvain", "Thomas"]),
    }

df = pd.Dataframe(notes)
print(df.index)
print(df.columns)

Index(['Gilles', 'Sylvain', 'Sylvie', 'Thomas'], dtype='object')
Index(['Mathématiques', 'Sciences Physiques'], dtype='object')

Création d’une Dataframe à partir d’un dictionnaire de ndarray ou de liste

Les ndarrays doivent tous être de la même longueur. Si un index est passé, il doit aussi être de la même longueur que les tableaux. Si aucun index n’est passé, le résultat sera range(n), où n est la longueur du tableau.

Prenons un exemple :

import pandas as pd

data = {"Prenom": ["Sylvie", "Gilles", "Sylvain", "Thomas"], "Age": [18.0, 23.0, 25.0, 40.0]}

df = pd.Dataframe(data)
print(df)

Avec ces instructions, le résultat est :

   Prenom   Age
0   Sylvie  18.0
1   Gilles  23.0
2  Sylvain  25.0
3   Thomas  40.0

Sélection des données

Maintenant que nous avons fait le tour sur comment créer les différentes structures de la bibliothèque Pandas nous allons voir comment sélectionner les données présentes dans ces structures.

Créer un objet Series ou un Dataframe est bien beau maintenant il faut savoir comment accéder aux données enregistrées dans ces structures.

Dans cette partie de cet article nous verrons quelles sont les différentes fonctions proposées par la librairie Pandas pour la sélection intelligente des données.

Accès aux données d’un objet Series

Il existe principalement trois méthodes d’accès spécifiques à Pandas :

• L’opérateur d’indexation [] ;
• Les méthodes fournis par Pandas .loc() et .iloc() ;
• Utiliser l’opérateur d’indexation.

Rappelons qu’une série possède deux indices :

•     Un index positionnel ou implicite, qui est toujours un RangeIndex ;
•     Un index explicite, qui peut contenir n’importe quel objet hachable.

Vous pouvez accéder facilement aux valeurs d’un objet Series à l’aide des étiquettes et des indices de position, comme ceci :

import pandas as pd

notes = {"Mathématiques": 19, "Français": 12, "Dessin": 15, "Sciences Physiques": 18, "Biologie": 17}
	
ser = pd.Series(notes)

print(ser["Mathématiques"])
print(ser[1])

Et vous obtiendrez le résultat suivant :

19
12

Vous pouvez également utiliser des indices négatifs et des tranches, comme vous le feriez pour une liste :

import pandas as pd

notes = {"Mathématiques": 19, "Français": 12, "Dessin": 15, "Sciences Physiques": 18, "Biologie": 17}

ser = pd.Series(notes)

print(ser[-2])

print("*********************")

print(ser[2:])

print("*********************")

print(ser["Français": "Biologie"])

Cette fois-ci, le résultat sera :

18
*********************
Dessin                15
Sciences Physiques    18
Biologie              17
dtype: int64
*********************
Français              12
Dessin                15
Sciences Physiques    18
Biologie              17
dtype: int64

Utilisation des méthodes .loc() et .iloc()

L’opérateur d’indexation ([]) est pratique, mais il y a un bémol. Que faire si les étiquettes sont également des nombres ? Supposons que vous ayez à travailler avec un objet Series comme celui-ci :

import pandas as pd

fleurs = pd.Series(["rose", "tournesol", "muguet", "tulipe", "violette"], index=[1, 2, 3, 5, 8])

Que retournera fleurs[1] ? Si l’on se base sur les positions, fleurs[1] renvoie « tournesol ». Cependant, si l’on se base sur les étiquettes, alors fleurs[1] renvoie  « rose ».

La bonne nouvelle, c’est que vous n’avez pas à vous poser ces questions ! En effet, pour éviter toute confusion, la bibliothèque Python Pandas fournit deux méthodes d’accès aux données :

• loc() fait référence  l’étiquette.
• iloc() fait référence à l’indice de position.

Si nous reprenons l’objet Series définit ci-dessus, les instructions suivantes :

print(fleurs.loc[1])
print(fleurs.iloc[1])

produit cet affichage:

rose
tournesol

.loc() et .iloc() prennent également en charge les fonctionnalités que vous attendez des opérateurs d’indexation, comme le découpage en tranches. Toutefois, ces méthodes d’accès aux données présentent une différence importante. Alors que .iloc() exclut l’élément de fermeture, .loc() l’inclut.

En résumé :

•  Vous pouvez utiliser .iloc() sur un objet Series de manière similaire à l’utilisation de l’opérateur d’indexation [] sur une liste.
•  Vous pouvez utiliser .loc() sur une série comme vous le feriez avec l’opérateur d’indexation [] sur un dictionnaire.

Accès aux données d’un Dataframe

Vous pouvez utiliser les mêmes outils d’accès aux éléments d’un objet Series avec un Dataframe car un Dataframe n’est qu’un ensemble d’objets Series. La différence essentielle réside dans la dimension supplémentaire du Dataframe. Vous utiliserez l’opérateur d’indexation pour les colonnes et les méthodes d’accès .loc() et .iloc() pour les lignes.

Utilisation de l’opérateur d’indexation

Si vous considérez un Dataframe comme un dictionnaire dont les valeurs sont des séries, il est logique que vous puissiez accéder à ses colonnes avec l’opérateur d’indexation comme ceci :

import pandas as pd
notes = pd.Dataframe({
         "Mathématiques": pd.Series([18.0, 20.0, 17.0], index=["Sylvie", "Gilles", "Sylvain"]),
         "Sciences Physiques": pd.Series([15.0, 7.0, 10.0,20.0],index=["Sylvie", "Gilles", "Sylvain", "Thomas"]),
    })

notes["Mathématiques"] #accès à la colonne Mathématiques

Gilles     20.0
Sylvain    17.0
Sylvie     18.0
Thomas      NaN
Name: Mathématiques, dtype: float64

Ici, vous utilisez l’opérateur d’indexation pour sélectionner la colonne intitulée « Sciences Physiques ».

Si le nom de la colonne est une chaîne de caractères, vous pouvez également utiliser un accès de type attributaire avec la notation par point c’est à dire en utilisant le Dataframe défini dans le code ci-dessus le code suivant :

notes.Mathématiques

notes[« Mathématiques »] et notes.Mathématiques renvoient le même résultat.

Utilisation des méthodes .loc() et .iloc()

Comme pour un objet Series, un Dataframe fournit également des méthodes d’accès aux données .loc() et .iloc(). Rappelez-vous que .loc() utilise l’étiquette et .iloc() l’index positionnel. Voyons cela avec l’exemple suivant :

import pandas as pd
notes = pd.Dataframe({
         "Mathématiques": pd.Series([18.0, 20.0, 17.0], index=["Sylvie", "Gilles", "Sylvain"]),
         "Sciences Physiques": pd.Series([15.0, 7.0, 10.0,20.0],index=["Sylvie", "Gilles", "Sylvain", "Thomas"]),
    })
print(notes)
print("*********************")
print(notes.loc["Gilles"])
print("*********************")
print(notes.iloc[1])

Le résultat de cet exemple est :

1	         Mathématiques  Sciences Physiques
2	Gilles            20.0                 7.0
3	Sylvain           17.0                10.0
4	Sylvie            18.0                15.0
5	Thomas             NaN                20.0
6	*********************
7	Mathématiques         20.0
8	Sciences Physiques     7.0
9	Name: Gilles, dtype: float64
10	*********************
11	Mathématiques         17.0
12	Sciences Physiques    10.0
13	Name: Sylvain, dtype: float64

notes.loc[« Gilles »] sélectionne la ligne dont l’indice d’étiquette est « Gilles ».

notes.iloc[1] sélectionne la ligne dont l’indice positionnel est 1, c’est-à-dire « Sylvain ».

Les opérations possibles sur un Dataframe

Dans la suite de ce tutoriel nous allons plus nous intéresser aux Dataframes. Nous verrons comment effectuer des opérations de statistiques et d’algèbre relationnelle, comment lire les fichiers et aussi comment produire des visualisations graphiques grâce aux données contenues dans un Dataframe.

Les opérations de statistique (sum, mean, median, etc.)

L’objectif principal visé lorsqu’on utilise la bibliothèque pandas est d’effectuer une analyse statistique sur un ensemble de données.

L’analyse statistique peut être utilisée pour :

• Faire ressortir les points clés d’un ensemble de données
• Résumer les informations.
• Calculer des mesures de cohérence, de pertinence ou de diversité dans les données.
• Faire des prédictions futures basées sur des données enregistrées précédemment.

Tout data scientist passera une grande partie de sa journée à remplir ces fonctions. Si vous souhaitez entamer une carrière dans le Big Data en tant data scientist ou occuper un autre poste dans ce domaine, nous vous avons dédié un article sur les 7 métiers porteurs du Big Data.

Un élément essentiel de l’analyse des données volumineuses est une synthèse efficace : le calcul d’agrégations telles que sum(), mean(), min() et max(), dans lesquelles un seul nombre donne un aperçu de la nature d’un ensemble de données potentiellement volumineux. Dans cette section, nous allons explorer les agrégations dans Pandas, à partir d’opérations simples.

Considérons le DataFrame suivant représentant les notes obtenues par des élèves dans quatre formations différentes.

import pandas as pd

df_notes = pd.DataFrame({
         "Introduction au Big data":  pd.Series([11.0, 15.0, 10.0,10.0],index=["Sylvie", "Gilles", "Sylvain", "Thomas"]),
         "Hadoop": pd.Series([18.0, 20.0, 17.0,18.0], index=["Sylvie", "Gilles", "Sylvain", "Thomas"]),
         "Spark": pd.Series([15.0, 7.0, 10.0,20.0],index=["Sylvie", "Gilles", "Sylvain", "Thomas"]),
         "Java": pd.Series([18.0, 20.0, 10.0,8.0],index=["Sylvie", "Gilles", "Sylvain", "Thomas"]),
    })
df_notes    

La méthode .sum()

Elle renvoie la somme des valeurs sur l’axe demandé (renvoie la somme des notes obtenues pour chaque étudiant), par exemple :

df_notes.sum(axis=1)

renvoie le résultat suivant :

Sylvie     62.0
Gilles     62.0
Sylvain    47.0
Thomas     56.0
dtype: float64

La méthode .mean()

Elle renvoie la moyenne des valeurs de l’axe demandé (renvoie la moyenne obtenue de chaque étudiant) :

df_notes.mean(axis=1)

Le résultat ici est :

Sylvie     15.50
Gilles     15.50
Sylvain    11.75
Thomas     14.00
dtype: float64

La méthode .max()

Elle renvoie le maximum des valeurs de l’axe demandé (renvoie la note maximale obtenue dans chaque formation). Prenons toujours un exemple :

1	df_notes.max(axis=0)

produisant le résultat suivant :

1	Introduction au Big data    15.0
2	Hadoop                      20.0
3	Spark                       20.0
4	Java                        20.0

La méthode .describe()

La méthode describe() est utilisée pour fournir toutes les informations essentielles sur la dataframe, qui peuvent être utilisées pour l’analyse des données et pour dériver différentes hypothèses mathématiques pour une étude plus approfondie. La fonction DataFrame describe() fonctionne dans la partie statistique de la bibliothèque Pandas.

print(df_notes.describe());

À l’issue de cela, vous obtenez :

       Introduction au Big data     Hadoop      Spark       Java
count                  4.000000   4.000000   4.000000   4.000000
mean                  11.500000  18.250000  13.000000  14.000000
std                    2.380476   1.258306   5.715476   5.887841
min                   10.000000  17.000000   7.000000   8.000000
25%                   10.000000  17.750000   9.250000   9.500000
50%                   10.500000  18.000000  12.500000  14.000000
75%                   12.000000  18.500000  16.250000  18.500000
max                   15.000000  20.000000  20.000000  20.000000

Les opérations de filtrage, groupage et de concaténation

Ces opérations sont très similaires aux opérations SQL qu’il est possible d’effectuer sur une table d’une base de données. Si vous êtes un programmeur SQL, vous êtes déjà familiarisé avec tout cela. La seule complexité réside dans le fait que vous pouvez joindre des colonnes en plus des lignes. Toutefois, si vous êtes novices dans ce domaine, vous pourriez consulter notre guide complète sur la programmation informatique.

L’opération de filtrage

Les Dataframe Pandas permettent l’indexation booléenne, qui est un moyen assez efficace de filtrer un dataframe pour plusieurs conditions. Dans l’indexation booléenne, les vecteurs booléens générés en fonction des conditions sont utilisés pour filtrer les données. Les conditions multiples impliquant les opérateurs | (pour l’opérateur ou), & (pour l’opérateur et), et ~ (pour l’opération non) peuvent être regroupées à l’aide de parenthèses ().

Considérons le DataFrame suivant représentant les notes obtenues par des élèves dans quatre formations différentes.

import pandas as pd
df_notes = pd.DataFrame({
         "Introduction au Big data":  pd.Series([11.0, 15.0, 10.0,10.0],index=["Sylvie", "Gilles", "Sylvain", "Thomas"]),
         "Hadoop": pd.Series([18.0, 20.0, 17.0,18.0], index=["Sylvie", "Gilles", "Sylvain", "Thomas"]),
         "Spark": pd.Series([15.0, 7.0, 10.0,20.0],index=["Sylvie", "Gilles", "Sylvain", "Thomas"]),
         "Java": pd.Series([18.0, 20.0, 10.0,8.0],index=["Sylvie", "Gilles", "Sylvain", "Thomas"]),
    })
df_notes

Exemple #1 :  Imaginons que nous voulons extraire du dataframe ci-dessus les étudiants ayant obtenu une note supérieure ou égale à 15 en Java.

Vous allez donc saisir ce qui suit :

resultat = df_notes[(df_notes['Java']>=15)]
print(resultat.Java)

pour obtenir cela :

Sylvie    18.0
Gilles    20.0
Name: Java, dtype: float64

Exemple #2 : En plus de connaitre les étudiants ayant une note supérieure ou égal à 15 en Java, imaginons si nous voulons, en plus de cette information, connaître les étudiants ayant une note supérieure ou égale à 10 en Spark.

resultat = df_notes[(df_notes['Java']>=15)&(df_notes['Spark']>=10)]
print(resultat[["Spark", "Java"]])

Le résultat sera :

        Spark  Java
Sylvie   15.0  18.0

L’opération de groupage

La fonction groupby() est l’une des fonctions les plus utiles lorsqu’il s’agit de traiter des dataframes volumineux dans Pandas. Une opération groupby consiste généralement à diviser la dataframe, à appliquer une fonction et à combiner les résultats.

Considérons le dataframe suivant :

import pandas as pd

notes = {'Région': ['Nouvelle-Aquitaine','Normandie','Normandie',
                   'Ile-de-France','Ile-de-France','Grand Est','Grand Est','Grand Est'], 
          'Université': ['Université de Poitiers','Université de Rouen','Université de Rouen',
                     'Université de Paris','Université de Paris','Université de Reims','Université de Reims','Université de Reims'],             
          'Nom': ['Gilles','Laura','Sylvain', 
                   'Thomas','Sylvie','luc','Marc','Hugo'], 
          'Spark': [14,14.5, 15,7.5,18,20,19,14],
          'Scala': [15,10,11,9,10.5,18.5,16,16]}

df = pd.DataFrame(notes, columns = 
                  ['Région', 'Université', 'Nom', 
                   'Spark', 'Scala'])
df

Regroupons les données du dataframe par Région :

gp = df.groupby('Région')5

for region, group in gp:
    print(region)
    print("**********************")
    print(group)
    print()

Dans ce cas, vous aurez ceci :

 Grand Est
**********************
      Région           Université   Nom  Spark  Scala
5  Grand Est  Université de Reims   luc   20.0   18.5
6  Grand Est  Université de Reims  Marc   19.0   16.0
7  Grand Est  Université de Reims  Hugo   14.0   16.0

Ile-de-France
**********************
          Région           Université     Nom  Spark  Scala
3  Ile-de-France  Université de Paris  Thomas    7.5    9.0
4  Ile-de-France  Université de Paris  Sylvie   18.0   10.5

Normandie
**********************
      Région           Université      Nom  Spark  Scala
1  Normandie  Université de Rouen    Laura   14.5   10.0
2  Normandie  Université de Rouen  Sylvain   15.0   11.0

Nouvelle-Aquitaine
**********************
               Région              Université     Nom  Spark  Scala
0  Nouvelle-Aquitaine  Université de Poitiers  Gilles   14.0   15.0

Nous pouvons encore aller plus loin. Maintenant, recherchons les résultats moyens en Scala et en Spark pour chaque Université :

df.groupby(['Région', 'Université']).mean()

Et cette fois-ci, le résultat sera :

L’opération de concaténation

Vous pouvez concaténer des dataframes le long de l’axe des lignes ou des colonnes. Supposons que vous ayez plusieurs dataframes comportant les mêmes champs et que vous souhaitiez les combiner en un seul le long de  l’axe des lignes.Ou encore, si vous avez des champs supplémentaires pour vos données actuelles que vous souhaitez ajouter, vous pouvez les concaténer le long de l’axe des colonnes. Dans cette partie, nous allons voir comment concaténer deux ou plusieurs dataframes avec Pandas.

Concaténation verticale

Considérons cet exemple :

import pandas as pd

# Création de deux Dataframes
df1 = pd.DataFrame({'Nom': ['Gilles', 'Sylvain'], 'Age': [25, 28]})
df2 = pd.DataFrame({'Nom': ['Sylvie', 'Luc'], 'Age': [35, 50]})

# Affichage des dataframes
print("DataFrame df1:\n")
print(df1)
print("\nDataFrame df2:\n")
print(df2)

# Concaténation verticale des dataframes
df_concat = pd.concat([df1, df2])

# Affichage du résultat
print("\nRésultat de la concaténation:\n", df_concat)

Le résultat à la sortie est :

DataFrame df1:

       Nom  Age
0   Gilles   25
1  Sylvain   28

DataFrame df2:

      Nom  Age
0  Sylvie   35
1     Luc   50
Résultat de la concaténation:
        Nom  Age
0   Gilles   25
1  Sylvain   28
0   Sylvie   35
1      Luc   50

Concaténation horizontale

Illustrons cela par les instructions qui suivent :

import pandas as pd

# Création de deux Dataframes
df1 = pd.DataFrame({'Nom': ['Gilles', 'Sylvain'], 'Age': [25, 28]})
df2 = pd.DataFrame({'Profession': ['Etudiant', 'Entrepreneur'], 'Statut Matrimoniale': ['Célibataire', 'Marié']})

# Affichage des dataframes
print("DataFrame df1:\n")
print(df1)
print("\nDataFrame df2:\n")
print(df2)

# Concaténation horizontale des dataframes
df_concat = pd.concat([df1, df2],axis=1)

# Affichage du résultat
print("\nRésultat de la concaténation:\n", df_concat)

Le résultat après la concaténation horizontale est :

DataFrame df1:

       Nom  Age
0   Gilles   25
1  Sylvain   28

DataFrame df2:

     Profession Statut Matrimoniale
0      Etudiant         Célibataire
1  Entrepreneur               Marié

Résultat de la concaténation:
        Nom  Age    Profession Statut Matrimoniale
0   Gilles   25      Etudiant         Célibataire
1  Sylvain   28  Entrepreneur               Marié  

Lire les fichiers avec pandas

Une caractéristique de Pandas est sa capacité à écrire et à lire des fichiers Excel, CSV et de nombreux autres types de fichiers. Des fonctions telles que la méthode Pandas read_csv() vous permettent de travailler efficacement avec des fichiers. Vous pouvez les utiliser pour charger des données de vos fichiers dans les instances Pandas Series ou DataFrame. Dans cette section nous verrons :

• Comment lire depuis des fichiers ?
• Comment travailler avec différents formats de fichiers ?
• Comment travailler efficacement avec des données volumineuses ?

Lire un fichier csv avec Pandas

Le format CSV (Comma Separated Values) est très populaire pour le stockage des données. Un grand nombre de stockage de données se présentent sous la forme de fichiers CSV qui peuvent être utilisés soit directement dans un tableur comme Excel, soit chargés dans des langages de programmation comme R ou Python. Les dataframes de Pandas sont assez puissants pour traiter des données tabulaires bidimensionnelles.

Pour lire un fichier csv avec Pandas on utilise la fonction read_csv() . Elle est fournie avec un certain nombre de paramètres différents pour personnaliser la façon dont vous souhaitez lire le fichier. Voici la syntaxe générale pour charger un fichier csv dans un dataframe :

import pandas as pd
df = pd.read_csv(path_to_file)

Ici, path_to_file est le chemin d’accès au fichier CSV que vous voulez charger. Il peut s’agir de n’importe quel chemin de chaîne valide ou d’une URL (voir les exemples ci-dessous). Elle renvoie un dataframe pandas.

Dans l’exemple suivant, nous chargerons un fichier csv stockant les données sur les espèces et le poids des animaux capturés sur le site du désert de Chihuahuan près de Portal, Arizona, États-Unis. Chaque ligne contient les informations relatives à un seul animal, et les colonnes représentent les caractéristiques étudiées.

import pandas as pd
df = pd.read_csv("https://ndownloader.figshare.com/files/2292172")
df

Les valeurs de sortie de celui-ci sont représentées dans le tableau suivant :

Sur le dataframe obtenu nous pouvons avoir des statistiques avec la méthode .describe() comme ceci :

print(df.describe());

1	   record_id         month           day          year       plot_id  \
2	count  35549.000000  35549.000000  35549.000000  35549.000000  35549.000000   
3	mean   17775.000000      6.474022     16.105966   1990.475231     11.397001   
4	std    10262.256696      3.396583      8.256691      7.493355      6.799406   
5	min        1.000000      1.000000      1.000000   1977.000000      1.000000   
6	25%     8888.000000      4.000000      9.000000   1984.000000      5.000000   
7	50%    17775.000000      6.000000     16.000000   1990.000000     11.000000   
8	75%    26662.000000      9.000000     23.000000   1997.000000     17.000000   
9	max    35549.000000     12.000000     31.000000   2002.000000     24.000000   
10	
11	       hindfoot_length        weight  
12	count     31438.000000  32283.000000  
13	mean         29.287932     42.672428  
14	std           9.564759     36.631259  
15	min           2.000000      4.000000  
16	25%          21.000000     20.000000  
17	50%          32.000000     37.000000  
18	75%          36.000000     48.000000  
19	max          70.000000    280.000000  

Lire un fichier Excel avec Pandas

Un tableau Excel est l’une des formes de fichiers les plus omniprésentes dans l’industrie informatique. Tous ceux qui utilisent un ordinateur à un moment ou à un autre a rencontré et travaillé avec des feuilles de calcul Excel. Cette popularité d’Excel est due à sa vaste gamme d’applications dans le domaine du stockage et de la manipulation de données sous forme de tableaux et de systèmes. De plus, les feuilles Excel sont très instinctives et conviviales, ce qui les rend idéales pour la manipulation de grands ensembles de données, même pour les personnes moins techniques.

Dans cette sous-section, vous allez apprendre à utiliser Pandas pour travailler avec des feuilles de calcul Excel.  L’objectif de cette sous-section est de vous apprendre à :

•     Lire les données d’un fichier Excel dans pandas en utilisant Python.
•     Explorer les données des fichiers Excel dans Pandas.

Supposons le fichier Excel suivant :

Nous pouvons importer ce fichier Excel dans notre programme Python en utilisant la fonction read_excel() de pandas comme suit :

import pandas as pd
data = pd.read_excel("fichier_sauvegarde.xlsx")
data

La deuxième instruction lit les données d’Excel et les stocke dans un dataframe pandas représenté par la variable data. S’il y a plusieurs feuilles dans le classeur Excel, la commande importera les données de la première feuille.

Pour sélectionner une feuille particulière on utilise l’argument sheet_name de la méthode read_excel() comme suit :

import pandas as pd
data_Etudiants = pd.read_excel("fichier_sauvegarde.xlsx", sheet_name="Etudiants")
data_Etudiants

Visualisation des données

En tant qu’expert en data, vous pourriez effectivement lire des données brutes. Toutefois, votre investisseur ou votre patron ne le pourra probablement pas.

Pour que nous puissions analyser correctement nos données, nous devons les représenter de manière tangible et complète afin que toutes les personnes concernées puissent les comprendre. C’est exactement la raison pour laquelle nous utilisons la visualisation des données !

La bibliothèque Pandas offre un large éventail d’outils qui vous aideront à accomplir cette tâche. Dans cette section, nous allons couvrir pas à pas tout ce dont vous aurez besoin pour commencer à utiliser les outils de visualisation de Pandas, notamment les diagrammes à barres, les histogrammes et les pie chart. Faire des visualisations avec pandas est pratique lorsque vous voulez voir rapidement à quoi ressemblent vos données.

Pour la suite de cette section nous utiliserons les données suivantes représentant des informations sur les présidents américains.

Imaginons que nous voulons présenter sur un graphique le pourcentage des partis politiques ayant occupé la maison blanche.

Le code qui permet de réaliser un tel graphique est le suivant :

import matplotlib.pyplot as plt
import pandas as pd 

presidents_americains = pd.read_excel("Presidents.xls")

couleurs = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral','red','green','blue']
presidents_americains['Political Party'].value_counts().plot(kind='pie',title='Partis politiques des Présidents',colors=couleurs)
plt.show()

On obtient le graphique suivant :

On remarque sur ce graphique que les républicains ont été plus représentés à la maison blanche. Il existe plusieurs graphiques proposés par pandas pour visualiser vos données. Vous trouverez sur ce lien la liste de ces graphiques et comment les utiliser.

Voilà ! Nous sommes arrivés au terme de ce tutoriel complet sur la librairie Pandas. Nous espérons que vous avez compris l’intérêt de cette bibliothèque dans le marché et son intérêt dans votre carrière. Clairement, Pandas et un outil à prendre en considération si vous souhaitez travailler dans le Big Data en tant que Data Analyst ou Data Engineer. C’est un outil qui s’apprivoise très rapidement. Si vous avez des questions par rapport à l’utilisation de cette bibliothèque n’hésitez pas à la poser dans les commentaires. Pour aller plus loin dans vos compétences dans le Big Data et dans la programmation informatique en général, nous vous offrons cette formation d’une heure en Scala.