Tables de données avec Pandas

Manipulation de données¶

Nous allons apprendre à manipuler des données organisées sous forme de table à une ou deux dimensions, notamment pour faire des analyses statistiques ou des visualisations.

Bibliothèque Pandas¶

Pandas est une bibliothèque Python qui permet de:

• manipuler des tables de données et

• faire des analyses statistiques,

comme on pourrait le faire avec un tableur (libreoffice ou excel par exemple), mais programmatiquement, donc permettant l’automatisation.

Les tables de données (type DataFrame): sont des tableaux à deux (ou plus) dimensions, avec des étiquettes (labels) sur les lignes et les colonnes. Les données ne sont pas forcément homogènes: d’une colonne à l’autre, le type des données peut changer (chaînes de caractères, flottants, entiers, etc.); de plus certaines données peuvent être manquantes.

Les séries (type Series) sont des tables à une seule dimension (des vecteurs), typiquement obtenues en extrayant une colonne d’un DataFrame.

Dans ce cours, par table, on entendra un tableau à deux dimensions de type DataFrame, tandis que par série on entendra un tableau à une dimension de type Series.

On retrouve ces concepts de DataFrame et de Series dans les autres bibliothèques ou systèmes d’analyse de données comme R.

De plus, Pandas permet de traiter des données massives réparties sur de très nombreux ordinateurs en s’appuyant sur des bibliothèques de parallélisme comme dask

Séries de données¶

Nous devons commencer par importer la bibliothèque pandas; il est traditionnel de définir un raccourci pd:

import pandas as pd

Construisons une série de températures:

temperatures = pd.Series([8.3, 10.5, 4.4, 2.9, 5.7, 11.1], name="Température")
temperatures

Vous noterez que la série est considérée comme une colonne et que les indices de ses lignes sont affichés. Par défaut, ce sont les entiers $0,1,\ldots$, mais d’autres indices sont possibles. Comme pour les tableaux C++ ou les listes Python, on utiliser la notation ‘t[i]’ pour extraire la ligne d’indice i:

temperatures[3]

La taille de la série s’obtient de manière traditionnelle avec Python avec la fonction len:

len(temperatures)

Calculons la moyenne des températures à l’aide de la méthode mean:

temperatures.mean()

Calculez la température maximale à l’aide de la méthode max:

### BEGIN SOLUTION
temperatures.max()
### END SOLUTION

Calculez la température minimale:

### BEGIN SOLUTION
temperatures.min()
### END SOLUTION

Quelle est la gamme de données (le range en anglais) de température? C’est-à-dire quelle est la différence entre la température maximale et la température minimale?

### BEGIN SOLUTION
temperatures.max() - temperatures.min()
### END SOLUTION

Tables de données (DataFrame)¶

Nous allons maintenant construire une table contenant les données d’acidité de l’eau de plusieurs puits. Elle aura deux colonnes: l’une pour le nom des puits et l’autre pour la valeur du pH (l’acidité).

Nous pouvons maintenant construire la table à partir de la liste des noms des puits et de la liste des pH des puits:

df = pd.DataFrame(
    {
        "Noms": ["P1", "P2", "P3", "P4", "P5", "P6", "P7", "P8", "P9", "P10"],
        "pH": [7.0, 6.5, 6.8, 7.1, 8.0, 7.0, 7.1, 6.8, 7.1, 7.1],
    }
)
df

Cette table à deux dimensions est vue comme une collection de colonnes. De ce fait, df[label] extrait la colonne d’étiquette label, sous la forme d’une série:

df["Noms"]

Vous pouvez ensuite accéder à chacune des valeurs de la table en en précisant le label de sa colonne puis l’indice de sa ligne. Voici le nom dans la deuxième ligne (indice 1):

df["Noms"][1]

Et la valeur du pH dans la quatrième ligne (indice 3):

df["pH"][3]

Métadonnées et statistiques¶

Nous utilisons maintenant Pandas pour extraire quelques métadonnées et statistiques de nos données.

D’abord la taille de la table:

df.shape

Le titre des colonnes:

df.columns

Le nombre de lignes:

len(df)

Des informations générales:

df.info()

