Chapitre 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" :
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¶
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) :
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() |