pandas est une des librairies de référence pour le traitement de données avec le langage Python. En tant que journaliste de données, elle constitue une alternative sérieuse à des logiciels comme Excel ou Libre Calc.

La preuve avec ce carnet de notes qui détaille plusieurs manipulations d'un csv rempli de données électorales !

J'ai pris volontairement un fichier assez classique, pour pouvoir faire des manipulations très basiques comme :

• des calculs de pourcentages
• des sélections d'échantillons
• des créations de nouvelles données à l'aide de tables de correspondance

Les choses un peu plus complexes comme les tableaux croisés dynamiques ne sont pas abordées dans ce carnet de notes. Mais j'essayerais de m'y pencher ultérieurement !

Serie et DataFrame

Avant d'entrer dans le vif du sujet, il faut présenter rapidement les deux format de données prépondérant dans pandas : les Series et les DataFrames.

Pour résumer :

• les Series correspondent en gros à des tableaux à une dimension (soit à une seule et unique colonne d'un tableur).
• les DataFrames correspondent quant à elles à des tableaux à plusieurs dimensions, ce qui nous intéresse particulièrement ici

On peut créer une DataFrame à partir de plusieurs Series ou transformer une colonne d'une DataFrame en série, mais ce type de manip' ne constituera pas le coeur de ce carnet de notes ! On va plutôt partir d'un bon vieux fichier csv à l'ancienne :-)

Lire un fichier csv

Commençons par importer le module pandas :

import pandas as pd
from pandas import DataFrame # comme on va bouffer du DataFrame, autant l'importer direct pour gagner en lisibilité

On va ensuite lire un csv avec la fonction read_csv() pour pouvoir le manipuler :

reg015 = pd.read_csv("reg015_grandest.csv")

On peut de suite vérifier que la variable reg015 correspond bien à une DataFrame :

type(reg015)
pandas.core.frame.DataFrame

On peut également obtenir le gabarit de notre DataFrame avec la fonction shape :

reg015.shape
(5189, 8)

Nous avons donc une DataFrame de 5 189 lignes sur huit colonnes.

Pour avoir un rapide aperçu de reg015, on peut utiliser les fonctions head() ou tail(), pour afficher respectivement les cinq premières ou dernières lignes du fichier.

reg015.head()

Manipulation de colonnes

Sélections

Pour afficher une seule colonne de reg015, il suffit de raisonner par nom de colonne :

reg015["ville"].tail()   # cette commande affiche les cinq dernières valeurs de 'ville'

5184         Xamontarupt
5185            Xaronval
5186            Xertigny
5187    Xonrupt-Longemer
5188            Zincourt
Name: ville, dtype: object

On peut s'assurer en deux temps trois mouvements qu'une colonne d'une DataFrame est bien considérée comme une Serie :

type(reg015["ville"])
pandas.core.series.Series

Pour sélectionner plusieurs colonnes, la syntaxe est la suivante :

reg015[['code insee','ville','abstentions']].iloc[:15] # iloc sert à sélectionner une partie des données à partir de leur index

Tri par colonnes

Il peut être intéressant de trier une colonne d'une DataFrame. On va pas se mentir, c'est même une des manipulations les plus souvent répétées sur ce bon vieil Excel !

Dans notre exemple, si l'on veut trier les communes dans l'ordre décroissant des votes FN, il suffit d'utiliser la fonction sort_values() comme ceci :

reg015 = reg015.sort_values('LFN',ascending=0)
reg015.iloc[:15]

On peut également prendre en compte plusieurs colonnes pour un tri.

Si on veut par exemple trier l'abstention et le FN par ordre décroissant, on peut écrire :

reg015 = reg015.sort_values(['abstentions','LFN'],ascending=[0,0])
reg015.iloc[:15]

Création de nouvelles colonnes

On va compléter la DataFrame, par exemple en ajoutant les pourcentages de l'abstention et de chaque liste. La formule pour créer ces nouvelles Series rappelle beaucoup l'incrémentation d'un dictionnaire Python :

reg015['pabs'] = ((reg015['abstentions']/reg015['inscrits'])*100).round(2)
reg015['pldvg'] = ((reg015['LDVG']/reg015['exprimes'])*100).round(2)
reg015['plfn'] = ((reg015['LFN']/reg015['exprimes'])*100).round(2)
reg015['plud'] = ((reg015['LUD']/reg015['exprimes'])*100).round(2)

On peut tout de suite vérifier que la manip' a fonctionné en réutilisant la fonction shape...

reg015.shape
(5189, 12)

...et en affichant les premières valeurs :

reg015 = reg015.sort('code insee')
reg015.head()

Résumé statistique

pandas inclut une fonction describe(), qui fournit un résumé statistique d'une DataFrame.

reg015.describe()

Valeurs minimale et maximale, déviation standard, moyenne, nombre d'unités (assez inutile pour le coup)... Y a pas mal de choses !

Par défaut, le tableau descriptif comprend les quartiles, mais on peut les changer à l'envie.

Par exemple, si on veut directement paramétrer des cartes par déciles avec neuf classes de couleurs, on peut procéder comme suit :

