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.
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 Exploratoire de Données avec le combo Jupyter Notebook et Pandas vous seront utiles.
