Traitement de données en tables : CSV, recherche, tri et fusion

Qu'est-ce qu'une table ? Le format CSV

Une table est un ensemble de données organisé en lignes (les enregistrements) et en colonnes (les champs). Chaque colonne porte un nom, le descripteur, et ne contient que des valeurs d'un même domaine (entiers, textes, etc.).

Le format CSV (Comma-Separated Values) stocke une table dans un fichier texte : un enregistrement par ligne, les champs séparés par un séparateur (virgule, point-virgule ou tabulation). La première ligne contient souvent les descripteurs.

nom,ville,age

Durand,Lille,17

Petit,Nice,16

Roux,Lille,16

En Python, on représente une table par une liste de dictionnaires : chaque dictionnaire est un enregistrement, ses clés sont les descripteurs.

table = [

    {"nom": "Durand", "ville": "Lille", "age": 17},

    {"nom": "Petit", "ville": "Nice", "age": 16},

    {"nom": "Roux", "ville": "Lille", "age": 16},

]

print(table[1]["ville"])   # Nice

On peut aussi utiliser une liste de p-uplets, plus légère mais moins lisible : on accède alors aux champs par leur indice.

Importer un fichier CSV

Le module csv de la bibliothèque standard lit le fichier. DictReader utilise la première ligne comme descripteurs et produit un dictionnaire par ligne.

import csv

with open("eleves.csv", encoding="utf-8") as f:

    lecteur = csv.DictReader(f)          # séparateur « , » par défaut

    table = [ligne for ligne in lecteur]

L'instruction with ferme automatiquement le fichier à la sortie du bloc, même en cas d'erreur. Sans with, il faudrait appeler f.close(). Si le séparateur est un point-virgule (courant dans les fichiers français, car la virgule sert de virgule décimale), on écrit csv.DictReader(f, delimiter=";").

nom,ville,age

Durand,Lille,17

Petit,Nice,16

Roux,Lille,16

Rechercher dans une table

Rechercher, c'est sélectionner les enregistrements qui vérifient un critère exprimé avec and, or, not et des comparaisons. La compréhension est l'outil naturel.

Pour ajouter un enregistrement, on utilise append : table.append({"nom": "Blanc", "ville": "Brest", "age": 17}).

Doublons et cohérence

Deux contrôles classiques :

• chercher les doublons : une même valeur (un mail, un identifiant) qui apparaît plusieurs fois ;

• tester la cohérence : champs non vides, valeurs dans le bon domaine, présence d'un @ dans un mail.

Avec deux boucles imbriquées, la recherche de doublons compare toutes les paires : environ $n^2$ opérations. Avec un dictionnaire (ou un ensemble) de valeurs déjà rencontrées, un seul parcours suffit, car tester x in d est quasi immédiat :

def doublons(table, champ):

    vus = {}

    res = []

    for e in table:

        v = e[champ]

        if v in vus and v not in res:

            res.append(v)

        vus[v] = True

    return res

Le coût est proportionnel à $n$ : sur 40 000 lignes, on évite plus d'un milliard de comparaisons.

def coherente(table):

    for e in table:

        for valeur in e.values():

            if valeur == "":

                return False

        if "@" not in e["mail"]:

            return False

    return True

Trier une table

La fonction sorted(table, key=f, reverse=False) renvoie une nouvelle liste triée ; table.sort(key=f) trie la liste en place. La fonction key reçoit un enregistrement et renvoie la valeur qui sert à comparer.

def population(v):

    return v["population"]

par_pop = sorted(villes, key=population, reverse=True)   # décroissant

# ou : sorted(villes, key=lambda v: v["population"], reverse=True)

Trier selon deux critères

On peut renvoyer un couple : Python compare d'abord le premier élément, puis le second en cas d'égalité.

sorted(t, key=lambda e: (e["ville"], e["age"]))   # ville ↑, puis âge ↑

Pour une ville croissante et un âge décroissant, on utilise -e["age"] (valable pour un nombre) : key=lambda e: (e["ville"], -e["age"]).

Autre méthode : le tri de Python est stable : deux éléments égaux pour la clé gardent leur ordre relatif d'origine. On trie donc d'abord selon le critère secondaire, puis selon le critère principal :

t1 = sorted(t, key=lambda e: e["age"], reverse=True)

t2 = sorted(t1, key=lambda e: e["ville"])

Fusionner des tables

Souvent, l'information est répartie sur plusieurs tables reliées par un champ commun. Ici, eleves contient id_club et clubs décrit chaque club :

Fusionner, c'est construire une nouvelle table qui combine les enregistrements des deux tables dont le champ commun est égal.

def fusion(eleves, clubs):

    res = []

    for e in eleves:

        for c in clubs:

            if e["id_club"] == c["id_club"]:

                res.append({"nom": e["nom"],

                            "club": c["club"],

                            "salle": c["salle"]})

    return res

Avec $n$ élèves et $m$ clubs, les deux boucles imbriquées font $n \times m$ comparaisons. Pour faire mieux, on indexe d'abord la petite table par un dictionnaire dont la clé est le champ commun :

index = {c["id_club"]: c for c in clubs}

res = []

for e in eleves:

    c = index[e["id_club"]]

    res.append({"nom": e["nom"], "club": c["club"], "salle": c["salle"]})

Le coût devient proportionnel à $n + m$.

Les contrôles de cohérence entre tables vérifient par exemple que chaque id_club d'une table existe dans l'autre, ou qu'un identifiant censé être unique l'est bien.

Calculer des agrégats

Un traitement fréquent : regrouper les enregistrements selon un champ et calculer une valeur par groupe (somme, moyenne, maximum). Le dictionnaire convient très bien : la clé est le groupe.

Retour au début : pour les 40 000 inscrits de Rennes, on lit le CSV avec DictReader, on filtre par compréhension, on détecte les doublons avec un dictionnaire et on associe chaque emprunt à son livre avec un index sur id_livre.

L'essentiel

• Une table est une liste de dictionnaires (un par enregistrement) ; le fichier CSV la stocke en texte avec un séparateur et une ligne de descripteurs.

• csv.DictReader lit le fichier dans un bloc with ; toutes les valeurs sont des chaînes : convertir avec int ou float.

• Rechercher : compréhension avec un critère en logique (and, or, not) ; doublons et cohérence se contrôlent, un dictionnaire évite le coût en $n^2$.

• Trier : sorted(t, key=…, reverse=…) ; pour deux critères, une clé en couple ou deux tris successifs (secondaire d'abord) grâce à la stabilité.

• Fusionner : combiner deux tables via un champ commun ; indexer avec un dictionnaire ramène le coût de $n \times m$ à $n + m$ ; traiter les clés absentes.