Partie 2 : Opérations sur les tables (recherche, tri, sélection)

Programme officiel (B.O.)

B.O. spécial n° 1 du 22 janvier 2019 - NSI Première

Contenus	Capacités attendues	Commentaires
Recherche dans une table	Rechercher les lignes d'une table vérifiant des critères exprimés en logique propositionnelle.	La recherche de doublons, les ## tests de cohérence d'une table sont présentés.
Tri d'une table	Trier une table suivant une colonne.	On se limite à un tri suivant une seule colonne.

---

1. Sélection de colonnes (projection)

La projection consiste à ne garder que certaines colonnes d'une table.

1.1 Principe

À partir d'une table complète :

table = [
    {"nom": "Dupont", "prenom": "Marie", "age": 16, "ville": "Lyon"},
    {"nom": "Martin", "prenom": "Léo", "age": 17, "ville": "Paris"},
    {"nom": "Durand", "prenom": "Emma", "age": 16, "ville": "Lille"}
]

On peut extraire uniquement les colonnes "prenom" et "ville" :

projection = [{"prenom": e["prenom"], "ville": e["ville"]} for e in table]

Résultat :

[
    {"prenom": "Marie", "ville": "Lyon"},
    {"prenom": "Léo", "ville": "Paris"},
    {"prenom": "Emma", "ville": "Lille"}
]

1.2 Fonction générique

def projeter(table, colonnes):
    """Renvoie une nouvelle table ne contenant que les colonnes indiquées."""
    return [{col: ligne[col] for col in colonnes} for ligne in table]

resultat = projeter(table, ["nom", "age"])

---

2. Sélection de lignes (filtrage)

Le filtrage consiste à ne garder que les lignes qui vérifient une condition.

2.1 Critère simple

# Élèves de 16 ans
jeunes = [e for e in table if e["age"] == 16]

2.2 Critères combinés

On peut combiner les conditions avec and, or, not :

# Élèves de 16 ans habitant Lyon
critere = [e for e in table if e["age"] == 16 and e["ville"] == "Lyon"]

# Élèves habitant Paris ou Lyon
grandes_villes = [e for e in table if e["ville"] in ["Paris", "Lyon"]]

2.3 Fonction générique

def filtrer(table, attribut, valeur):
    """Renvoie les lignes où l'attribut a la valeur donnée."""
    return [ligne for ligne in table if ligne[attribut] == valeur]

lyonnais = filtrer(table, "ville", "Lyon")

---

3. Tri d'une table

3.1 Trier avec sorted()

La fonction sorted() permet de trier un tableau de dictionnaires selon un attribut :

# Tri par âge (croissant)
par_age = sorted(table, key=lambda e: e["age"])

# Tri par nom (alphabétique)
par_nom = sorted(table, key=lambda e: e["nom"])

# Tri par âge décroissant
par_age_desc = sorted(table, key=lambda e: e["age"], reverse=True)

Le paramètre key

key attend une fonction qui, pour chaque élément, renvoie la valeur utilisée pour la comparaison. lambda e: e["age"] est une fonction anonyme qui renvoie l'âge de l'élève e.

3.2 Tri en place avec sort()

La méthode sort() modifie la table directement (sans en créer une nouvelle) :

table.sort(key=lambda e: e["nom"])

3.3 Stabilité du tri

Le tri de Python est stable : si deux éléments ont la même valeur pour le critère de tri, leur ordre relatif d'origine est conservé.

table = [
    {"nom": "Dupont", "prenom": "Marie", "age": 16},
    {"nom": "Martin", "prenom": "Léo", "age": 16},
    {"nom": "Durand", "prenom": "Emma", "age": 17}
]

par_age = sorted(table, key=lambda e: e["age"])
# Marie et Léo ont 16 ans : ils restent dans l'ordre d'origine

---

4. Recherche de doublons

4.1 Principe

Un doublon est un enregistrement qui apparait deux fois (ou plus) dans la table. On peut chercher les doublons sur un attribut particulier ou sur l'ensemble des attributs.

4.2 Doublons sur un attribut

def doublons(table, attribut):
    """Renvoie les valeurs de l'attribut qui apparaissent plus d'une fois."""
    vus = []
    en_double = []
    for ligne in table:
        valeur = ligne[attribut]
        if valeur in vus and valeur not in en_double:
            en_double.append(valeur)
        vus.append(valeur)
    return en_double

table = [
    {"nom": "Dupont", "age": 16},
    {"nom": "Martin", "age": 17},
    {"nom": "Dupont", "age": 15},
    {"nom": "Durand", "age": 16}
]

print(doublons(table, "nom"))    # ['Dupont']
print(doublons(table, "age"))    # [16]

4.3 Supprimer les doublons

def sans_doublons(table, attribut):
    """Renvoie une table sans doublons sur l'attribut donné (garde le premier)."""
    vus = []
    resultat = []
    for ligne in table:
        if ligne[attribut] not in vus:
            vus.append(ligne[attribut])
            resultat.append(ligne)
    return resultat

---

5. Tests de cohérence

Avant de traiter des données, il est important de vérifier leur cohérence : valeurs manquantes, types incorrects, valeurs aberrantes.

5.1 Valeurs manquantes

def valeurs_manquantes(table, attribut):
    """Renvoie les indices des lignes où l'attribut est vide."""
    indices = []
    for i, ligne in enumerate(table):
        if attribut not in ligne or ligne[attribut] == "":
            indices.append(i)
    return indices

5.2 Valeurs aberrantes

def valeurs_aberrantes(table, attribut, val_min, val_max):
    """Renvoie les lignes où l'attribut est hors de l'intervalle attendu."""
    return [ligne for ligne in table if ligne[attribut] < val_min or ligne[attribut] > val_max]

# Exemple : âges aberrants (hors [10, 20])
aberrants = valeurs_aberrantes(table, "age", 10, 20)

5.3 Vérification des types

def verifier_entiers(table, attribut):
    """Vérifie que toutes les valeurs d'un attribut sont des entiers."""
    for i, ligne in enumerate(table):
        try:
            int(ligne[attribut])
        except (ValueError, TypeError):
            print(f"Ligne {i} : '{ligne[attribut]}' n'est pas un entier")

---

6. Agrégation (statistiques sur une colonne)

L'agrégation consiste à calculer une valeur résumant une colonne entière.

table = [
    {"nom": "Dupont", "note": 15},
    {"nom": "Martin", "note": 12},
    {"nom": "Durand", "note": 18},
    {"nom": "Petit", "note": 9}
]

notes = [e["note"] for e in table]

print(f"Nombre : {len(notes)}")         # 4
print(f"Somme  : {sum(notes)}")         # 54
print(f"Moyenne : {sum(notes)/len(notes)}")  # 13.5
print(f"Min    : {min(notes)}")         # 9
print(f"Max    : {max(notes)}")         # 18

---

7. Résumé

Opération	Description	Syntaxe Python
Projection	Garder certaines colonnes	Compréhension avec sélection de clés
Filtrage	Garder certaines lignes	[e for e in table if condition]
Tri	Ordonner les lignes	sorted(table, key=lambda e: e["col"])
Doublons	Repérer les valeurs en double	Parcours avec ensemble des valeurs vues
Cohérence	Vérifier les données	Tests sur les valeurs manquantes, types, bornes
Agrégation	Résumer une colonne	sum(), min(), max(), len()