$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 meuble pour poser un ordinateur

]]> Plaisanterie : on parle bien d'une structure
informatique, pas de mobilier.

]]> Un type primitif de Python

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

]]> Un tableau composé de lignes (enregistrements) et de colonnes (descripteurs ou attributs)

]]> 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

]]> 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 simple chaîne de caractères

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

]]> Comme une liste de dictionnaires, chaque dictionnaire représentant une 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 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.

]]> table.age[1]

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

]]> 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
print(table.nom)
`

]]> Erreur : pas d'attribut .nom sur une liste.
Cela lève AttributeError.

]]> `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
print(table["nom"])
`

]]> Erreur : table est une liste, on ne peut
pas indexer par chaîne.

]]> 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, JSON), d'un tableur, d'une base de données, d'une API web...

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

]]> Aucune des réponses précédentes

]]> Erreur : la deuxième proposition est
correcte.

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

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

]]> Uniquement d'une base de données 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

]]> Possible mais fastidieux et fragile. Il existe
un outil dédié.

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

]]> Non, cette fonction n'existe pas dans le
module csv.

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

]]> Bonne réponse : csv.DictReader produit un
itérateur de dictionnaires ; list() le
matérialise en table prête à l'emploi.

]]> json.load(open('data.csv'))

]]> Erreur : json.load lit du JSON, pas du CSV.

]]> 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 Comment trier la table par âge croissant ?

]]> Pour trier sans modifier la table d'origine :
sorted(table, key=lambda r: r['age']). Pour un
tri décroissant, ajouter reverse=True.

]]> 1.0 0.0 0 true true abc table.sort(key=lambda ligne: ligne['age'])

]]> Bonne réponse : key indique sur quoi
comparer. La lambda renvoie l'âge de chaque
ligne. Tri en place de la liste.

]]> table.sort()

]]> Erreur : sort ne sait pas comparer deux
dictionnaires sans préciser sur quel
descripteur.

]]> sorted(table, by='age')

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

]]> table.sort('age')

]]> Erreur : sort n'accepte pas une chaîne
comme premier argument positionnel. Il faut
le mot-clé key=.

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

]]> Cette opération consiste à extraire un
sous-ensemble de colonnes d'une table. C'est
l'une des manipulations classiques de tables,
au même titre que la sélection de lignes, le
tri ou la fusion.

]]> 1.0 0.0 0 true true abc table[['nom', 'age']]

]]> Erreur : c'est une syntaxe pandas, pas
Python standard.

]]> table.select('nom', 'age')

]]> Erreur : la méthode .select n'existe pas
sur les listes (cela ressemble à du SQL).

]]> [{k: l[k] for k in ['nom', 'age']} for l in table]

]]> Bonne réponse : compréhension de liste
imbriquée avec une compréhension de
dictionnaire. Pour chaque ligne, on
reconstruit un dictionnaire ne gardant que les
clés voulues.

]]> table.keep('nom', 'age')

]]> Erreur : pas de méthode .keep en Python
standard.

]]> 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.extend(t2) ou
t1 += t2.

]]> 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. Il faudrait
plutôt extend.

]]> 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 mean(table.age)

]]> Erreur : pas de fonction mean en standard,
et pas d'attribut .age sur une liste.

]]> table.average('age')

]]> Erreur : pas de méthode .average.

]]> 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 eleves = [{"id":1,"nom":"Alice"},...] et
notes = [{"id_eleve":1,"matiere":"Maths","note":15},...].
Pour associer chaque note au nom de l'élève, on
effectue une jointure. Quel pseudo-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
notes + eleves
`

]]> Erreur : la concaténation ne fait aucune
mise en correspondance.

]]> `python
eleves.merge(notes)
`

]]> Erreur : pas de méthode .merge en Python
standard.

]]> `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. Complexité O(n × m).

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

]]> Erreur : eleves[1] accède à l'indice 1
de la liste, pas à l'élève d'id 1.
Coïncidence possible mais code incorrect en
général.

]]> 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 Comment compter le nombre d'élèves dans chaque
ville à partir de table = [{"nom":..., "ville":...}, ...] ?

]]> Alternative plus concise avec
collections.Counter :
Counter(ligne["ville"] for ligne in table).
Mais le schéma manuel est universel.

]]> 1.0 0.0 0 true true abc set(table['ville'])

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

]]> `python
c = {}
for ligne in table:
v = ligne["ville"]
c[v] = c.get(v, 0) + 1
`

]]> Bonne réponse : on construit progressivement
un dictionnaire ville → effectif. La
méthode .get(v, 0) renvoie 0 si la ville
n'a pas encore été rencontrée.

]]> len(table)

]]> Erreur : cela donne le total, pas la
répartition par ville.

]]> table.count('ville')

]]> Erreur : count cherche un élément exact
dans la liste, pas un comptage par
catégorie.

]]> Tables de données — Q18 : Tri sur deux critères Comment trier la table par âge croissant, puis
par nom alphabétique en cas d'égalité ?

]]> Astuce élégante : la comparaison des tuples
Python est lexicographique, ce qui simplifie
beaucoup les tris multi-critères.

]]> 1.0 0.0 0 true true abc table.sort(key=lambda l: (l['age'], l['nom']))

]]> Bonne réponse : la clé est un tuple.
Python compare lexicographiquement les
tuples : d'abord par âge, puis par nom en
cas d'égalité.

]]> table.sort('age', 'nom')

]]> Erreur : sort n'accepte pas plusieurs
arguments positionnels.

]]> table.sort(key=lambda l: l['age'] + l['nom'])

]]> Erreur : on ne peut pas additionner un entier
et une chaîne. Et ce ne serait pas
sémantiquement correct.

]]> table.sort(by=['age', 'nom'])

]]> Erreur : c'est la syntaxe pandas, pas Python
standard.

]]> 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' avec leurs coordonnées et capacités, 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 transports

]]> 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

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

]]> Un arbre généalogique sur plusieurs générations 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 une liste de dictionnaires
[{"x":1,"y":2}, {"x":3,"y":4}] en dictionnaire
de listes {"x":[1,3], "y":[2,4]} (représentation
"colonne par colonne"). Quel code est correct ?

]]> Cette transformation est très utile pour passer
à numpy/matplotlib, qui préfèrent souvent les
colonnes individuelles aux listes
d'enregistrements.

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

]]> Bonne réponse : compréhension de
dictionnaire. Pour chaque clé du premier
dictionnaire, on construit la liste des
valeurs de cette clé sur toutes les lignes.

]]> table.pivot()

]]> Erreur : pas de méthode .pivot en Python
standard (cela existe en pandas).

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

]]> Erreur : on écrase les valeurs à chaque
itération (chaque clé n'aura que la dernière
valeur).

]]> dict(table)

]]> Erreur : dict ne sait pas faire cette
transformation. Lèverait TypeError ou
produirait un résultat inattendu.

]]> 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 supprimant la moitié des colonnes

]]> Erreur : la complexité dépend du nombre de
lignes, pas du nombre de colonnes.

]]> En triant les deux tables au préalable

]]> Possible (jointure par fusion) mais coûteux
en pré-traitement. Il existe plus simple
en Python.

]]> En indexant une table par sa clé dans un dictionnaire (accès O(1)), ce qui ramène la jointure à O(n + m)

]]> Bonne réponse : par exemple,
idx = {e["id"]: e for e in eleves}, puis
for n in notes: e = idx.get(n["id_eleve"]).
Beaucoup plus rapide pour de gros volumes.

]]> En utilisant des tuples au lieu de dictionnaires

]]> Pas une vraie optimisation algorithmique.

]]> Tables de données — Q24 : Bug subtil Un élève écrit
`python
for ligne in table:
if ligne["age"] > 16:
table.remove(ligne)
`
Quel est le problème ?

]]> Bonne pratique : ne jamais modifier une
structure pendant qu'on la parcourt. Construire
une nouvelle liste filtrée :
table = [l for l in table if l["age"] <= 16].

]]> 1.0 0.0 0 true true abc La boucle ne compile pas

]]> Erreur : la syntaxe est valide, le code
s'exécute (mais avec un bug logique).

]]> Cela lève toujours une exception

]]> Pas toujours : ça produit un résultat
incorrect, sans erreur visible.

]]> Modifier une liste pendant qu'on la parcourt provoque des lignes ignorées : certains éléments ne seront jamais testés

]]> Bonne réponse : c'est un piège classique.
Quand on supprime l'élément d'indice i,
les indices suivants se décalent et le
parcours saute le suivant. Solution :
construire une nouvelle liste filtrée.

]]> La méthode .remove n'existe pas

]]> Erreur : elle existe parfaitement.

]]> 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.

]]>