En tant que Data Scientist, je consacre environ le tiers de mon temps à analyser les données et à tenter d’obtenir des informations utiles. Voici les outils que j’utilise le plus pour mener à bien une Analyse Exploratoire de données.

Êtes-vous nouveau dans le monde fascinant de la Data Science? Est-ce que des mots comme Analyse Exploratoire vous font peur? Si oui, ne vous inquiétez pas, je suis ici pour vous aider à naviguer dans ce domaine un peu fou.

Aujourd’hui, nous allons examiner deux outils géniaux que j’utilise au quotidien. L’un est Jupyter Notebook et l’autre est la célèbre bibliothèque d’analyse de données: Pandas.

Jupyter Notebook

Parlons d’abord de Jupyter Notebook. Si vous avez déjà utilisé la console Python, vous vous êtes probablement rendu compte de son utilité. De déboguer facilement une fonction en vérifiant si sa sortie correspond à vos attentes (je ne dis pas que ça doit remplacer un bon test, mais qui ne l’a pas fait?) jusqu’à l’exécution de processus coûteux en mémoire, il y a de nombreux avantages à avoir un environnement interactif.

Finalement Jupyter Notebook présente le même environnement. C’est comme si vous utilisiez l’outil de la console Python pour une boucle lecture-évaluation-affichage, mais avec une interface attrayante et la possibilité de documenter et d’enregistrer ce que vous avez testé. C’est très pratique, il permet de rédiger son analyse de données avec du code en l’accompagnant d’explications!

Installation Jupyter Notebook

Pour installer Jupyter, il suffit d’exécuter cette commande pip:
python -m pip install jupyter

Si vous êtes sous Linux, vous devriez utiliser cette commande:
pip3 install --user jupyter

Ouvrir Jupyter Notebook

Ensuite, pour exécuter le programme, ouvrez votre terminal dans le dossier où vous souhaitez stocker vos notebooks et exécutez:
jupyter notebook

Oui, c’est aussi simple que cela. Cette commande initialisera un serveur sur votre ordinateur et redirigera vers votre navigateur favori.
A partir de là, utilisez simplement l’interface graphique pour créer un nouveau notebook et ouvrez-le. Utilisez le bouton + pour créer un nouveau bloc de codes et le bouton «coupé» pour en supprimer un. Chaque bloc de code peut être exécuté indépendamment (mais pas simultanément) en y plaçant votre curseur et en appuyant sur «Shift + Entrer».

Bibliothèque Pandas

Passons maintenant à la partie amusante. Parlons un peu de la bibliothèque Pandas. Pandas est un framework Open Source Python, maintenu par la communauté PyData. Il est principalement utilisé pour l’analyse et le traitement des données — principalement pour manipuler des fichiers CSV.

Analyse exploratoire de données avec Pandas

Générer un fichier au format CSV

Fichier de format CSV

Au cas où vous ne le sauriez pas, CSV est simplement un format pour les fichiers qui encodent des données dans des séries (colonnes), où chaque rangée possède une valeur. Chaque rangée est une ligne du fichier et chaque valeur est séparée de la précédente par une virgule, ce qui correspond au fichier CSV (Comma Separated Values). La première ligne est réservée à l’en-tête, avec les noms de chaque colonne.

Création d’un jeu de données

Dans cet article, nous allons d’abord générer un jeu de données fictif de «données relatives aux employés» à partir d’une entreprise qui stocke uniquement le nom, le prénom et le salaire de chaque employé. L’ensemble de données sera généré sous la forme d’un fichier CSV.

Générer des dictionnaires de personnes

Tout d’abord, nous utilisons du Python standard pour générer des dictionnaires, chacun représentant une personne. Si vous êtes à l’aise avec JavaScript, chaque dictionnaire est simplement un JSON, avec les champs “first_names”, “last_names” et “salary”.

import random

first_names = ["Vincent","Jessica","Ivan","Maria","Elodie"]
last_names = ["Pernaud","Evian","Seri","Pasta","Bolivar"]
salaries = [500*random.randint(10,30) for _ in range(10)]

def generate_random_person(first_names, last_names, salaries):
    return {"firstname":random.sample(first_names,1)[0],
            "lastname":random.sample(last_names,1)[0],
            "salary":random.sample(salaries,1)[0]}

def generate_people(k):
    return [generate_random_person(first_names, last_names, salaries) for _ in range(k)]

Générer un DataFrame Pandas

Nous générons ensuite un DataFrame Pandas avec 50 personnes à partir de la fonction generate_people(), où chaque colonne est une série Pandas:

import pandas as pd

df = pd.DataFrame(generate_people(50),
                  columns=["firstname","lastname","salary"])

df.to_csv("random_people.csv", index=False)

Voilà comme vous pouvez le constater, un Dataframe est généré sous la forme d’une liste de dictionnaires et d’un argument (facultatif) pour les noms de colonnes. On l’exporte simplement dans un fichier CSV en utilisant la méthode to_csv avec un nom de fichier comme seul argument.
Résultat, on obtient un DataFrame avec 5O personnes à partir 5 prénoms/noms et des salaires générés aléatoirement.

Analyse Exploratoire de données