reg015.describe(percentiles=[.11, .22, .33, .44, .55, .66, .77, .88]) # chaque niveau représente un seuil de classe sur la carte

Sélections et expressions logiques

pandas offre également la possibilité de faire des sélections sur une DataFrame pour renvoyer une nouvelle DataFrame en résultat.

Par exemple, si on veut sélectionner les villes où le FN obtient la majorité absolue, il suffira d'entrer :

fn_vainqueur = reg015[reg015['plfn']>50]  # cette syntaxe ne marchera qu'avec une seule et unique expression logique
fn_vainqueur.head()

Rien n'empêche de pimenter la chose en accumulant les sélections. Si on veut ne retenir que les villes où :

• la liste de droite obtient la majorité absolue
• la liste de gauche est seconde

On peut écrire :

ud_victoire = reg015['plud']> 50
dvg_second = reg015['pldvg']> reg015['plfn']

tierce = reg015[ud_victoire & dvg_second]
tierce.head()

A noter qu'on peut aussi rassembler les sélections directement ainsi (attention aux parenthèses) :

tierce = reg015[(reg015['plud']>50) & (reg015['pldvg']> reg015['plfn'])]

Chacune des DataFrames ainsi créées peut être par la suite enregistrée dans un nouveau fichier. Mais avant cela...

Quelques fonctions intermédiaires

Il est très courant lors d'une soirée électorale de vouloir très rapidement avoir le nom du candidat ou de la liste arrivée en tête dans tel territoire.

Une fonction de pandas toute désignée pour ça est idxmax(). On va l'utiliser en prenant en compte les voix brutes de la droite, de la gauche et de l'extrême droite pour remplir une nouvelle colonne de la DataFrame nommée 'vainqueur' :

reg015['vainqueur'] = reg015[['LDVG','LFN','LUD']].idxmax(axis=1)
reg015.iloc[:6]

Les plus observateurs auront remarqué un souci : la dernière ville donne le FN vainqueur, alors qu'il est à égalité avec la droite. Moyen moins...

Il faut tricher un peu pour inclure le cas d'égalité. Voici une manip' gracieusement proposée sur StackOverflow, qui consiste en gros à appliquer un calque sur les valeurs initiales de 'vainqueur'.

Les étapes pour y arriver seront :

• créer une nouvelle Serie, disons 'somme', pour paramétrer le calque
• additionner à l'intérieur de cette Serie le nombre de maximum (!) de chaque commune

Une fois que la Serie sera prête, on la superposera à la Serie 'vainqueur' pour que :

• si la valeur de somme est égale à 1, le calque ne s'applique pas
• en revanche, si cette valeur est supérieure à 1, on pose un masque dessus en la remplaçant par 'Egalite'

Concrètement, ça donne :

somme = reg015[['LDVG','LFN','LUD']].eq(reg015[['LDVG','LFN','LUD']].max(axis=1), axis=0).sum(axis=1)
somme[:6]
0    1
1    1
2    1
3    1
4    1
5    2
dtype: int64

On voit bien qu'à l'indice 5, celui correspondant aux Alleux, le nombre de maximum est supérieur à 1.

On peut alors procéder au changement de valeurs comme suit :

reg015['vainqueur'] = reg015['vainqueur'].mask(somme > 1, 'Egalite')
reg015[:6]

Une fois ceci fait, pourquoi ne pas ajouter une couleur en fonction du parti arrivé en tête dans chaque commune ?

pandas est une librairie Python, on pourrait donc règler l'affaire en utilisant des boucles if/elif/else... mais on peut aussi vouloir utiliser une table de correspondance, par exemple :

correspondance = pd.read_csv("table_couleurs.csv")
correspondance

Pour être parfaitement raccord à la colonne 'vainqueur' de notre grosse DataFrame, il faudrait ajouter une ligne avec le cas d'égalité.

Une DataFrame fonctionne à peu près comme une liste Python classique, à l'intérieur de laquelle on range un dictionnaire.

La commande sera plus parlante :

correspondance = correspondance.append([{'vainqueur':'Egalite','couleur':'#c0c0c0'}])
correspondance

Pour faire la correspondance, la fonction merge() fait le job (ça rappellera sûrement des trucs aux utilisateurs de Google Fusion Table).

Dans notre cas, ça va donner :

reg015 = pd.merge(reg015, correspondance, how='left')
reg015[:6]

Transformer une DataFrame en fichier

Un instinct primaire encouragerait à tenter une fonction to_csv() pour transformer une DataFrame, et il aurait raison !

reg015.to_csv("reg015_def.csv")

Pandas obéit par défaut à une logique anglo-saxonne : les séparateurs de données sont des virgules, ce qui tombe bien puisque les décimales sont représentées par des points.

Mais rien n'interdit d'ajouter quelques paramètres pour avoir à l'arrivée un csv lisible avec une configuration francophone !

reg015.to_csv("reg015_deffr.csv", sep = ";", decimal = ",")

C'est tout pour aujourd'hui !

Point Github

Les CSV utilisés pour cette démo ont été publiés via mon compte Github, avec un carnet de notes qui en détaille les grandes lignes !