$course$/QCM de NSI/Première/Tables de données Représentation tabulaire des données, descripteurs
(colonnes), enregistrements (lignes), opérations courantes
(recherche, tri, sélection, fusion, jointure simple), en
Python avec listes de dictionnaires ou listes de listes.

]]> Tables de données — Q01 : Qu'est-ce qu'une table ? En informatique, qu'appelle-t-on une table de données ?

]]> Les tables sont la structure la plus simple et la
plus répandue pour organiser des données : tableurs,
bases relationnelles, fichiers CSV, DataFrames pandas
reposent tous sur ce modèle.

]]> 1.0 0.0 0 true true abc Un fichier texte dont les valeurs sont séparées par des virgules

]]> Erreur : c'est la description du format
CSV, qui n'est qu'un moyen de stocker
une table dans un fichier. La table
elle-même est la structure abstraite
(lignes et colonnes), indépendante de son
format d'enregistrement.

]]> Un type primitif fondamental fourni nativement par Python

]]> Erreur : Python n'a pas de type natif "table".
On peut la simuler avec des listes ou
dictionnaires.

]]> Un tableau de lignes (enregistrements) et de colonnes (descripteurs)

]]> Bonne réponse : c'est la définition standard,
identique à celle d'un tableur ou d'une table
de base de données. Chaque ligne décrit une
entité (élève, livre...), chaque colonne un
attribut (nom, âge...).

]]> Une fonction Python qui renvoie un dictionnaire

]]> Erreur : c'est éventuellement un moyen de
représenter une table, pas la définition
elle-même.

]]> Tables de données — Q02 : Vocabulaire Comment appelle-t-on une colonne dans une table
de données ?

]]> Vocabulaire à maîtriser : ligne = enregistrement
= entité ; colonne = descripteur = attribut =
champ. Selon le manuel, le mot peut varier.

]]> 1.0 0.0 0 true true abc Une ligne

]]> Erreur : confusion ligne/colonne. Une ligne
décrit une entité.

]]> Une clé primaire

]]> Erreur : une clé primaire est un descripteur particulier qui identifie de manière unique
chaque ligne. Toutes les colonnes ne sont pas
des clés primaires.

]]> Un enregistrement, c'est-à-dire une entité complète de la table

]]> Erreur : un enregistrement est une ligne,
pas une colonne.

]]> Un descripteur (ou attribut, ou champ)

]]> Bonne réponse : la colonne décrit une propriété
commune à toutes les entités (par exemple
"nom", "age", "ville"). Les termes
"descripteur", "attribut", "champ" sont
synonymes selon le contexte.

]]> Tables de données — Q03 : Liste de dictionnaires Comment représente-t-on couramment une table en
Python (avec en-tête) ?

]]> Autres représentations possibles : liste de
tuples, liste de listes, dict de listes (« colonne
par colonne »). Le choix dépend de l'usage. Pour
le NSI Première, on utilise principalement la liste
de dictionnaires.

]]> 1.0 0.0 0 true true abc Comme une seule et longue chaîne de caractères unique

]]> Erreur : ce ne serait pas pratique pour
manipuler les données.

]]> Comme une liste de dictionnaires, un par ligne

]]> Bonne réponse : exemple
[{"nom":"Alice","age":17}, {"nom":"Bob","age":16}].
C'est ce que renvoie csv.DictReader quand on
le convertit en liste. Très lisible
(ligne["nom"]).

]]> Comme une fonction

]]> Erreur : une fonction décrit un calcul, pas
des données.

]]> Comme un entier

]]> Erreur : un entier ne stocke aucune
structure.

]]> Tables de données — Q04 : Accéder à une cellule Soit
`python
table = [
{"nom": "Alice", "age": 17},
{"nom": "Bob", "age": 16}
]
`
Comment accéder à l'âge de Bob ?

]]> Schéma général : table[indice_ligne][descripteur].
L'ordre des accès reflète la structure : d'abord
la liste, puis le dictionnaire.

]]> 1.0 0.0 0 true true abc table[1]['age']

]]> Bonne réponse : Bob est la deuxième ligne
(indice 1), et 'age' est le descripteur. On
obtient 16.

]]> table['Bob']['age']

]]> Erreur : table est une liste, pas un
dictionnaire indexé par nom. Cela lève
TypeError.

]]> table[2]['age']

]]> Erreur : indice hors-borne. Avec deux
lignes, les indices valides sont 0 et 1, pas
2 (IndexError).

]]> table.age[1]

]]> Erreur : aucune méthode ni attribut .age sur
une liste (AttributeError).

]]> Tables de données — Q05 : Parcourir une table Pour afficher tous les noms d'élèves d'une table
(liste de dictionnaires avec une clé "nom"), quel
code utilise-t-on ?

]]> Schéma classique de parcours d'une liste de
dictionnaires. À retenir.

]]> 1.0 0.0 0 true true abc `python
for ligne in table:
print(ligne.nom)
`

]]> Erreur : un dictionnaire n'a pas d'attribut
.nom, cette écriture lève AttributeError.
La valeur d'une clé s'obtient avec des
crochets : ligne["nom"].

]]> `python
for ligne in table:
print(ligne["nom"])
`

]]> Bonne réponse : la boucle parcourt chaque
dictionnaire, et on accède à la valeur de la
clé "nom".

]]> `python
for nom in table:
print(nom)
`

]]> Erreur : la variable nom recevrait chaque
dictionnaire entier, pas le nom seulement.

]]> `python
for ligne in table:
print(table["nom"])
`

]]> Erreur : dans la boucle, c'est ligne qu'il
faut indexer. table est une liste, on ne
peut pas l'indexer par une chaîne : TypeError.

]]> Tables de données — Q06 : Origine des tables D'où peut provenir une table de données dans un
projet réel ?

]]> Une compétence clé du NSI : savoir lire des
données réelles (souvent en CSV ou JSON), les
transformer en table Python, puis les manipuler.

]]> 1.0 0.0 0 true true abc D'un fichier CSV ou JSON, d'un tableur, d'une base, d'une API...

]]> Bonne réponse : les tables sont partout en
informatique. Open Data (data.gouv.fr),
extracts SQL, exports Excel, scraping web...
autant de sources possibles.

]]> Uniquement de données saisies à la main au clavier

]]> Trop restrictif : une table peut aussi provenir
d'un fichier, d'une base ou d'une API, sans aucune
saisie manuelle.

]]> Uniquement d'un fichier CSV créé à la main

]]> Trop restrictif : il existe de nombreuses
autres sources.

]]> Uniquement à partir d'une base de données relationnelle SQL

]]> Trop restrictif : SQL est une source
fréquente mais pas la seule.

]]> Tables de données — Q07 : Recherche par critère Pour trouver toutes les lignes où l'âge est
strictement supérieur à 16, quel code écrit-on ?

]]> Compréhension de liste : schéma Python élégant
pour filtrer, transformer et combiner. Très
utilisé sur les tables.

]]> 1.0 0.0 0 true true abc `python
for ligne in table:
if ligne["age"] > 16:
print(ligne)
`

]]> Cela affiche les lignes mais ne renvoie
pas une liste. Si la question est "trouver",
on attend une valeur de retour, pas un
affichage.

]]> `python
[ligne for ligne in table if ligne["age"] > 16]
`

]]> Bonne réponse : compréhension de liste avec
condition. Forme idiomatique en Python pour
filtrer.

]]> `python
table.find(age > 16)
`

]]> Erreur : la méthode .find() n'existe pas
sur les listes.

]]> `python
table[ligne["age"] > 16]
`

]]> Erreur : syntaxe invalide. ligne n'est pas
défini hors d'une boucle.

]]> Tables de données — Q08 : Construire depuis CSV Quel est le moyen le plus simple de construire une
table (liste de dictionnaires) à partir d'un fichier
CSV avec en-tête ?

]]> Idiome standard. Penser à fermer le fichier
proprement avec un with, ou utiliser cette
écriture compacte si le fichier est petit.

]]> 1.0 0.0 0 true true abc Lire le fichier ligne par ligne et coder à la main le découpage

]]> Erreur : possible mais fastidieux et fragile
(séparateur, guillemets, en-tête). Le module
csv fait ce découpage pour nous.

]]> csv.load('data.csv') (cette fonction existe-t-elle ?)

]]> Erreur : cette fonction n'existe pas dans le
module csv (AttributeError).

]]> list(csv.DictReader(open('data.csv', encoding='utf-8')))

]]> Bonne réponse : csv.DictReader produit un
itérateur de dictionnaires (un par ligne, avec
pour clés les noms de l'en-tête) ; list() le
matérialise en table prête à l'emploi.

]]> list(csv.reader(open('data.csv', encoding='utf-8')))

]]> Erreur : csv.reader produit des listes,
pas des dictionnaires, et la ligne d'en-tête
est lue comme les autres. Sur un fichier
nom,age on obtient
[['nom', 'age'], ['Alice', '17'], ...], sans
accès par descripteur.

]]> Tables de données — Q09 : Nombre de lignes Comment obtenir le nombre d'enregistrements
(lignes) d'une table représentée comme liste de
dictionnaires ?

]]> Pour le nombre de colonnes, on regarde les
clés du premier dictionnaire :
len(table[0]) (en supposant la table non vide).

]]> 1.0 0.0 0 true true abc size(table)

]]> Erreur : pas de fonction size en Python
standard.

]]> len(table.keys())

]]> Erreur : .keys() n'existe pas sur une
liste. Cela lève AttributeError.

]]> len(table)

]]> Bonne réponse : len() sur la liste donne le
nombre de dictionnaires, donc de lignes.

]]> table.count

]]> Erreur : .count est une méthode (qui
compte les occurrences d'un élément), il faut
l'appeler avec des parenthèses et un
argument.

]]> Tables de données — Q10 : Table vide Que vaut len(table) pour une table vide ?

]]> Toujours penser au cas de la table vide dans les
calculs : moyenne = total / len(table) lèverait
ZeroDivisionError.

]]> 1.0 0.0 0 true true abc Une exception est levée

]]> Erreur : len([]) renvoie 0 sans erreur.

]]> 0

]]> Bonne réponse : [] (liste vide) contient
zéro élément.

]]> -1

]]> Erreur : len n'est jamais négatif.

]]> None

]]> Erreur : len renvoie toujours un entier.

]]> Tables de données — Q11 : Trier par descripteur On dispose de la fonction clé
`python
def age(ligne):
return ligne["age"]
`
Comment trier la table par âge croissant ?

]]> Pour trier sans modifier la table d'origine :
sorted(table, key=age). Pour un tri
décroissant, ajouter reverse=True. On passe
la fonction elle-même (age, sans parenthèses) :
c'est sort qui l'appelle sur chaque ligne.

]]> 1.0 0.0 0 true true abc table.sort(key=age)

]]> Bonne réponse : key indique la fonction qui
calcule, pour chaque ligne, la valeur sur
laquelle comparer. Ici age renvoie l'âge de
la ligne. Tri en place de la liste.

]]> table.sort(reverse=False)

]]> Erreur : reverse=False est déjà la valeur
par défaut, et il manque key : sans lui,
sort ne sait pas comparer deux
dictionnaires entre eux (TypeError).

]]> sorted(table, by=age)

]]> Erreur : sorted n'a pas d'argument by
(TypeError). C'est key= qu'il faut.

]]> table.sort(age)

]]> Erreur : sort n'accepte aucun argument
positionnel (TypeError). La fonction de clé
doit être nommée : key=age.

]]> Tables de données — Q12 : Sélectionner des colonnes Comment construire une nouvelle table resultat ne
contenant que les colonnes nom et age de table
(sans les autres descripteurs) ?

]]> Cette opération consiste à extraire un
sous-ensemble de colonnes d'une table (on parle
aussi de projection). C'est l'une des manipulations
classiques de tables, au même titre que la
sélection de lignes, le tri ou la fusion. En
compréhension de liste :
[{"nom": l["nom"], "age": l["age"]} for l in table].

]]> 1.0 0.0 0 true true abc `python
resultat = []
for l in table:
resultat.append(l[["nom", "age"]])
`

]]> Erreur : syntaxe inspirée de pandas, pas de
Python standard. Un dictionnaire ne s'indexe pas
par une liste de clés (TypeError) : il faut
extraire chaque clé séparément.

]]> `python
resultat = {}
for l in table:
for k in ["nom", "age"]:
resultat[k] = l[k]
`

]]> Erreur : resultat est un dictionnaire
unique dont on écrase les deux valeurs à chaque
ligne. On obtient le nom et l'âge de la dernière
ligne seulement, et non une table.

]]> `python
resultat = []
for l in table:
resultat.append({"nom": l["nom"], "age": l["age"]})
`

]]> Bonne réponse : pour chaque ligne, on construit
un nouveau dictionnaire ne gardant que les deux
clés voulues, et on l'ajoute à la nouvelle
table.

]]> `python
resultat = []
for l in table:
for k in ["nom", "age"]:
resultat.append({k: l[k]})
`

]]> Erreur : chaque tour ajoute un dictionnaire à
une seule clé. La table obtenue compte deux
fois plus de lignes que l'originale, le nom et
l'âge d'un même élève étant séparés sur deux
lignes.

]]> Tables de données — Q13 : Fusion de tables Soient deux tables t1 et t2 ayant les mêmes descripteurs. Comment obtenir une nouvelle table
contenant toutes les lignes de t1 puis celles de
t2 ?

]]> Pour modifier t1 en place au lieu de créer
une nouvelle table : t1 += t2, ou une boucle
qui ajoute chaque ligne de t2 avec append.

]]> 1.0 0.0 0 true true abc t1.append(t2)

]]> Attention : append(t2) ajouterait t2
comme un seul élément (une liste de
listes), pas en fusionnant. Pour ajouter
les lignes une à une, il faudrait une
boucle : for ligne in t2: t1.append(ligne).

]]> fusion(t1, t2)

]]> Erreur : pas de fonction fusion en Python
standard.

]]> t1.merge(t2)

]]> Erreur : pas de méthode .merge sur les
listes (cela ressemble à du pandas).

]]> t1 + t2

]]> Bonne réponse : la concaténation de listes
(+) crée une nouvelle liste contenant tous
les éléments. Idiome Python standard.

]]> Tables de données — Q14 : Calculer une moyenne Comment calculer la moyenne des âges d'une
table avec un descripteur age (entier) ?

]]> Penser à gérer le cas de la table vide
(division par zéro) : tester if table: avant
le calcul, ou utiliser
sum(...) / len(table) if table else 0.

]]> 1.0 0.0 0 true true abc sum(ligne.age for ligne in table) / len(table)

]]> Erreur : un dictionnaire n'a pas d'attribut
.age (AttributeError). La valeur d'un
descripteur s'obtient par ligne['age'].

]]> sum(ligne['age'] for ligne in table) / len(table[0])

]]> Erreur : len(table[0]) compte les
descripteurs de la première ligne (le
nombre de colonnes), pas le nombre de lignes.
Il faut diviser par len(table).

]]> sum(table['age']) / len(table)

]]> Erreur : table est une liste, on ne
peut pas l'indexer par chaîne. Lève
TypeError.

]]> sum(ligne['age'] for ligne in table) / len(table)

]]> Bonne réponse : on extrait la valeur age
pour chaque ligne via une expression
génératrice, puis on divise par le nombre de
lignes.

]]> Tables de données — Q15 : Jointure simple Soient
`python
eleves = [
{"id": 1, "nom": "Alice"},
{"id": 2, "nom": "Bob"}
]
notes = [
{"id_eleve": 1, "matiere": "Maths", "note": 15},
{"id_eleve": 2, "matiere": "NSI", "note": 18}
]
`
Pour associer chaque note au nom de l'élève, on
effectue une jointure. Quel code l'implémente
correctement ?

]]> C'est l'opération de fusion de deux tables sur
une clé commune. Pour gagner en performance, on
peut indexer eleves par id dans un dictionnaire
au préalable.

]]> 1.0 0.0 0 true true abc `python
for n in notes:
for e in eleves:
print(e["nom"], n["matiere"], n["note"])
`

]]> Erreur : sans la condition d'égalité
n["id_eleve"] == e["id"], on produit le
produit cartésien : chaque note est
associée à tous les élèves, pas au sien
(quatre lignes affichées au lieu de deux).

]]> `python
for n in notes:
for e in eleves:
if n["id_eleve"] == e["id_eleve"]:
print(e["nom"], n["matiere"], n["note"])
`

]]> Erreur : la clé commune ne porte pas le même
nom dans les deux tables : "id" dans
eleves, "id_eleve" dans notes.
e["id_eleve"] lève donc KeyError dès la
première comparaison.

]]> `python
for n in notes:
for e in eleves:
if n["id_eleve"] == e["id"]:
print(e["nom"], n["matiere"], n["note"])
`

]]> Bonne réponse : on parcourt les notes et,
pour chacune, on cherche l'élève
correspondant. On affiche Alice Maths 15
puis Bob NSI 18. Complexité O(n × m).

]]> `python
for n in notes:
print(eleves[n["id_eleve"]]["nom"], n["matiere"], n["note"])
`

]]> Erreur : eleves[1] accède à l'indice 1
de la liste, pas à l'élève d'id 1. Ici la
note de Maths est attribuée à Bob, puis
eleves[2] lève IndexError. Un identifiant
n'est pas un indice.

]]> Tables de données — Q16 : Pièges de conversion Après lecture d'un CSV avec csv.DictReader, on
veut calculer la moyenne des âges. Quel piège
faut-il éviter ?

]]> Piège classique chez les débutants : oublier la
conversion. Symptôme : addition qui concatène
des chaînes ou comparaison qui plante.

]]> 1.0 0.0 0 true true abc Le module csv ne gère pas les fichiers de plus de 100 lignes

]]> Erreur : il gère sans problème des fichiers de
plusieurs millions de lignes.

]]> Toujours initialiser une variable globale

]]> Pas un piège spécifique au CSV.

]]> Il faut payer une licence pour utiliser csv.DictReader

]]> Erreur : le module csv est gratuit et inclus
dans Python standard.

]]> Oublier de convertir les valeurs en int (les valeurs lues sont des chaînes)

]]> Bonne réponse : csv.DictReader ne fait
aucune conversion de type. "17" + "16"
donne "1716", pas 33. Toujours convertir
avant de calculer.

]]> Tables de données — Q17 : Compter par catégorie Soit
`python
table = [
{"nom": "Alice", "ville": "Lyon"},
{"nom": "Bob", "ville": "Paris"},
{"nom": "Chloé", "ville": "Lyon"}
]

Quel code construit le dictionnaire c donnant le
nombre d'élèves dans chaque ville, ici
{"Lyon": 2, "Paris": 1}` ?

]]> Schéma général du comptage par catégorie : un
dictionnaire dont les clés sont les catégories et
les valeurs les effectifs. Le test if v in c
distingue la première rencontre d'une catégorie
(création de la clé) des suivantes (incrément).

]]> 1.0 0.0 0 true true abc `python
c = {}
for ligne in table:
v = ligne["ville"]
if v in c:
c[v] = 1
else:
c[v] = c[v] + 1
`

]]> Erreur : les deux branches sont inversées. À la
première rencontre d'une ville, la clé v
n'existe pas encore dans c, et c[v] + 1
lève KeyError (ici dès "Lyon"). C'est la
première rencontre qui doit créer la clé à 1.

]]> `python
c = {}
for ligne in table:
v = ligne["ville"]
if v in c:
c[v] = c[v] + 1
else:
c[v] = 1
`

]]> Bonne réponse : on construit progressivement
un dictionnaire ville → effectif. À la
première rencontre d'une ville, on crée la clé
avec la valeur 1 ; ensuite, on incrémente.

]]> `python
c = {}
for ligne in table:
v = ligne["ville"]
if v in table:
c[v] = c[v] + 1
else:
c[v] = 1
`

]]> Erreur : le test d'appartenance porte sur
table, qui ne contient que des dictionnaires,
jamais une chaîne : il est toujours faux et
chaque ville est remise à 1. On obtient
{"Lyon": 1, "Paris": 1} : une présence, pas
un comptage.

]]> `python
c = {}
for ligne in table:
v = ligne["ville"]
c[v] = table.count(v)
`

]]> Erreur : count cherche l'élément exact v
(une chaîne) dans table, qui ne contient que
des dictionnaires : il renvoie toujours 0.
On obtient {"Lyon": 0, "Paris": 0}.

]]> Tables de données — Q18 : Tri sur deux critères Soit
`python
table = [
{"nom": "Lou", "age": 17},
{"nom": "Bob", "age": 16},
{"nom": "Ana", "age": 17}
]
`
Quel code trie la table par âge croissant, puis
par nom alphabétique en cas d'égalité ?

]]> Astuce : la comparaison des tuples en Python est
lexicographique (premier élément, puis deuxième en
cas d'égalité), ce qui simplifie beaucoup les tris
sur plusieurs critères. La fonction clé renvoie le
tuple des critères dans l'ordre de priorité.

]]> 1.0 0.0 0 true true abc `python
def cle(l):
return (l["age"], l["nom"])
table.sort(key=cle)
`

]]> Bonne réponse : la clé est un tuple.
Python compare les tuples élément par
élément : d'abord l'âge, puis le nom en cas
d'égalité. On obtient Bob (16), Ana (17),
Lou (17).

]]> `python
def cle(l):
return l["age"] + l["nom"]
table.sort(key=cle)
`

]]> Erreur : on ne peut pas additionner un entier
et une chaîne (TypeError). Et même entre
chaînes, une concaténation ne définirait pas
un ordre sur deux critères.

]]> `python
def cle(l):
return (l["nom"], l["age"])
table.sort(key=cle)
`

]]> Erreur : l'ordre des critères est inversé. Le
premier élément du tuple est le critère
principal, ici le nom. On obtient Ana, Bob,
Lou, sans tenir compte de l'âge.

]]> `python
def cle(l):
return l["age"]
table.sort(key=cle)
`

]]> Erreur : le tri ne porte que sur l'âge. En cas
d'égalité, sort conserve l'ordre initial des
lignes : on obtient Bob, Lou, Ana, et non Bob,
Ana, Lou.

]]> Tables de données — Q19 : Exemple concret Lequel des fichiers Open Data suivants se prête
naturellement à une représentation en table ?

]]> Open Data : data.gouv.fr, opendata.paris.fr,
INSEE... regorgent de jeux de données en CSV
directement utilisables.

]]> 1.0 0.0 0 true true abc La liste des stations Vélib' au format CSV

]]> Bonne réponse : un cas typique. Chaque ligne
= une station, descripteurs = nom,
longitude, latitude, capacité, etc. Idéal
pour traitement en table.

]]> Une carte des arrondissements de Paris au format SVG

]]> Erreur : SVG est un format vectoriel, pas
tabulaire.

]]> Un PDF illustré

]]> Erreur : un PDF est un format de
présentation, mal adapté à la manipulation
tabulaire (sauf après extraction).

]]> Une vidéo de présentation des différents transports urbains

]]> Erreur : un fichier multimédia ne se
structure pas en table.

]]> Tables de données — Q20 : Limite des tables Pour quel type de données les tables sont-elles
mal adaptées ?

]]> Règle générale : pour des données plates, la
table est adaptée ; pour des données hiérarchiques
(comme un arbre généalogique), un format imbriqué
(JSON par exemple) est plus naturel.

]]> 1.0 0.0 0 true true abc Une liste de produits avec prix

]]> Données plates : table parfaitement adaptée.

]]> Un classement sportif officiel regroupant plusieurs équipes

]]> Données plates : table adaptée.

]]> Un arbre généalogique avec des relations multiples

]]> Bonne réponse : les relations
parent/enfant/conjoint sont hiérarchiques.
Les tables peuvent les stocker, mais ce n'est
pas la représentation la plus naturelle pour
ce type de données.

]]> Une liste d'élèves avec nom, âge, ville

]]> Données plates : parfaitement adaptées à
une table.

]]> Tables de données — Q21 : Trace d'accès Soit
`python
t = [
{"a": 1, "b": 2},
{"a": 3, "b": 4},
{"a": 5, "b": 6}
]

Que vaut sum(l["a"] for l in t if l["b"] >= 4)` ?

]]> Méthode : (1) appliquer le filtre l["b"] >= 4
à chaque ligne ; (2) extraire l["a"] pour les
lignes restantes ; (3) sommer.

]]> 1.0 0.0 0 true true abc 12

]]> Erreur : tu as additionné les a de toutes
les lignes (1 + 3 + 5) sans filtrer.

]]> 8

]]> Bonne réponse : les lignes filtrées sont
{"a": 3, "b": 4} (b=4 ≥ 4) et
{"a": 5, "b": 6} (b=6 ≥ 4). Somme des a :
3 + 5 = 8.

]]> 0

]]> Erreur : il y a bien des lignes qui
satisfont l["b"] >= 4.

]]> 9

]]> Erreur : tu as inclus la première ligne
(a=1) à tort. Or b=2, donc le filtre rejette.

]]> Tables de données — Q22 : Transformer la structure On veut convertir la liste de dictionnaires
`python
table = [
{"x": 1, "y": 2},
{"x": 3, "y": 4}
]

en dictionnaire de listes {"x": [1, 3], "y": [2, 4]}
(représentation « colonne par colonne »), rangé
dans colonnes`. Quel code est correct ?

]]> La représentation colonne par colonne facilite les
calculs sur une colonne entière (somme, moyenne,
maximum de colonnes["x"]) sans reparcourir les
lignes. La transformation inverse (dictionnaire de
listes vers liste de dictionnaires) se fait de
façon symétrique.

]]> 1.0 0.0 0 true true abc `python
colonnes = {}
for k in table[0]:
colonnes[k] = [l[k] for l in table]
`

]]> Bonne réponse : pour chaque clé du premier
dictionnaire (les descripteurs), on construit
la liste des valeurs de cette clé sur toutes
les lignes.

]]> `python
colonnes = {}
for k in table:
colonnes[k] = [l[k] for l in table]
`

]]> Erreur : for k in table parcourt les
lignes (des dictionnaires), pas les clés.
l[k] avec k dictionnaire lève TypeError
(un dictionnaire ne peut pas servir de clé).
Il faut prendre les clés d'une ligne, par
exemple table[0].

]]> `python
colonnes = {}
for l in table:
for k in l:
colonnes[k] = l[k]
`

]]> Erreur : on range une valeur et non une
liste, écrasée à chaque ligne. On obtient
{"x": 3, "y": 4} : seule la dernière ligne
subsiste.

]]> `python
colonnes = []
for k in table[0]:
for l in table:
colonnes.append(l[k])
`

]]> Erreur : colonnes est une simple liste plate,
[1, 3, 2, 4] : les noms de colonnes sont
perdus. Il faut un dictionnaire dont chaque
valeur est la liste d'une colonne.

]]> Tables de données — Q23 : Performance d'une jointure Pour une jointure entre deux tables de tailles
n et m, la version naïve à deux boucles
imbriquées a une complexité de O(n × m). Comment
l'améliorer ?

]]> C'est exactement ce que font les SGBD avec leurs
index : transformer une recherche linéaire
en accès direct quasi instantané (table de
hachage ou arbre B).

]]> 1.0 0.0 0 true true abc En ne conservant que les colonnes utiles dans chacune des deux tables

]]> Erreur : la complexité dépend du nombre de
lignes parcourues, pas du nombre de colonnes.
Chaque ligne est plus légère, mais les deux
boucles imbriquées font toujours n × m
comparaisons.

]]> En triant d'abord les deux tables, tout en gardant les deux boucles imbriquées

]]> Erreur : trier ne sert à rien si l'on garde
ensuite les deux boucles imbriquées, qui font
toujours n × m comparaisons. Un tri n'accélère
une jointure que si l'algorithme en tire parti
(parcours simultané des deux tables triées), et
il coûte lui-même O(n log n).

]]> En indexant l'une des deux tables par sa clé dans un dictionnaire

]]> Bonne réponse : l'accès à un dictionnaire par
sa clé est en O(1). On construit l'index en un
seul parcours, avec idx[e["id"]] = e pour
chaque élève e, puis chaque note n ne
coûte qu'un accès : e = idx[n["id_eleve"]].
La jointure passe de O(n × m) à O(n + m),
beaucoup plus rapide pour de gros volumes.

]]> En représentant chaque ligne par un tuple plutôt que par un dictionnaire

]]> Erreur : changer la représentation d'une ligne
ne change pas le nombre de comparaisons, les
deux boucles imbriquées font toujours n × m
tours. Ce n'est pas une optimisation
algorithmique.

]]> Tables de données — Q24 : Bug subtil Un élève construit une table à partir d'une liste
de noms :
`python
noms = ["Alice", "Bob", "Chloé"]
ligne = {"nom": "", "age": 16}
table = []
for nom in noms:
ligne["nom"] = nom
table.append(ligne)
print(table[0]["nom"])
`
Qu'affiche ce programme, et pourquoi ?

]]> Piège classique de construction d'une table : un
dictionnaire est un objet modifiable, et une liste
ne stocke que des références. Réutiliser le même
dictionnaire pour toutes les lignes produit une
table de lignes identiques. Il faut créer un
dictionnaire neuf pour chaque enregistrement.

]]> 1.0 0.0 0 true true abc Chloé, car les trois lignes sont le même dictionnaire, modifié à chaque tour

]]> Bonne réponse : append range dans la table
une référence vers ligne, jamais une copie.
Les trois éléments de table désignent le
même dictionnaire, dont la clé "nom" vaut
"Chloé" après le dernier tour. Correction :
créer un dictionnaire neuf à chaque tour, en
plaçant ligne = {"nom": nom, "age": 16} dans
la boucle.

]]> Alice, car append range dans la table une copie de ligne à chaque tour

]]> Erreur : append ne copie rien, il ajoute une
référence vers l'objet. Les trois lignes sont
le même dictionnaire, et table[0]["nom"]
vaut "Chloé".

]]> Chloé, car append insère chaque nouvelle ligne en tête de la table

]]> Erreur : append ajoute toujours en fin
de liste. La valeur affichée est bien Chloé,
mais pour une autre raison : les trois lignes
sont le même dictionnaire.

]]> Rien, car ajouter plusieurs fois le même dictionnaire à une liste lève une erreur

]]> Erreur : une liste peut contenir plusieurs fois
le même objet sans aucune erreur. Le programme
s'exécute et affiche Chloé.

]]> Tables de données — Q25 : Synthèse Parmi les affirmations suivantes sur les tables de
données, laquelle est fausse ?

]]> Les tables de données et leurs opérations
associées (recherche, tri, fusion) sont au cœur
du traitement de données. Les maîtriser en
Python est un atout majeur pour
manipuler de gros volumes.

]]> 1.0 0.0 0 true true abc Les opérations classiques sont la recherche, le tri, la sélection de lignes (filtrage), la sélection de colonnes et la fusion

]]> Vrai : ce sont les opérations canoniques sur
les tables, prévues par le programme.

]]> Une fusion permet de combiner deux tables sur la base d'un descripteur commun

]]> Vrai : c'est exactement le rôle de la fusion,
qui rapproche les lignes de deux tables
partageant une clé.

]]> En Python, on représente couramment une table par une liste de dictionnaires

]]> Vrai : c'est la représentation la plus
fréquente en NSI Première.

]]> Le module csv produit toujours des données typées (entiers, flottants, dates)

]]> Faux (donc bonne réponse) : csv produit
uniquement des chaînes. C'est au
programme de convertir les types.

]]>