Voyons la partie lecture et traitement des données.

Lecture du jeu de données

Nous importons d’abord le fichier CSV en tant que Dataframe avec le code suivant:

import pandas as pd 

df = pd.read_csv("random_people.csv")

 

Exploration rapide

Head

Commençons par avoir un feeling avec nos données en affichant la tête du dataframe:

df.head(4)
  firstname lastname  salary
0      Ivan     Seri    8000
1     Maria  Bolivar    6000
2   Jessica    Pasta   14500
3   Jessica  Bolivar    6500

Utiliser df.head(k) où k correspond aux k premières lignes du dataframe. C’est le moyen le plus facile d’obtenir un aperçu des données.

Méthodes d’agrégation

Pour afficher qu’une série du dataframe, il suffit de l’indexer comme s’il s’agissait d’un champ de dictionnaire:

df[“*series name*”]

Vous pouvez ensuite appeler sur cette série n’importe quelle méthode d’agrégation habituelle que vous utiliseriez dans tout autre outil d’analyse de données. Ma méthode préférée est la méthode value_counts() qui affiche chaque valeur et le nombre de fois qu’elle apparaît dans la série, en ordre décroissant d’apparitions. Elle permet notamment d’obtenir une intuition sur la série.

df['salary'].value_counts()
6500     16
6000      9
8000      8
11500     6
14500     5
5500      3
9500      3
Name: salary, dtype: int64

Les autres méthodes intéressantes sont mean()sum(), count() et median():

df['salary'].median()
6500.0

 

Fonctions personnalisées

Cependant, vous voudrez parfois appliquer à une série une fonction plus complexe et personnalisé. Dans ce cas Pandas n’a peut-être pas ce cas spécifique d’utilisation.
A vous de simplement définir votre propre fonction et utiliser la méthode apply sur la série que vous souhaitez modifier. Ce sera un peu plus fastidieux, mais fonctionne toujours bien pour les fonctions simples. Cela ajoutera de la flexibilité au traitement de vos données.

Création nouvelle colonne

On définit une nouvelle colonne dans notre dataframe calculée à partir d’une autre colonne:

df["salary_after_tax"] = df["salary"]*.8

Apply

Puis on définit une nouvelle fonction et on l’applique à notre série directement avec la méthode apply:

def tax(s):
    if s>=6000:
        return s*.7
    else:
        return s*.85

df["salary_after_tax"] = df["salary"].apply(tax)
df.head()
  firstname lastname  salary  salary_after_tax
0      Ivan     Seri    8000            5600.0
1     Maria  Bolivar    6000            4200.0
2   Jessica    Pasta   14500           10150.0
3   Jessica  Bolivar    6500            4550.0
4   Vincent  Pernaud    8000            5600.0

 

Filtrer un DataFrame

Série de booléens

Si vous souhaitez filtrer votre Dataframe et ne conserver que les lignes qui présentent une condition spécifique, vous pouvez faire:

df_low = df[df["salary"]<6000] 
df_high = df[df["salary"]>=6000]

df["salary"]> = 6000 peut être remplacé par tout ce qui retourne une série de booléens, soit df["series_name"].apply (f) tel que f est une fonction booléenne. Assurez-vous la série comporte le même nombre d’éléments que la série que vous filtrez.

On peut ensuite calculer la moyenne des salaires sur ce dataframe filtré:

df_high["salary"].mean()
8340.425531914894

 

Méthode Loc

Enfin, gardez à l’esprit que ces dataframes filtrés sont en lecture seule par défaut puisqu’ils sont générées par référence. Si vous souhaitez les modifier, ajoutez simplement .loc après le nom du dataframe, avant le premier crochet, comme suit:

df_low= df.loc[df["salary"]<6000]
df_low
   firstname lastname  salary  salary_after_tax
19   Vincent  Bolivar    5500            4675.0
22   Vincent    Evian    5500            4675.0
37   Jessica  Pernaud    5500            4675.0

 

Vous pouvez également ajouter un nom de colonne en tant que second paramètre à la méthode .loc afin de conserver une seule série filtrée au lieu de l’intégralité du Dataframe:

df_low= df.loc[df["salary"]<6000,"salary"]
df_low
19    5500
22    5500
37    5500
Name: salary, dtype: int64

Notez que ce dernier se réfère au dataframe df. Par conséquent, toute modification que vous lui apportez sera également effectuée sur le Dataframe d’origine. Pour éviter cela, appelez simplement la méthode .copy() en fin de ligne.

Pour finir, on peu, au lieu de définir une fonction de taxe, directement filtrer puis calculer la valeur:

df_low= df.loc[df["salary"]<6000,"salary"]
df.loc[df["salary"]<6000,"salary_after_tax"] = df_low*.85 

df_low= df.loc[df["salary"]>=6000,"salary"]
df.loc[df["salary"]>=6000,"salary_after_tax"] = df_low*.7

df_low.head()
0     8000
1     6000
2    14500
3     6500
4     8000
Name: salary, dtype: int64

 

J’espère que ces quelques points d’Analyse Explorative avec le combo Jupyter Notebook et Pandas vous seront utiles.
Vous pouvez vous abonner ci-dessous pour recevoir plus de contenus.