Traiter des données en tables

Deux façons de désigner une case, et le programme les autorise toutes deux : le tableau de p-uplets nommés ci-dessus — eleves[0]["moyenne"] — ou le tableau doublement indexé du chapitre 4 — t[0][2]. La première est préférable dès que les colonnes ont un sens : ["moyenne"] reste juste si l'on insère une colonne, [2] devient faux en silence. C'est l'argument du chapitre 4 sur les p-uplets nommés, appliqué à des milliers de lignes.

6.2 Importer une table

nom,classe,moyenne,option
Nour,1G3,15.5,NSI
Camille,1G1,12.0,SVT
Yanis,1G3,9.5,NSI
Sofia,1G2,17.25,NSI
Adam,1G1,13.0,SES

import csv

def importer(chemin, separateur=","):
    """Table lue depuis un fichier CSV à ligne d'en-tête.

    Précondition  : le fichier existe, est encodé en UTF-8, et sa première
                    ligne porte les descripteurs.
    Postcondition : toutes les lignes renvoyées ont exactement les mêmes clés.
    """
    with open(chemin, "r", encoding="utf-8", newline="") as f:
        table = [dict(ligne) for ligne in csv.DictReader(f, delimiter=separateur)]
    if len(table) > 0:
        descripteurs = set(table[0].keys())
        assert all(set(l.keys()) == descripteurs for l in table), "lignes heterogenes"
    return table

"9.5" > "15.5"          # True  <- chaines : '9' vient apres '1'
9.5 > 15.5              # False <- la verite

def convertir(table, colonne, fonction):
    """Applique fonction à une colonne de la table, sur place.

    Précondition : la colonne existe dans toutes les lignes et toutes ses
                   valeurs sont acceptables par fonction.
    """
    assert all(colonne in ligne for ligne in table), "colonne absente"
    for ligne in table:
        ligne[colonne] = fonction(ligne[colonne])


eleves = importer("eleves.csv")
convertir(eleves, "moyenne", float)      # à faire AVANT tout tri, toute comparaison

6.3 Rechercher dans une table

« Logique propositionnelle » désigne ici les opérateurs booléens du chapitre 2 : and, or, not, combinés en une condition. La recherche s'écrit alors en une ligne : on garde les enregistrements qui vérifient la condition.

def selection(table, critere):
    """Lignes de la table qui vérifient le critère.

    critere est une FONCTION prenant une ligne et renvoyant un booléen.
    Postcondition : le résultat est un sous-ensemble de la table, dans le
                    même ordre, et sa longueur est au plus celle de la table.
    """
    return [ligne for ligne in table if critere(ligne)]


def bons_nsi(ligne):
    return ligne["option"] == "NSI" and ligne["moyenne"] >= 14

selection(eleves, bons_nsi)        # Nour et Sofia

6.4 Doublons et cohérence

Le programme demande explicitement que « la recherche de doublons » et « les tests de cohérence d'une table » soient présentés. Une table importée d'ailleurs est rarement propre.

def doublons(table, colonne):
    """Valeurs de la colonne qui apparaissent plus d'une fois."""
    effectifs = {}
    for ligne in table:
        v = ligne[colonne]
        effectifs[v] = effectifs.get(v, 0) + 1
    return [v for v, n in effectifs.items() if n > 1]

C'est le compteur du chapitre 5, appliqué à une colonne. Chercher les doublons en comparant chaque ligne à toutes les autres coûterait $n^2$ comparaisons ; le dictionnaire ramène le travail à un seul parcours — un premier aperçu de ce que le chapitre 7 appellera le coût d'un algorithme.

def hors_domaine(table, colonne, valide):
    """Lignes dont la valeur de colonne sort du domaine.

    valide est une fonction qui dit si une valeur est acceptable.
    """
    return [ligne for ligne in table if not valide(ligne[colonne])]


def moyenne_valide(x):
    return isinstance(x, float) and 0.0 <= x <= 20.0

hors_domaine(eleves, "moyenne", moyenne_valide)     # [] si la table est saine