<class 'pandas.DataFrame'>
RangeIndex: 10 entries, 0 to 9
Data columns (total 2 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   Noms    10 non-null     str    
 1   pH      10 non-null     float64
dtypes: float64(1), str(1)
memory usage: 292.0 bytes

La moyenne de chaque colonne pour laquelle cela fait du sens, c’est-à-dire seulement les colonnes contenant des valeurs numériques (ici que le pH):

df.mean(numeric_only=True)

Les écarts-types:

df.std(numeric_only=True)

La mediane:

df.median(numeric_only=True)

Le quantile 25%:

df.quantile(0.25, numeric_only=True)

Les valeurs min et max:

df.min()

df.max()

Un résumé des statistiques principales:

df.describe()

L’indice du pH max:

df["pH"].idxmax()

Un histogramme des pH. Remarque : Ici, on a l’option bins = 20, cela veut dire qu’on divise le range des pH (l’axe des x) en 20 groupes de meme taille. Changez la valeur de bins à 2 et regardez la différence:

df["pH"].hist(bins=20);

Avec pyplot, il est possible de peaufiner le résultat en ajoutant des labels aux axes, etc:

import matplotlib.pyplot as plt

df["pH"].plot(kind="hist")
plt.grid()
plt.ylabel("Counts")
plt.xlabel("pH");

Opérations de bases de données¶

Pandas permet de faire des opérations de bases de données (pour ceux qui ont fait le projet Données Libres, souvenez-vous de «select», «group by», «join», etc.). Nous ne montrons ici que la sélection de lignes; vous jouerez avec «group by» plus loin.

Transformons la table pour que l’une des colonnes serve d’indices; ici nous nous servirons des noms:

df1 = df.set_index("Noms")
df1

Il est maintenant possible d’accéder à une valeur de pH en utilisant directement le nom comme index de ligne:

df1["pH"]["P1"]

Sélectionnons maintenant toutes les lignes de pH 7.1:

df1[df1["pH"] == 7.1]

Comment cela fonctionne-t-il?

Notons pH la colonne de même label:

pH = df1["pH"]
pH

Comme avec NumPy, toutes les opérations sont vectorisées sur tous les éléments du table ou de la séries. Ainsi, si l’on écrit pH + 1 (ce qui n’a pas de sens mathématique, les objets étant de type très différents: pH est une série tandis que 1 est un nombre), cela ajoute 1 à toutes les valeurs de la série:

pH + 1

De manière similaire, si l’on écrit pH == 7.1, cela renvoie une série de booléens, chacun indiquant si la valeur correspondante est égale ou non à 7.1:

pH == 7.1

Enfin, si l’on indexe une table par une série de booléen, cela extrait les lignes pour lesquelles la série contient True:

df1[pH == 7.1]

Exercice: les notes¶

Les notes d’un cours «Info 111» (anonymes!) sont dans le fichier CSV data/notes_info_111.csv. Consultez le contenu de ce fichier: vous noterez que les valeurs sont séparées par des virgules ‘,’ (CSV: Comma Separated Value).

Voici comment charger ce fichier comme une table:

df = pd.read_csv("data/notes_info_111.csv", sep=",")

Affichez la table qui a été chargée ci-dessus:

### BEGIN SOLUTION
df
### END SOLUTION

Affichez un résumé des statistiques principales:

### BEGIN SOLUTION
df.describe()
### END SOLUTION

Avec DataGrid, vous pouvez explorer interactivement la table; faites quelques essais:

• de filtrage (icône );

• de tri (cliquer sur le titre de la colonne par rapport à laquelle trier).

from ipydatagrid import DataGrid

DataGrid(df)

Exercice: Les prénoms¶

Dans cet exercice il s’agit d’analyser une base de données qui porte sur les prénoms donnés à Paris entre 2004 et 2018 (souvenirs du S1?). Ces données sont librement accessibles également sur le site opendata de la ville de Paris. La commande shell suivante va les télécharger dans le fichier liste_des_prenoms.csv s’il n’est pas déjà présent.

if [ ! -f liste_des_prenoms.csv ]; then
    curl --http1.1 "https://opendata.paris.fr/explore/dataset/liste_des_prenoms/download/?format=csv&timezone=Europe/Berlin&lang=fr&use_labels_for_header=true&csv_separator=%3B" -o data/liste_des_prenoms.csv
fi

1. Ouvrez le fichier pour consulter son contenu.

2. En vous inspirant de l’exemple ci-dessus, chargez le fichier data/liste_des_prenoms.csv et stockez dans une variable prenoms. Indication: le fichier utilise des points-virgules ; comme séparateurs et non des virgules ,.

### BEGIN SOLUTION
prenoms = pd.read_csv("data/liste_des_prenoms.csv", sep=";")
### END SOLUTION

Si le test ci-dessous ne passe pas, vérifiez que vous avez bien appelé votre table prenoms (sans accent, avec un s):

assert isinstance(prenoms, pd.DataFrame)
assert list(prenoms.columns) == [
    "Nombre prénoms déclarés",
    "Sexe",
    "Annee",
    "Prenoms",
    "Nombre total cumule par annee",
]

2. Affichez les dix premières lignes du fichier. Indication: consultez la documentation de la méthode head avec prenoms.head?

### BEGIN SOLUTION
prenoms.head(10)
### END SOLUTION

3. Affichez les lignes correspondant à votre prénom (ou un autre prénom tel que Mohammed, Maxime ou encore Brune si votre prénom n’est pas dans la liste):

### BEGIN SOLUTION
prenoms[prenoms.Prenoms == "Brune"]
### END SOLUTION

4. Faites de même interactivement avec DataGrid:

DataGrid(prenoms)

5. Extraire dans une variable prenoms_femmes les prénoms de femmes (avec répétitions), sous la forme d’une série. Indication: retrouvez dans les exemples ci-dessus comment sélectionner des lignes et comment extraire une colonne.

### BEGIN SOLUTION
prenoms_femmes = prenoms["Prenoms"][prenoms["Sexe"] == "F"]
prenoms_femmes
### END SOLUTION

Combien y en a-t’il?

### BEGIN SOLUTION
len(prenoms_femmes)
### END SOLUTION

# Vérifie que prenoms_femmes est bien une série
assert isinstance(prenoms_femmes, pd.Series)

# Vérifie le premier prénom alphabetiquement
assert prenoms_femmes.min() == "Aaliyah"
# Vérifie le nombre de prénoms après suppression des répétitions
assert len(set(prenoms_femmes)) == 1491

6. Procédez de même pour les prénoms d’hommes:

### BEGIN SOLUTION
prenoms_hommes = prenoms["Prenoms"][prenoms["Sexe"] == "M"]
prenoms_hommes
### END SOLUTION

### BEGIN SOLUTION
len(prenoms_hommes)
### END SOLUTION

Une petite vérification:

assert len(prenoms_hommes) + len(prenoms_femmes) == len(prenoms)

Exercice : Transformez les Prenoms en majuscule de la table prenoms. Affectez le résultat à la variable prenoms_maj

Objectif: savoir rechercher dans la documentation pandas: https://pandas.pydata.org/docs/user_guide/.

### BEGIN SOLUTION
# Solution apres avoir cherche dans "working with text" in the user guide
prenoms_maj = prenoms["Prenoms"].str.upper()
### END SOLUTION

Exercice $\clubsuit$

Quel est le prénom le plus déclaré, en cumulé sur toutes les années? Affectez le à la variable prenom.

Indication: consulter le premier exemple à la fin de la documentation de la méthode groupby pour calculer les nombres cumulés par prénom (avec sum). Puis utilisez DataGrid pour visualiser le résultat et le trier, ou bien utilisez sort_values, ou idxmax.

### BEGIN SOLUTION
df = prenoms.groupby("Prenoms").sum()
# Solution 1
DataGrid(df)
# Solution 2
df.sort_values("Nombre prénoms déclarés")
### END SOLUTION

### BEGIN SOLUTION
# Solution 3
prenom = df["Nombre prénoms déclarés"].idxmax()
### END SOLUTION

Ce test vérifie que vous avez trouvé la bonne réponse; sans vous la donner; la magie des fonctions de hachage :-)

import hashlib

assert (
    hashlib.md5(prenom.encode("utf-8")).hexdigest()
    == "b70e2a0d855b4dc7b1ea34a8a9d10305"
)

Conclusion¶