6.5 Trier une table

Un point mérite d'être vu plutôt que lu : trier une table ne trie pas une colonne, il réordonne des lignes — chaque enregistrement reste d'un bloc.

Figure : Trier sur la colonne `annee`. Les lignes changent de place entières : un enregistrement ne se disloque jamais.

Le programme autorise ici l'emploi d'une fonction toute faite : « une fonction de tri intégrée au système ou à une bibliothèque peut être utilisée ». Les algorithmes de tri seront écrits à la main au chapitre 7 ; ici, on s'en sert.

def cle_moyenne(ligne):
    return ligne["moyenne"]

classement = sorted(eleves, key=cle_moyenne, reverse=True)

sorted renvoie une nouvelle table et laisse l'originale intacte — ce qui est presque toujours ce qu'on veut. Le paramètre key reçoit une fonction qui, pour chaque ligne, donne la valeur sur laquelle comparer.

"9.5", "17.25", "15.5", "13.0", "12.0"     <- ordre des CHAÎNES
17.25, 15.5, 13.0, 12.0, 9.5               <- l'ordre attendu

def cle_classe_puis_moyenne(ligne):
    return (ligne["classe"], -ligne["moyenne"])

sorted(eleves, key=cle_classe_puis_moyenne)

6.6 Fusionner deux tables

Deux tables se combinent quand elles partagent une colonne — la clé de rapprochement. Ici, une table d'élèves et une table de classes, reliées par la colonne classe.

classe,professeur,salle
1G1,Benali,204
1G2,Roux,112
1G3,Diallo,305

def fusion(table1, table2, cle):
    """Table combinant les lignes des deux tables qui partagent la même clé.

    Précondition  : la colonne cle existe dans les deux tables, et ses valeurs
                    sont uniques dans table2.
    Postcondition : le résultat a au plus autant de lignes que table1 ; chaque
                    ligne porte les descripteurs des deux tables.
    """
    assert all(cle in l for l in table1) and all(cle in l for l in table2)
    assert len(doublons(table2, cle)) == 0, "cle non unique dans table2"

    index = {ligne[cle]: ligne for ligne in table2}     # accès direct, chapitre 5
    resultat = []
    for ligne in table1:
        if ligne[cle] in index:
            combinee = dict(ligne)
            combinee.update(index[ligne[cle]])
            resultat.append(combinee)
    assert len(resultat) <= len(table1)
    return resultat

Figure : La fusion rapproche les lignes par l'égalité des valeurs de la clé. C'est pourquoi

le domaine de valeurs décide du succès de l'opération.</div>

ImportantC'est le domaine de valeurs qui décide du succès

Le rapprochement se fait sur l'égalité des valeurs de la clé. Il suffit donc d'un écart d'écriture — "1G3" d'un côté, "1g3" ou " 1G3" de l'autre — pour que la ligne disparaisse de la fusion. Sans erreur, sans avertissement : le résultat est simplement plus court.

C'est pourquoi le programme demande que « la notion de domaine de valeurs soit mise en évidence » précisément à propos de la fusion. Toujours comparer le nombre de lignes obtenu à celui attendu — c'est le contrôle qui coûte une ligne et détecte le désastre.

complete = fusion(eleves, classes, "classe")
if len(complete) < len(eleves):
    print("Attention :", len(eleves) - len(complete), "ligne(s) sans correspondance")

Piste de projet : Exploiter des données ouvertes

Choisir un jeu de données ouvert réel — qualité de l'air, fréquentation des transports, résultats électoraux, catalogue d'une médiathèque — et en faire une petite étude : import, contrôle de cohérence et de domaine, recherches par critères composés, tri, fusion avec une seconde table, et quelques conclusions présentées à la classe.

L'intérêt tient à ce que les données réelles sont sales : accents mal encodés, colonnes vides, doublons, valeurs aberrantes. Le rapport doit dire combien de lignes ont été écartées et pourquoi — c'est cette honnêteté-là qui distingue une étude d'une illustration.

Continuer sur Adloun : animation, QCM, fiches, exercices