LDP Complet

1
C O L L E C T I O N
re
Numérique et
sciences informatiques
PROGRAMME
2019
Sous la direction de Claire Savinas
Stéphane Bonnaud
Professeur agrégé de Physique-Chimie au lycée François Arago de Perpignan
Professeur de SNT et de NSI
Professeur d’informatique en classes préparatoires
Formateur Python et Arduino
Claire Savinas
Professeure de Mathématiques au lycée Jean Vilar de Villeneuve-lez-Avignon
Professeure de SNT et de NSI
Ingénieure en informatique et réseaux
Formatrice en Mathématiques, SNT et Python
L IV RE DU P ROF ESSEUR
04733833_001_003.indd 1 11/08/2021 15:35

Liste des ressources numériques en complément du cahier
NB. Toutes les ressources professeur et élève sont disponibles gratuitement. Elles sont accessibles sur le site nsi.editions-bordas.fr et
sur le cahier numérique vidéoprojetable.
Le site élève lycee.editions-bordas.fr/cahier-NSI1re ne contient que les ressources élèves. Il est conforme au RGPD. L’accès aux
ressources s’effectue sans installation et sans identification.
Les ressources en turquoise Séquence 4 — Données en tables Activité 4 Réalisation d’une IHM
sont réservées au professeur :
• Livre du professeur préremplie
• Des QCM diagnostic pour introduire • QCM diagnostic Mini-projet 1 Jeu de casse-brique
chaque séquence.
Histoire des sciences Interface pour prérempli
• Le livre du professeur passer du format CSV à un tableau Mini-projet 2 Base de code pour un
téléchargeable gratuitement.
Activités 2, 4 et 6, exercices 1, 3, 4 et 5 jeu de tic-tac-toe
• Toutes les corrections directement Interface pour passer d’un fichier CSV
vidéoprojetables dans les interfaces. • QCM d’auto-évaluation
à des points sur une carte
• Des propositions de progressions • Corrections Python de l’activité 4 et
annuelles. • Programmes Python et fichiers CSV des mini-projets
• Une vidéo de présentation nécessaires pour toutes les activités
et tous les exercices Séquence 8 — Langages et programmation
des interfaces.
• Pour une remédiation, le chapitre • QCM d’auto-évaluation • Livre du professeur
du cahier SNT 2de, consacré • Corrections Python des activités 2 et 3, • QCM diagnostic
au langage Python. des exercices et des mini-projets • Programmes Python pour
Séquence 5 — Interactions entre l’homme les activités 3, 4 et l’exercice 6
Ressources transversales
et la machine sur le Web • QCM d’auto-évaluation
Un éditeur Python en ligne, avec tous • Livre du professeur • Corrections Python des mini-projets
les modules nécessaires
• QCM diagnostic Séquence 9 — Les bases de l’algorithmique
• Propositions de progression annuelles Activités 2 et 7 Simulations de formu-
• Livre du professeur
• Chapitre du cahier de SNT 2de laires de connexion
consacré à Python Activités 3 et 4 et exercices Interface
• QCM diagnostic
de programmation web Activités 2 et 6, exercice 1 Interface
Séquence 1 — Représentation pour comparer graphiquement des
Mini-projet 1 Simulation de minage
des nombres courbes de complexité
de Bitcoins à modifier
• Livre du professeur Activité 5 Interface de simulation d’un
Mini-projet 2 Jeu d’escape game à
tri par sélection
• QCM diagnostic compléter
Activités 5 et 6 Interface de modéli
Activité 2 « Couleurs en HTML » :
interface de simulation de codage de
• Fichiers HTML et PHP à télécharger sation de courbes de complexité
pour les activités 3, 4 et 5, les exercices Activité 6 Interface de simulation d’un
couleurs et les mini-projets tri par insertion
• QCM d’auto-évaluation • QCM d’auto-évaluation
• Programmes Python pour l’activité 6
• Corrections Python de l’activité 5 et • Corrections de l’activité 4, des et les exercices 6, 9 et 14
des mini-projets exercices 1, 2, 3, 8, 9 et des mini-projets
• Fichiers CSV pour les exercices 6 et 14
Séquence 6 — Architecture et systèmes
Séquence 2 — Encodage des caractères • QCM d’auto-évaluation
et expressions booléennes d’exploitation
• Corrections Python des activités 1, 5, 6,
• Livre du professeur • Livre du professeur des exercices et des mini-projets
• QCM diagnostic • QCM diagnostic
Séquence 10 — Algorithmique avancée
Activité 3 Interface de simulation d’un Activités 3, 4, 5, 6 Émulateur Linux
additionneur binaire 1 bit Activité 7 Émulateur d’un processeur • Livre du professeur
pour programmer en langage assem- • QCM diagnostic
• Programme Python pour l’activité 1 bleur Histoire des sciences Simulation d’une
• QCM d’auto-évaluation machine de Turing
• QCM d’auto-évaluation
• Corrections Python des mini-projets Activité 4 Interface de modélisation
• Corrections des mini-projets de courbes de complexité
Séquence 3 — Les types construits Séquence 7 — Réseaux et IHM
• Programmes Python pour l’activité
• Livre du professeur • Livre du professeur « Histoire des sciences » et l’exercice 5
• QCM diagnostic • QCM diagnostic • Fichier CSV pour l’exercice 5
• QCM d’auto-évaluation Histoire des sciences Interface pour • QCM d’auto-évaluation
• Corrections Python des activités 1 passer d’un fichier CSV à des points
• Corrections Python de l’activité 4,
et 3, de l’exercice 13 et des mini-projets sur une carte des exercices et des mini-projets
04733894_002.indd 2 11/08/2021 16:14

Sommaire
Sommaire
Les ressources numériques du cahier ............................................................................................................................................... 2
Thème A Représentation des données : types et valeurs de base
Séquence 1 Représentation des nombres ................................................................................................................................. 5
Séquence 2 Encodage des caractères et expressions booléennes .............................................................. 30
Thème B Représentation des données : types construits
Séquence 3 Les types construits ................................................................................................................................................. 46
Thème C Traitement de données en tables
Séquence 4 Données en table ........................................................................................................................................................... 69
Thème D Interactions entre l’homme et la machine sur le Web
Séquence 5 Interactions entre l’homme et la machine sur le Web ................................................................. 89
Thème E Architectures matérielles et systèmes d’exploitation
Séquence 6 Architecture et systèmes d’exploitation ................................................................................................. 1 15

Séquence 7 Réseaux et IHM ............................................................................................................................................................... 1 37
Thème F Langages et programmation
Séquence 8 Langages et programmation .............................................................................................................................. 1 56
Thème G Algorithmique
Séquence 9 Les bases de l’algorithmique ............................................................................................................................. 172

Séquence 10 Algorithmique avancée ............................................................................................................................................ 200
04733833_001_003.indd 3 11/08/2021 16:13

4
04733901_p004-224.pdf 1 11/08/2021 14:50

Thème A : Représentation des données :
types et valeurs de base
Séquence 1 Représentation des nombres
Le thème A (Représentation des données : types et valeurs de base) correspond aux deux séquences
suivantes :
 Séquence 1 : Représentation des nombres
 Séquence 2 : Encodage des caractères et expressions booléennes
La séquence 1 ne nécessite pas d’avoir traité au préalable une autre séquence du cahier.
Site ressources avec toutes les ressources pour les élèves : lycee.editions-bordas.fr/cahier-NSI1re.
Site ressources pour l’enseignant : nsi.editions-bordas.fr.
A. Le programme
Les capacités exigibles du BO pour cette séquence sont données ci-dessous. Les autres contenus du
thème Représentation des données : types et valeurs de base seront traités dans la séquence 2.
Contenus Capacités attendues du BO Activités /

traitées dans la séquence 1 Exercices
Écriture d’un Passer de la représentation d’une base dans une autre. Activités 1 et 2
entier positif dans p. 10 et 11
une base b ⩾ 2
Exercices 1, 2, 3, 4,
5, 6 p. 19-20
Représentation Évaluer le nombre de bits nécessaires à l’écriture en Activités 3 et 4

binaire d’un entier base 2 d’un entier, de la somme ou du produit de deux p. 12 et 13
relatif nombres entiers.
Utiliser le complément à 2. Exercices 7, 8, 9,
10, 11, 12, 13
p. 21-22
Représentation Calculer sur quelques exemples la représentation de Activité 5

approximative des nombres réels : 0.1, 0.25 ou 1/3. p. 14-15
nombres réels :
notion de nombre Exercices 14, 15, 16
flottant p. 23
5 Thème A  Séquence 1 Représentation des nombres
04733901_p004-224.pdf 2 11/08/2021 14:50

B. QCM diagnostic d’ouverture
Ces questions vont instaurer le débat, ou la discussion.
Elles sont destinées à faire une évaluation diagnostic en début de séquence et sont disponibles sur
QCMCam et aux formats PDF, PPT et ODP sur le site ressources : cahier-nsi.fr/#!/diagnostic/seq1 et
sur le manuel numérique enseignant.
Activité Le résultat du calcul 2 × 103 + 3 × 102 + 1 × 101 + 7 est :

1
Réponses :
A. 137.
B. 197.
C. 2 317. (Bonne réponse.)
Activité Le reste de la division euclidienne (appelée également division entière) de 7 par 2 est :
1
Réponses :
A. 0.
B. 1. (Bonne réponse : 7 = 2 × 3 + 1.)
C. 3.
Activité Le résultat du calcul 23 + 22 + 21 + 20 est :

2
Réponses :
A. 12.
B. 13.
C. 15. (Bonne réponse : 23 + 22 + 21 + 20 = 8 + 4 + 2 + 1.)
Activité Le reste de la division euclidienne (appelée également division entière) de 20 par 16 est :
2
Réponses :
A. 0.
B. 1.
C. 4. (Bonne réponse : 20 = 16 × 1 + 4.)
Activité Sur un affichage à deux chiffres, combien de valeurs peut-on afficher ?

3
Réponses :
A. 9.
B. 99.
C. 100. (Bonne réponse : on peut afficher toutes les valeurs de 0 à 99.)
Activité Le résultat du calcul − 7 + 5 est :

4
Réponses :
A. – 12.
B. – 2. (Bonne réponse.)
C. 12.
1
Activité La valeur :
3
5
Réponses :
A. est égale à 0,33.
B. est égale à 0,3333333333.
C. a une infinité de décimales. (Bonne réponse.)
04733901_p004-224.pdf 3 11/08/2021 14:50

C. Description des activités
Histoire des Sciences p. 9 / Du comptage au calcul mécanique
(voir la correction à la fin de la partie C)
Capacité attendue :
 Événements clés de l’histoire de l’informatique.
Cette activité présente succinctement l’évolution des systèmes de numération, de l’Antiquité à la

représentation des entiers en machine.
Elle est l’occasion de revoir le système de comptage additif qu’utilisaient les Romains et de se
remémorer que l’idée de position d’un chiffre dans un nombre, que nous utilisons tous les jours, date
de moins de quatre mille ans. La représentation d’un nombre en chiffres romains a été traitée en
collège dans le programme de mathématiques. L’élève peut également se rendre compte que les
Égyptiens utilisaient un système décimal sans zéro et que le zéro est arrivé beaucoup plus tard.
Une des capacités attendues de cette séquence est le changement de base mais les élèves ne voient pas
forcément l’intérêt dans un premier temps. La première question aide l’élève à se questionner sur
l’utilisation de bases autres que la base 10 dans la vie de tous les jours, comme pour l’âge des jeunes
enfants que l’on donne en mois. La base 60 est utilisée pour le système des secondes et des minutes.
La base 12 est utilisée pour compter en demi-journées qui correspondent à 12 heures. Il est également
possible de demander aux élèves un exemple d’utilisation de la base 24, pour les heures d’une journée.
Même si un certain nombre d’élèves savent que toute machine informatique manipule des bits, ils ne
savent pas forcément que c’est pour stocker des données. C’est d’autant plus intéressant de voir que la
représentation binaire n’a pas attendu l’apparition de l’informatique pour exister puisqu’elle remonte à
plus de trois cents ans. En 1690, pour concevoir la première machine à calculer des multiplications,
Leibniz représente en effet les nombres en base binaire, bien avant l’avènement de l’informatique.
Activité 1 p. 10 / Base décimale et base binaire (voir la correction à la fin de la partie C)

Capacités attendues :
 Passer de la représentation d’une base dans une autre. Les bases 2 et 10 sont privilégiées.
Cette activité propose de découvrir et de manipuler uniquement la base binaire et la base décimale. La
base hexadécimale sera introduite à l’activité 2.
La contextualisation a paru intéressante aux auteurs afin que les élèves puissent ancrer la base binaire
et la base décimale par les images du manchot de Linux et du démon de FreeBSD. L’enseignant
pourra ainsi se référer à cette activité avec les images mentales du manchot à 2 ailes et du démon
à 10 doigts. Elle permet également de commencer à parler des systèmes d’exploitation GNU/Linux.
Cette contextualisation a paru indispensable aux auteurs afin de parler tout de même d’informatique
aux élèves qui trouvent ce thème très mathématique.
La base décimale, bien qu’utilisée quotidiennement par les élèves est rappelée avec la décomposition
de 25610 en base 10. Le tableau avec le rang permet de fournir le vocabulaire sur la base qu’ils
connaissent. La notation sous forme d’indice sera utilisée dans tout le cahier. Le choix d’écrire
04733901_p004-224.pdf 4 11/08/2021 14:50

« valeur en base décimale » plutôt que « valeur décimale » permet d’éviter la confusion avec le
vocabulaire mathématique.
Bien que pas explicitement au programme, il a paru important aux auteurs d’expliquer pourquoi les
ordinateurs stockent les informations en base binaire et que l’utilisation des caractères 1 et 0 est
uniquement une convention. La question 2 permet de manipuler la base binaire introduite avec un
exemple simple. La contextualisation de la question devrait permettre aux élèves de comprendre qu’en
informatique, il est important de préciser la base dans laquelle une valeur est écrite.
Avant la question 4, il a paru nécessaire aux auteurs de redonner le vocabulaire de la division

euclidienne sur un exemple car celle-ci n’est pas toujours acquise. Pour les divisions successives, ils
ont choisi de ne pas faire apparaître les étapes de calculs, mais uniquement le reste de la division
euclidienne, afin de ne pas surcharger l’écriture et la lecture du résultat. La division euclidienne de 13
par 2 donnée permet de retrouver la valeur en base binaire donnée par le manchot et de faire le lien
avec le début de l’activité.
L’erreur classique de cette activité est l’évaluation de 20 qui vaut 1. Il paraît nécessaire de faire des
exercices de la page 19 avant d’attaquer la base hexadécimale avec l’activité 2 de cette séquence.
Activité 2 p. 11 / Base hexadécimale

 Passer de la représentation d’une base dans une autre. Les bases 2, 10 et 16 sont privilégiées.
Cette activité propose de découvrir et de manipuler uniquement la base hexadécimale. L’activité 2

nécessite d’avoir traité l’activité 1 au préalable avec les rappels de la base décimale, sur la division
euclidienne et l’introduction de la base binaire. Dans un premier temps, l’activité propose de convertir
des valeurs de la base 16 à la base 10 et inversement. Dans un deuxième temps, elle propose de
découvrir les conversions entre la base 16 et la base 2.
La contextualisation de l’activité 2 a pour objectif de réévoquer le langage de description web : le

HTML, et de parler d’un cas utile de conversion entre la base décimale et la base hexadécimale. La
première question permet à l’élève d’accéder à une petite interface web pour se rendre compte de
l’équivalence entre les deux syntaxes de couleurs en HTML. L’interface ne permet pas de répondre
aux questions de l’activité, mais d’avoir une vue ludique des deux syntaxes.
Le texte d’au-dessous permet d’introduire la base hexadécimale sur un exemple concret et de

réinvestir les trois composantes RVB vues en SNT. L’utilisation des lettres pour coder les valeurs de
10 à 15 est justifiée par le manque de chiffres dans la numération usuelle.
Les divisions successives par 16 sont introduites par l’exemple par analogie avec les divisions
successives par 2. Les divisions par 16 sont plus délicates que par 2 pour des élèves et l’utilisation de
la calculatrice peut être utile pour les aider dans un premier temps. Volontairement, nous avons fait le
choix de ne pas montrer avant le cours les fonctions Python natives bin() et hex() et les préfixes 0x et
0b puisque les élèvent n’auront pas accès ni à une calculatrice ni à une console Python pour traiter les
sujet des épreuves communes dans le cas d’un abandon de la spécialité à la fin de la classe de Première
ou à la partie sur feuille des épreuves de Terminale.
04733901_p004-224.pdf 5 11/08/2021 14:50

Les auteurs ont fait le choix de montrer en activité les conversions entre la base 16 et la base 2 qui sont
souvent plus pratiques que de passer par l’intermédiaire de la base décimale. Le schéma des
conversions de la page 16 du cours permet de faire la synthèse de ces conversions et il paraît
intéressant de le montrer en synthèse de cette activité.
Les exercices de la page 20 permettront aux élèves de manipuler ces changements de base qui ne sont
pas si simples à maîtriser. C’est un passage très mathématique du programme qui est souvent évalué
dans les sujets des épreuves communes pour les élèves qui feront le choix d’abandonner la spécialité à
la fin de la classe de Première.
Pour la conversion de la base 2 à la base 16, la principale difficulté pour les élèves est de penser à
commencer par les bits à droite pour faire les paquets de 4 bits.
Activité 3 p. 12 / Integer Overflow

 Évaluer le nombre de bits nécessaires à l’écriture en base 2 d’un entier et de la somme deux nombres
entiers.
Cette activité a pour objectif d’introduire dans un premier temps l’évaluation du nombre de bits
nécessaires à l’écriture en base binaire d’un entier positif puis, dans un deuxième temps, la somme de
deux nombre entiers positifs. La contextualisation est destinée à montrer aux élèves que ces deux
notions peuvent avoir un impact sur l’affichage de valeurs entières dans la vie de tous les jours,
comme un compteur de personnes à l’entrée d’un manège, un compteur du nombre de pièces d’or dans
les vieux jeux vidéo…
L’idée de l’activité est d’étudier un affichage incohérent et d’essayer d’expliquer ce qui s’est passé.
La représentation sur 8 bits est facilitée par le tableau à 8 cases de la question 2.
Les auteurs ont choisi de faire découvrir une méthode pour déterminer le nombre de bits nécessaires
pour représenter un nombre entier en binaire qui n’utilise pas le logarithme, afin d’éviter de dépendre
de notions de mathématiques non vues en classe de Seconde. Ce choix permet également de traiter les
questions des épreuves communes pour lesquelles la calculatrice est interdite. C’est l’occasion de
montrer aux élèves la nécessité de connaître les puissances de 2 au moins jusqu’à 216 .
En remplissant le tableau de la question 5, l’enseignant pourra justifier les choix de valeurs avec les
tailles courantes des entiers (8, 16, 32 et 64 bits). Les auteurs ont choisi de faire compléter une ligne
du tableau avec le plus grand entier positif que l’on peut stocker, afin que les élèves pensent au zéro
qu’il faut également coder et qui prend une valeur quelle que soit la taille de l’entier.
Les auteurs ont également choisi de faire découvrir uniquement le nombre de bits nécessaires pour
effectuer la somme de deux entiers positifs. Le produit sera vu avec la démonstration dans le cours et
retravaillé en exercices.
04733901_p004-224.pdf 6 11/08/2021 14:50

Activité 4 p. 13 / Découverte du complément à 2 puissance n
 Utiliser le complément à 2.
L’activité a pour objectif de faire découvrir le complément à 2. Dans un premier temps, la somme de
deux entiers positifs en base binaire est vue afin de pouvoir utiliser la méthode du complément à 2. La
règle est donnée et un exemple est rédigé afin que l’élève puisse faire les deux additions binaires
suivantes par analogie avec la règle de la somme binaire. Afin d’aider les élèves, nous leur proposons
la valeur en base décimale à côté, ce qui sera d’autant plus important pour la dernière partie de
l’activité.
La deuxième partie de l’activité permet d’introduire la représentation d’un nombre relatif. Les auteurs
se sont permis d’insister sur le vocabulaire de nombre relatif puisque les élèves n’ont pas toujours
acquis ce vocabulaire mathématique en classe de Première. Pour montrer que la somme binaire donne
toujours un résultat correct, la question 2 permet de refaire les additions binaires de la question 1 avec
l’interprétation du code donné au-dessus, pour les nombres signés.
Dans le cours, les auteurs ont fait le choix de mettre en évidence le fait qu’un complément à 2 d’un
nombre en complément à 2 revient au nombre d’origine, plutôt que de montrer la méthode qui consiste
à remonter la méthode du complément à 2 qui est plus laborieuse et source d’erreur pour les élèves.
La méthode du complément à 2 est donnée avec un exemple. Après la question 3, qui est une simple
mise en application, la question 4 produit un dépassement d’entier (integer overflow), ce qui permet de
donner un autre cas de ce phénomène et la façon de le traiter dans le cas du complément à 2.
Pour aider les élèves dans les questions 5 et 6, il paraît pertinent de leur demander de continuer à écrire
les valeurs à sommer en base décimale comme sur les autres sommes.
Activité 5 p. 14 / Représentation approximative d’un nombre flottant

 Calculer sur quelques exemples la représentation de nombres réels : 0.1, 0.25 ou 1/3.
Les corrections Python de cette activité sont disponibles sur le site ressources et le manuel numérique
enseignant.
Cette activité a pour objectif d’introduire la représentation des nombres flottant avec une situation
déclenchante. La question 2 demande aux élèves de comparer la somme 0,1 + 0,2 et 0,3 dans une
console Python. Pour les aider à comprendre ce qui ne leur paraît pas logique, la question 3 permet de
montrer que la représentation machine de 0,1 + 0,2 n’est pas exactement 0,3. Il est important de
préciser que le problème de la représentation en machine d’un nombre flottant n’est pas propre à
Python mais au stockage de la valeur sous forme binaire de manière générale.
04733901_p004-224.pdf 7 11/08/2021 14:50

C’est également l’occasion d’insister sur le fait qu’un nombre non entier, même si on peut l’appeler à
« virgule flottante » n’est pas écrit en informatique avec une virgule mais avec un point. Le choix de
ce séparateur décimal, symbole utilisé pour partager la partie entière et la partie décimale d’un nombre
décimal, est celui du système anglo-saxon. En Python, la virgule sera réservée pour séparer des
éléments dans les types construits introduits à la séquence 3.
Les auteurs ont fait le choix de montrer la décomposition d’un nombre flottant en base binaire, qui
parlera davantage aux élèves qui continuent les mathématiques.
La méthode pour convertir un nombre flottant de la base décimale à la base binaire est relativement
simple. Pour la partie entière, elle a déjà été vue à l’activité 1. Pour la partie décimale, la méthode est
relativement facile à comprendre. Ce qui l’est moins est l’aspect circulaire, qui est mis en lumière par
les valeurs encadrées dans le deuxième tableau de la question 6.
1
Le fait que 3 ne soit pas représentable de façon exacte est relativement compréhensible par un élève.
En revanche, que la valeur 0,1 ne puisse pas être représentée de façon exacte dans la mémoire d’un
ordinateur est moins trivial. Le tableau de la question 7 est volontairement plus long que nécessaire
pour déterminer le cycle infini afin que les élèves puissent mieux se rendre compte.
Une fois que l’on a pu expliquer pourquoi le test 0.1 + 0.2 == 0.3 renvoie False et que les élèves ont
compris qu’il ne fallait pas tester une égalité sur les nombres flottants sans prendre de précautions,
deux autres objectifs ont paru nécessaires aux auteurs. Le premier est la possibilité de contourner le
problème du test d’égalité sur les flottants avec la fonction isclose() du module numpy, ainsi que
certaines versions du module math. Sinon, il est également possible d’utiliser la fonction abs(), dont
l’utilisation est un peu plus mathématiques.
Le défaut d’affichage des nombres flottants peut être pallié avec la fonction native Python round(). Il
est important d’insister sur le fait qu’il ne s’agit pas d’une bonne pratique, sauf pour des données en
lien avec un aspect financier que l’on peut arrondir à deux décimales par exemple.
04733901_p004-224.pdf 8 11/08/2021 14:50

04733901_p004-224.pdf 9 11/08/2021 14:50

04733901_p004-224.pdf 10 11/08/2021 14:50

04733901_p004-224.pdf 11 11/08/2021 14:50

04733901_p004-224.pdf 12 11/08/2021 14:50

04733901_p004-224.pdf 13 11/08/2021 14:50

04733901_p004-224.pdf 14 11/08/2021 14:50

04733901_p004-224.pdf 15 11/08/2021 14:50

D. Description des exercices
Exercice 1 page 19 (voir la correction à la fin de la partie D)
Cet exercice a pour objectif de faire manipuler la conversion de la base binaire à la base décimale.
Dans un premier temps, la question 1 permet de guider la décomposition en base binaire avant de faire
le calcul de la valeur en base décimale à la question 2. Il paraît intéressant de bien faire écrire les
indices afin d’en faire prendre l’habitude aux élèves avant d’ajouter la base hexadécimale.

Cet exercice permet de faire faire 3 divisions successives pour convertir trois valeurs de la base
décimale à la base binaire. La question 2 permet de vérifier les résultats obtenus à la question 1. Faire
faire la conversion inverse pour vérifier ses résultats est un bon moyen d’éviter les erreurs en
évaluation.

Cet exercice a pour objectif de faire faire des conversions entre les bases décimale et binaire sans trop
guider les élèves. Les calculs de vérifications peuvent être faits sur une feuille de brouillon ou avec la
fonction Python native bin() et le préfixe 0b.

Cet exercice permet à l’élève de passer de la base hexadécimale à la base binaire et inversement sans
passer par l’intermédiaire de la base décimale.

Cet exercice permet à l’élève de travailler le passage de la base hexadécimale à la base binaire et
inversement.
Pages de p19-20.pdf 1 12/08/2021 12:27

Cet exercice propose de manipuler les conversions des bases binaire, décimale et hexadécimale sans
guider l’élève. L’élève a le choix des conversions à faire et la consigne lui rappelle que certaines
conversions sont plus faciles que d’autres à faire, comme les conversions de la base binaire vers la
base hexadécimale et inversement.
La question 2 lui propose de vérifier ses résultats avec les fonctions Python natives bin() et hex() et
les préfixes 0x et 0b donnés dans le cours.

 Évaluer le nombre de bits nécessaires à l’écriture en base 2 d’un entier.
Cet exercice propose de s’interroger sur le champ TTL des paquets IP dont la valeur est initialisée
à 255. Il est aussi l’occasion de montrer aux élèves que cette séquence leur permet de comprendre d’où
viennent des valeurs qui peuvent leur paraître arbitraires.
C’est l’occasion d’ancrer la nécessité de de ne pas oublier la valeur zéro qui doit également être codée.
Encore un cas où la connaissance des puissances de 2 est importante.

Cet exercice propose à l’élève de s’interroger sur le nombre de lignes d’un fichier d’un tableur très
connu. Encore une occasion de rappeler aux élèves que la connaissance des puissances de 2 est
importante.

Cet exercice propose de déterminer le nombre de bits nécessaires pour écrire une adresse Ipv6 en base
binaire. Même si ce n’est pas une question que les élèves se sont encore posée, c’est une question
intéressante.
Pages de p19-20.pdf 2 12/08/2021 12:27

 Évaluer le nombre de bits nécessaires à l’écriture en base 2 de la somme ou du produit de deux nombres
entiers.
 Effectuer la somme binaire de deux entiers positifs.
Cet exercice permet d’utiliser les formules du cours pour déterminer le nombre de bits nécessaires à
l’écriture en base 2 de la somme et du produit de deux nombres entiers. La question 3 propose
d’effectuer une somme binaire sur un octet.

 Représentation d’un nombre positif en base binaire.
Cet exercice permet de traiter un type de question présent dans les sujets des épreuves communes.
Même si les élèves n’en verront pas forcément l’intérêt, l’enseignant peut leur expliquer que dans les
processeurs, il y a souvent une unité qui permet de faire des décalages de bits pour les multiplications
et les divisions par des puissances de 2.

Cet exercice permet de faire le complément à 2 de deux valeurs négatives et propose de vérifier le
résultat avec la méthode rapide explicitée dans le cours.

Cet exercice demande de faire la somme binaire sur 4 bits de deux entiers négatifs.
L’élève doit penser à faire le complément à 2 des deux valeurs avant de les sommer. La somme
produit un integer overflow qu’il faut penser à supprimer puisque le résultat est attendu sur 4 bits.
Pour convertir la valeur en complément à 2 trouvée, l’élève doit réitérer la méthode du complément
à 2.
04733901_p004-224.pdf 18 11/08/2021 14:50

Cet exercice demande de réinvestir la notion de valeur non exacte stockée dans un ordinateur. La
notation e-17 peut être compliquée à interpréter, mais le calcul est relativement simple. Les élèves
devraient donc facilement s’attendre à trouver zéro.

Cet exercice demande de convertir un nombre flottant en base binaire avec une contextualisation. Pour
la question 1, il ne faut pas oublier de traiter la partie entière. Pour la question 2, la contextualisation
permet uniquement de montrer à l’élève les conséquences de la représentation en machine d’un
nombre flottant.

 Évaluer le nombre de bits nécessaires à l’écriture en base 2 d’un entier relatif.
Cet exercice propose de réfléchir à un sujet que les élèves ont peut-être déjà croisé dans la presse.
C’est l’occasion de faire travailler l’élève sur la représentation d’un nombre signé.
04733901_p004-224.pdf 19 11/08/2021 14:50

04733901_p004-224.pdf 20 11/08/2021 14:50

04733901_p004-224.pdf 21 11/08/2021 14:50

04733901_p004-224.pdf 22 11/08/2021 14:50

04733901_p004-224.pdf 23 11/08/2021 14:50

04733901_p004-224.pdf 24 11/08/2021 14:50

E. Correction des QCM (Préparer l’évaluation commune de 1re)
NB. Des QCM d’auto-évaluation sont également disponibles pour un travail en autonomie de l’élève
à l’adresse : https://cahier-nsi.fr/#!/revision/seq1.
04733901_p004-224.pdf 25 11/08/2021 14:50

F. Les propositions de mini-projets
Les corrections Python de ces mini-projets sont disponibles sur le site ressources et sur le manuel
numérique enseignant.
Proposition 1
Ce mini-projet propose d’écrire des fonctions Python de conversion d’entiers positifs. Les types
construits ne sont pas nécessaires, le type chaîne de caractères est suffisant. La principale difficulté
pour les élèves est le parcours de la chaîne de caractères. Un élève qui n’a pas bien compris les
divisions successives aura des difficultés à commencer à écrire la fonction. La généralisation
demandée à la question 3 permet de traiter à la fois les questions 1 et 2 avec des appels avec les
arguments bien choisis
Ce mini-projet permet de retravailler les conversions au programme en changeant de registre.
Proposition 2
Ce mini-projet est plus difficile que le premier. La correction commentée proposée est de haut niveau
afin de prendre en compte toute la norme IEEE 754. Des versions plus simplistes d’élèves peuvent être
déjà de bonne qualité. L’aide propose d’utiliser la fonction déjà écrite à la question 2 pour éviter à
l’élève de faire un copié-collé du code et lui donner la bonne habitude de toujours découper son
programme en fonctions réutilisables, comme cela sera travaillé à la séquence 8.
G. Apprendre à argumenter – correction
04733901_p004-224.pdf 26 11/08/2021 14:50

Thème A : Représentation des données :
types et valeurs de base
Séquence 2 Encodage des caractères
et expressions booléennes
Le thème A (Représentation des données : types et valeurs de base) correspond aux deux séquences
suivantes :
 Séquence 1 : Représentation des nombres
 Séquence 2 : Encodage des caractères et expressions booléennes
La séquence 2 ne nécessite pas d’avoir traité au préalable d’autre séquence du cahier, sauf la
séquence 1 pour l’exercice 5 et l’activité d’histoire. Il est tout de même conseillé de faire la séquence 1
avant la séquence 2.
A. Le programme
thème Représentation des données : types et valeurs de base ont été traités dans la séquence 1.
Contenus Capacités attendues du BO Activités / Exercices

traitées dans la séquence 2
Valeurs booléennes : 0, 1. Dresser la table d’une expression Activités 1, 2 et 3

Opérateurs booléens : and, or, not. booléenne. p. 28 à 30
Expressions booléennes
Exercices 1, 2 et 3
p. 34
Représentation d’un texte en Identifier l’intérêt des différents Activité 4

machine. systèmes d’encodage. p. 31
Exemples des encodages ASCII, Convertir un fichier texte dans
ISO-8859-1, Unicode différents formats d’encodage. Exercices 4, 5, 6, 7
p. 35
30 Thème A  Séquence 2 Encodage des caractères et expressions booléennes
04733901_p004-224.pdf 27 11/08/2021 14:50

Activité Dans une instruction conditionnelle (avec le mot-clé Python if), quelles valeurs peuvent prendre
1 l’expression à évaluer ?
Réponses :
A. True ou False (Bonne réponse : la condition peut être soit vraie soit fausse.)
B. Toutes les valeurs réelles possibles.
C. Uniquement True.
Activité Dans une expression mathématique, en l’absence de puissances, les règles de priorité indiquent
2 que :
Réponses :
A. les calculs doivent être toujours être réalisés de gauche à droite.
B. aucune opération n’est prioritaire sur les autres hormis les parenthèses.
C. les parenthèses sont prioritaires et certaines opérations sont prioritaires sur d’autres. (Bonne
réponse : la multiplication est prioritaire sur l’addition.)
Activité Dans un ordinateur, les opérations sont effectuées :

3
Réponses :
A. en base décimale.
B. en base binaire. (Bonne réponse.)
C. en base hexadécimale.
Activité Quelle hypothèse peut-on faire pour un article d’actualité qui s’affiche avec des caractères
4 bizarres sur un smartphone ?
Réponses :
A. Le journaliste a fait une coquille.
B. Le navigateur du smartphone n’utilise pas le même type d’encodage que l’article d’origine.
(Bonne réponse.)
C. Le navigateur du smartphone doit être mis à jour.
04733901_p004-224.pdf 28 11/08/2021 14:50

Histoire des Sciences p. 27 / L’encodage des caractères alphanumériques
 Identifier l’intérêt des différents systèmes d’encodage.
Cette activité permet d’identifier l’intérêt des différents systèmes d’encodage au programme avec des
repères chronologiques. L’élève peut se rendre compte de l’évolution de l’encodage des caractères
alphanumériques depuis la naissance du code ASCII.
Même si les auteurs ont fait le choix de ne pas remonter aussi loin dans l’histoire, le codage des
communications est un problème ancien, avec beaucoup de solutions différentes comme les signaux de
fumée, le sémaphore (système communiquant des informations par signaux lumineux ou par la
position de drapeaux par exemple) ou le code morse. C’est un complément qui peut être intéressant à
envisager à l’oral.
Le codage et le décodage des caractères restent des opérations complexes. Par exemple, les appareils
Apple pouvaient se bloquer lors de l’affichage d’un simple caractère de l’alphabet indien télougou.
C’est l’occasion de rappeler aux élèves qu’il existe un grand nombre de caractères dans les différentes
langues utilisées dans le monde.
Les questions 4 et 5 leur permettent de manipuler et de se rendre compte que ce ne sont pas
uniquement des notions théoriques.
Activité 1 p. 28 / Opérateurs booléens : and et or (voir la correction à la fin de la partie C)

 Valeurs booléennes.
 Opérateurs booléens : and, or.
Cette activité propose d’introduire les opérateurs booléens en travaillant sur des conditions
d’instructions conditionnelles afin de contextualiser cette notion.
Les questions 2 et 3 auraient pu être traitées avec des assertions mais les auteurs ont considéré que la
séquence 2 serait traitée avant la séquence 8 du cahier. C’est tout de même l’occasion de commencer à
en parler avec les élèves. L’élève attentif pourra remarquer l’équivalence entre not (a and b) et
not a or not b qui sera traité à la question 4 de l’activité 2. Il peut également débattre sur le fait que
l’écriture x == 0 ou x != 0 peut être plus ou moins facile à lire et à déboguer.
L’évaluation de la première expression booléenne (question 5) est l’occasion de rappeler que, comme
en mathématiques, les parenthèses indiquent des priorités de calcul et que certains opérateurs sont
prioritaires sur d’autres comme indiqué dans le cours.
L’introduction des premières tables de vérité est l’occasion de mentionner que tous les couples
d’entrées a et b sont listés et évalués.
04733901_p004-224.pdf 29 11/08/2021 14:50

Activité 2 p. 29 / Tables de vérité des opérateurs not et xor
 Opérateurs booléens : and, or, not.
 Le ou exclusif (xor) est évoqué.
 Dresser la table d’une expression booléenne.
Cette activité propose de continuer à travailler sur les tables de vérité avec de nouveaux opérateurs.
À la question 2, même si les priorités sur les opérateurs n’ont pas encore été travaillées dans le cours,
il paraît logique de donner la priorité à l’opérateur not.
Avec la question 3, comme demandé dans le programme officiel, l’attention des élèves est attirée sur
le caractère séquentiel de certains opérateurs booléens.
L’élève attentif pourra remarquer que les expressions à étudier dans la question 4 sont identiques aux
conditions des instructions conditionnelles des deux fonctions Python de l’activité 1.
Activité 3 p. 30 / Additionneur binaire (voir la correction à la fin de la partie C)

 Valeurs booléennes : 0, 1.
Comme il est indiqué dans le programme officiel, quelques applications directes comme l’addition
binaire sont présentées ; les auteurs ont fait le choix de présenter l’additionneur 1 bit. Cet exemple
relativement simple mais incontournable permet d’introduire le fonctionnement interne d’un
processeur et de faire le lien avec la machine de von Neumann de la séquence 6.
Cet exemple permet de montrer le lien entre les opérateurs booléens et les portes logiques.
La question 1 est l’occasion de montrer le circuit logique de la porte xor et de retrouver l’expression
booléenne à l’aide du circuit logique proposé.
La question 2 permet d’accéder à une interface qui simule le fonctionnement de l’additionneur binaire
1 bit. L’élève peut modifier les valeurs des entrées a, b et 𝑟e par un simple clic sur la valeur et voir
l’état des entrées et des sorties des portes logiques (rond jaune pour la valeur 0 et rond rouge pour la
valeur 1). En testant toutes les combinaisons des entrées, il peut remplir la table de vérité de la
question 2.
La question 3 lui permet de déterminer l’expression de la sortie 𝑟s à l’aide des portes logiques de
l’interface. La question 4 permet de vérifier l’expression trouvée sur deux configurations d’entrée
puisqu’il a la valeur attendue dans la table de vérité. Les valeurs correspondantes sont encadrées dans
la correction.
04733901_p004-224.pdf 30 11/08/2021 14:50

Activité 4 p. 31 / Représentation d’un texte en machine
 Convertir un fichier texte dans différents formats d’encodage.
Cette activité permet de voir une application classique du problème d’encodage de caractères.
Ce problème est d’ailleurs souvent rencontré par l’élève dans la séquence 5 pour la programmation
web. Au lieu de modifier directement les octets du fichier à l’aide d’un éditeur hexadécimal, les
auteurs ont choisi de le faire faire à la main, avec la table des caractères ISO 8859-1, afin de bien
comprendre ce qui se passe. L’activité souligne également qu’en ISO 8859-1, un caractère est codé sur
un octet alors qu’en UTF-8, certains caractères sont codés sur deux octets. Le problème d’encodage
des caractères est avant tout un problème d’interprétation. En eux-mêmes, les octets n’ont « aucun
sens ». Le tableau de l'exemple en bas de la page 33 du cours est intéressant à montrer en conclusion
de cette activité pour fixer cette nouvelle notion.
Dans la correction de la question 5, la solution de remplacer le caractère é par é est une
solution très intéressante sur laquelle l’enseignant peut insister.
04733901_p004-224.pdf 31 11/08/2021 14:50

04733901_p004-224.pdf 32 11/08/2021 14:50

04733901_p004-224.pdf 33 11/08/2021 14:50

04733901_p004-224.pdf 34 11/08/2021 14:50

04733901_p004-224.pdf 35 11/08/2021 14:50

04733901_p004-224.pdf 36 11/08/2021 14:50

Cet exercice basique permet d’évaluer deux expressions booléennes. La principale difficulté est de
faire attention aux priorités entre les opérateurs and, or et not. Faire écrire les accolades sous les
parties de l’expression à évaluer, comme montré dans la correction, est un bon moyen d’éviter les
erreurs.

Cet exercice demande de remplir deux tables de vérités. Même si la loi de De Morgan n’est pas au
programme, les auteurs ont trouvé intéressant de la faire démontrer aux élèves puisque c’est une règle
basique de transformation d’équation booléenne. La difficulté principale est la présence de parenthèses
dans le membre de gauche de l’égalité booléenne.

Cet exercice propose de dresser la table de vérité d’une expression booléenne afin de déterminer
quelles peuvent être les valeurs des variables booléennes possibles en entrée. L’exercice est donc
construit à l’envers pour montrer un autre intérêt de l’utilisation des tables de vérité. Ce type de
question est évalué dans les épreuves communes.

 Événements clés de l’histoire de l’informatique
Cet exercice propose de visualiser comment des nombres étaient codés sur un ruban perforé. L’élève
peut remarquer l’extraordinaire augmentation de la densité de stockage sur une période très courte de
l’histoire.
04733901_p004-224.pdf 37 11/08/2021 14:50

Cet exercice permet de réinvestir la conversion de la base hexadécimale à la base binaire traitée dans
la séquence 1. La conversion proposée permet également de montrer que l’organisation du codage
ASCII n’est pas arbitraire et suit une certaine logique.

Cet exercice permet de faire choisir la norme d’encodage à privilégier sur des cas concrets, en fonction
des langues utilisées et de l’espace de stockage disponible.

Cet exercice propose de faire réfléchir l’élève sur des affichages farfelus que l’on peut également
croiser dans des articles d’actualité sur smartphone. Un élève attentif remarquera rapidement que le
caractère é de « retardé » est affiché avec deux caractères, ce qui lui permettra de répondre à la
question plus facilement.
04733901_p004-224.pdf 38 11/08/2021 14:50

04733901_p004-224.pdf 39 11/08/2021 14:50

04733901_p004-224.pdf 40 11/08/2021 14:50

04733901_p004-224.pdf 41 11/08/2021 14:50

Les corrections Python de ces mini-projets sont disponibles sur le site ressources et sur le manuel
Proposition 1
Ce mini-projet propose de revoir l’additionneur binaire en changeant de contexte. La fonction à écrire
pour la question 1 doit renvoyer un p-uplet afin d’être utilisable dans la fonction de la question 2.
Il est noté qu’il est préférable d’avoir traité la séquence 3 pour faire ce mini-projet afin que cette notion
soit correctement assimilée. Si la séquence 3 a été vue, il est également possible d’utiliser une liste
Python. Ce mini-projet a également pour objectif de faire programmer l’élève en réutilisant des fonctions
déjà écrites. Pour la question 3, l’élève peut écrire la fonction uniquement avec la fonction
additionneur_complet(), ce qui est un peu plus long que le décalage de bits vu à l’exercice 11 p. 22.
Proposition 2
Cette proposition a pour objectif de faire travailler les encodages de caractères en changeant de
contexte. Des fonctions Python natives permettent de faire le travail demandé mais ce n’est pas le but.
Ce mini-projet n’est pas facile puisqu’il demande de travailler sur les encodages sur des chaînes de
caractères. La correction commentée proposée est de haut niveau afin de prendre en compte toutes les
subtilités de l’encodage. Des versions plus simplistes d’élèves peuvent déjà être de bonne qualité.
04733901_p004-224.pdf 42 11/08/2021 14:50

Thème B : Représentation des données : types construits
Séquence 3 Les types construits
Le thème B (Représentation des données : types construits) correspond à la séquence suivante :

 Séquence 3 : Les types construits
La séquence 3 nécessite d’avoir revu les bases du langage Python (voir en pages 6 et 7 du cahier).
A. Le programme
Les capacités exigibles du BO pour cette séquence sont données ci-dessous.

p-uplets. Écrire une fonction renvoyant un p-uplet de valeurs. Activités 1 et 6

p-uplets nommés p. 40 et 45
Exercices 1, 2, 3
p. 49
Tableau indexé, Lire et modifier les éléments d’un tableau grâce à leurs Activités 2, 3, 6
tableau donné en index. p. 41-42 et 45
compréhension Construire un tableau par compréhension.
Utiliser des tableaux de tableaux pour représenter des Exercices 4, 5, 6, 7,
matrices : notation a[i][j]. 8, 9, 10 p. 50-51
Itérer sur les éléments d’un tableau.
Dictionnaires Construire une entrée de dictionnaire. Activités 4, 5, 6

par clés et Itérer sur les éléments d’un dictionnaire. p. 43 à 45
valeurs Utiliser les méthodes keys(), values() et items().
Exercices 11, 12,
13, 14 p. 52-53
46 Thème B  Séquence 3 Les types construits
04733901_p004-224.pdf 43 11/08/2021 14:50

QCMCam et aux formats PDF, PPT et ODP sur le site ressources : cahier-nsi.fr/#!/diagnostic/seq3
et sur le manuel numérique enseignant.
Activité Quel est le rôle du symbole = en Python ?

1
Réponses :
A. Il sert à tester une égalité mathématique.
B. Il sert à écrire une affectation. (Bonne réponse : le symbole = sert à affecter tout type de
variable en Python.)
C. Il sert à écrire une équation.
Activité En informatique, la virgule est utilisée :

1
Réponses :
A. Pour écrire un nombre décimal, comme 3,14.
B. Pour faciliter la lecture d’une instruction Python.
C. Pour séparer des éléments entre eux. (Bonne réponse : la virgule et utilisée entre autres pour
les p-uplets, les listes et les dictionnaires.)
Activité Pour programmer un jeu de plateau, quelle(s) information(s) essentielle(s) pourrait-on stocker
2 dans un tableau ?
Réponses :
A. L’heure du début de la partie.
B. Les positions de tous les pions du jeu. (Bonne réponse, les positions de tous les pions du jeu
nécessitent au moins deux valeurs par pion pour les repérer sur le plateau.)
C. Le nom des joueurs.
Activité Si le premier élément d’une liste Python a pour indice 0, quel est l’indice du 4 e élément ?
3
Réponses :
A. 3. (Bonne réponse : le premier élément a pour indice 0, le deuxième 1, le troisième 2 et le
quatrième 3.)
B. 4.
C. 5.
Activité En français, l’ouvrage de référence qui contient un ensemble de mots d’une langue avec leur
4 définition s’appelle :
Réponses :
A. Un tableau.
B. Un dictionnaire. (Bonne réponse : le type construit d’un langage de programmation fait
référence au terme du langage courant.)
C. Un annuaire.
Activité Une variable de type int peut contenir :

6
Réponses :
A. Plusieurs valeurs simultanément.
B. Une seule valeur à la fois. (Bonne réponse : c’est également le cas des types bool, str ou
encore float.)
C. Des valeurs intermédiaires.
04733901_p004-224.pdf 44 11/08/2021 14:50

Histoire des Sciences p. 39 / Le langage Python en bref (voir la correction à la fin de la partie C)
 Découvrir les types construits en Python.
 Découvrir quelques caractéristiques du langage Python.
Cette activité présente succinctement les caractéristiques du langage Python, imaginé et développé par
Guido Van Rossum en 1991.
Le langage Python offre la possibilité de programmer selon différents paradigmes et sur diverses
plateformes. Il est devenu l’un des langages les plus populaires, grâce notamment à sa facilité de prise
en main. Il est particulièrement utilisé en intelligence artificielle grâce à de nombreux modules en
évolution constante.
En fin d’activité, l’élève découvre la syntaxe particulière utilisée pour manipuler les types p-uplet, liste
et dictionnaire en Python.
Activité 1 p. 40 / Découverte du p-uplet en Python (voir la correction à la fin de la partie C)

 Écrire un p-uplet en Python.
 Écrire une fonction renvoyant un p-uplet de valeurs.
La correction Python de la question 8 est disponible sur le site ressources et le manuel numérique enseignant.
Cette activité propose de découvrir un nouveau type de variable, le p-uplet (souvent appelé tuple en
Python). Dans le cahier, les auteurs ont choisi d’utiliser le mot p-uplet, qui peut se décliner en 2-uplet
ou doublet (en prenant p = 2), 3-uplet ou triplet (p = 3), 4-uplet ou quadruplet (p = 4), etc.
Création, concaténation et multiplication d’un p-uplet sont découverts dans cette activité.
C’est également l’occasion de découvrir l’opérateur d’appartenance in.
Une étape essentielle de l’activité sera de découvrir qu’un p-uplet n’est plus modifiable par affectation
une fois créé. Il sera judicieux de faire remarquer à l’élève que sa modification sera possible par la
création d’un nouveau p-uplet et la copie d’une partie de ses éléments, ce qui revient à créer un nouvel
objet.
L’activité se termine avec une notion délicate à appréhender, l’affectation multiple, encore appelé le
dépaquetage (unpacking) de p-uplet. Ainsi dans la question 9, l’instruction Python
a, b, c = multiples(5) ne pourra fonctionner que si 3 variables a, b, c sont utilisées. Des
instructions du type a, b = multiples(5) ou encore a, b, c, d = multiples(5) provoqueront
une erreur, car la fonction multiples() écrite à la question 8 doit renvoyer un p-uplet de 3 valeurs
exactement, ni 2 ni 4.
Il semble judicieux de montrer ces erreurs de dépaquetage sur une console Python, en fin d’activité, ou
avec le vidéo-projecteur en classe.
04733901_p004-224.pdf 45 11/08/2021 14:50

Le dépaquetage de p-uplet apparaît souvent dans les QCM des épreuves communes et sera réintroduit (et
donc nécessaire) dans l’implémentation d’algorithmes plus complexes comme dans les séquences 9 et 10.
Activité 2 p. 41 / Découverte du type liste (voir la correction à la fin de la partie C)

 Écrire une liste en Python.
 Construire un tableau par compréhension.
 Utiliser des tableaux de tableaux pour représenter des matrices : notation a[i][j].
Cette activité propose de découvrir un nouveau type de variable, très utilisé en Python, appelé « liste ».
La liste en Python peut contenir des objets de différents types. L’élève découvre qu’il est ainsi
possible d’imbriquer différents types de variables, telles des poupées russes, pour obtenir, par
exemple, une liste de listes ou encore une liste de p-uplets, etc.
Une étape délicate de cette activité est la découverte de l’écriture d’une liste par compréhension. Cette
syntaxe très particulière est particulièrement efficace et doit être bien assimilée par l’élève pour
aborder les QCM des évaluations communes.
La question 8, qui propose de stocker les positions successives du cheval d’un jeu d’échecs dans une
liste, fait écho à l’image de début de séquence.
Activité 3 p. 42 / Propriétés d’une liste (voir la correction à la fin de la partie C)

 Lire et modifier les éléments d’un tableau grâce à leurs index.
 Itérer sur les éléments d’un tableau.
La correction Python de la question 7 est disponible sur le site ressources et le manuel numérique enseignant.
Au fil de l’activité, l’élève découvre comment accéder individuellement aux éléments d’une liste grâce
aux index (ou indices) de position (qui débutent toujours à zéro en Python).
L’élève découvre également la fonction len(), commune aux trois types construits, qui renvoie le
nombre d’éléments de la liste.
C’est aussi l’occasion (question 7) d’écrire une première fonction de comptage d’occurrences d’un
élément donné dans une liste donnée, avec la nécessité d’utiliser un compteur, géré par une variable de
type int.
Les questions 9 et 10 proposent de modifier une liste par affectation, ce qui était impossible avec un
p-uplet. C’est l’occasion d’insister sur cette différence majeure entre un p-uplet et une liste et
d’introduire (ou de revoir) le vocabulaire muable/immuable, modifiable/non modifiable, mutable/non
mutable. Les trois familles d’adjectifs peuvent être utilisées.
04733901_p004-224.pdf 46 11/08/2021 14:50

Activité 4 p. 43 / Découverte du type dictionnaire (voir la correction à la fin de la partie C)
 Construire une entrée de dictionnaire.
Cette activité présente un type nouveau de variable, le type dictionnaire. Contrairement au p-uplet et à
la liste, il n’est pas possible d’accéder à un élément par son index (ou indice) de position avec un
dictionnaire. Il est alors indispensable d’avoir recours à des clés, toutes différentes et de type non
muable, auxquelles sont associées des valeurs.
Cette activité propose de construire à la main trois entrées d’un dictionnaire de mots, afin de rester
dans la symbolique du mot dictionnaire. Il pourra être intéressant de tenter d’ajouter une clé identique
à une clé déjà présente, afin d’obtenir un message d’erreur (les clés doivent être toutes différentes).
La question 8 propose une illustration afin que l’élève mémorise bien qu’à chaque clé est associée une
valeur.
Activité 5 p. 44 / Convertisseur français-anglais (voir la correction à la fin de la partie C)

 Itérer sur les éléments d’un dictionnaire.
 Utiliser les méthodes keys(), values() et items().
Cette activité propose de découvrir trois méthodes spécifiques aux dictionnaires, les méthodes keys(),
values() et items(). Ces méthodes doivent être bien connues des élèves car de nombreuses
questions des évaluations communes y font référence.
La question 6 propose d’écrire une fonction booléenne utilisant simultanément l’opérateur in et la

méthode keys().
La question 7 est l’occasion de rappeler que Python est sensible à la casse (majuscule ou minuscule).
Activité 6 p. 45 / Les différents types de variables (voir la correction à la fin de la partie C)

 Distinguer les différents types de variables.
Pour cette activité, l’idée est d’avoir une réflexion sur les sept types de variables découverts dans les
séquences 1, 2 et 3. Une carte mentale à compléter est proposée dans la question 1.
La question 4 propose de retrouver le type de différentes variables, utilisées dans des scripts donnés.
Plusieurs solutions sont parfois possibles et la correction du spécimen enseignant ne fait apparaître que
les types les plus évidents ou les plus logiques.
04733901_p004-224.pdf 47 11/08/2021 14:50

04733901_p004-224.pdf 48 11/08/2021 14:50

04733901_p004-224.pdf 49 11/08/2021 14:50

04733901_p004-224.pdf 50 11/08/2021 14:50

04733901_p004-224.pdf 51 11/08/2021 14:50

04733901_p004-224.pdf 52 11/08/2021 14:50

04733901_p004-224.pdf 53 11/08/2021 14:50

04733901_p004-224.pdf 54 11/08/2021 14:50

 Utiliser une variable de type p-uplet.
Des variables de type p-uplet sont utilisées pour enregistrer les différentes adresses IPv4 d’un réseau
local privé. Rappelons que les adresses locales sont du type 192.168.X.X. Ces adresses ne sont pas
routées sur Internet et ne sont pas uniques, plusieurs réseaux locaux différents pouvant utiliser
localement les mêmes adresses IP.

 Utiliser quelques propriétés des p-uplets.
Cet exercice propose de retravailler quelques propriétés des p-uplets. L’utilisation de l’ordinateur n’est
pas indispensable. Le message d’erreur renvoyé par une console Python à la question 5.b sera
l’occasion de revenir sur le caractère non mutable des p-uplets.

 Écrire un appel de fonction.
 Utiliser une affectation multiple (dépaquetage de p-uplet).
Cet exercice met l’accent sur le dépaquetage de p-uplet (ou affectation multiple). L’élève doit être
capable d’écrire l’appel à la fonction recherche(), d’en analyser le contenu renvoyé (un 4-uplet) et
de l’affecter à 4 variables a, b, c, d.
Il est important de faire observer que le comportement de la fonction est identique, qu’un élève soit
trouvé ou non : dans le cas où un élève a été trouvé, le quadruplet (a, b, c, d) est renvoyé. Si
aucun élève n’a été trouvé, la fonction renvoie le quadruplet (None, None, None, None). Rappelons
que l’utilisation de print() doit être exceptionnelle et plutôt réservée au débogage. Autrement dit, la
fonction doit renvoyer un quadruplet dans tous les cas afin de ne pas créer d’erreur de dépaquetage.

 Construire une liste Python à la main.
Cet exercice propose de créer une liste des jours de la semaine. Ne pas oublier que les noms des jours
sont des chaînes de caractères qu’il convient de noter entre guillemets. La fonction len(), commune
aux trois types construits, est revue.
04733901_p004-224.pdf 55 11/08/2021 14:50

 Construire une matrice à la main.
Cet exercice propose de représenter les 9 cases d’un jeu de tic-tac-toe à l’aide d’une liste de listes en
Python. Le contenu de chaque case est une chaîne de caractères : 'O', 'X' ou '' qui désigne une case
vide.

 Construire une liste par compréhension.
Cet exercice propose de créer une liste par compréhension. Cette technique peut être rapide et doit être
connue d’un élève de 1re NSI car beaucoup de questions du thème B des évaluations communes
utilisent ce mode d’écriture.
La question 3 propose de découvrir l’ajout d’une condition de filtrage de liste, afin de ne garder que
les carrés pairs ou impairs. C’est l’occasion de revoir l’utilisation de la division euclidienne et du
symbole Python associé %.

 Construire une matrice par compréhension.
Cet exercice propose de créer une matrice par compréhension, représentant les 64 cases d’un jeu
d’échecs. L’élève découvre la nécessité d’utiliser deux boucles « pour » imbriquées l’une dans l’autre.
Afin de faciliter la génération du nom des lignes et des colonnes, les deux variables lettres et
chiffres peuvent être utilisées, sachant que les chaînes de caractères sont des itérables en Python,
c’est-à-dire qu’on peut les parcourir élément par élément, comme on le ferait avec une liste.
 Découvrir la méthode append().
Cet exercice propose de découvrir la méthode append(), qui opère uniquement sur le type list. Elle
permet d’ajouter un élément à la fin d’une liste en allongeant cette liste d’un élément. La syntaxe
point, empruntée à la programmation orientée objet (POO) est ici nécessaire. Ainsi l’instruction
Python L.append(2) ajoute-t-elle l’entier 2 en dernière position de la liste L.
Notons bien que cet ajout dynamique a une complexité très défavorable : pour ajouter un élément à
une liste, il faut d’abord créer une nouvelle variable de taille supérieure, ensuite recopier tous les
04733901_p004-224.pdf 56 11/08/2021 14:50

éléments un par un, pour enfin copier en dernière position l’élément à ajouter. Tout ceci est transparent
en Python, comme un genre de boîte noire.
La méthode doit être connue car beaucoup de questions des évaluations communes l’utilisent.

 Découvrir le slicing, encore appelé découpage de liste.
Le langage Python se prête très bien au slicing. Cet exercice propose d’en découvrir un usage simple
en opérant uniquement avec les deux arguments debut et fin, selon la syntaxe L[debut:fin]. Il
existe un autre argument possible appelé le pas selon la syntaxe L[debut:fin:pas]. Dans ce cas, les
éléments sont extraits toutes les pas valeurs. Il est recommandé de se référer à la documentation
Python pour découvrir encore plus de possibilités sur le slicing mais ce sujet sortirait du cadre de
l’enseignement de NSI de 1re.
Attention, le slicing peut être l’objet de questions lors de l’évaluation commune de 1re.

 Appliquer la compréhension de liste.
Cet exercice permet d’appliquer la syntaxe des listes en compréhension sous la forme de deux
questions de QCM (une seule bonne réponse).

 Créer et utiliser un dictionnaire.
 Utiliser la méthode items().
Cet exercice propose de stocker puis de retrouver les informations EXIF contenues dans un fichier
image. Pour cela, il faut créer un dictionnaire. On peut ensuite en extraire une valeur, pour une clé (on
encore une entrée) donnée.
La question 3 permet de revoir une des trois méthodes du type dictionnaire, la méthode items() qui
renvoie l’ensemble du contenu du dictionnaire (clés et valeurs).

 Créer et utiliser un dictionnaire.
 Utiliser la méthode keys().
04733901_p004-224.pdf 57 11/08/2021 14:50

Cet exercice propose de créer et d’utiliser un dictionnaire pour enregistrer le contenu d’un panier de
fruits. La méthode keys() permet de renvoyer toutes les clés du dictionnaire, c’est-à-dire ici le nom de
tous les fruits du panier. Rappelons que toutes les clés d’un dictionnaire doivent être différentes.

 Écrire une fonction Python qui opère sur un dictionnaire, reçu en argument.
La correction Python de cet exercice est disponible sur le site ressources et le manuel numérique enseignant.
La fonction à écrire permet d’effectuer la mise à jour d’un dictionnaire, utilisé ici pour gérer une
collection de fruits (nom et quantité). Cet exercice permet d’initier l’élève à la gestion d’une table et
de préparer la séquence 4 qui suivra (Données en table).
 Écrire une instruction Python qui opère sur un dictionnaire, en utilisant la méthode values().
Cet exercice propose d’utiliser simplement la méthode values() afin d’effectuer facilement la
recherche d’une occurrence dans un dictionnaire. Cette méthode doit être connue car elle est
régulièrement proposée lors des évaluations communes de première.

 Choisir un type de variable adapté.
Cet exercice propose de choisir un type de variable adapté selon l’utilisation attendue des données à
enregistrer. En effet, le choix d’une structure de données adaptée à l’utilisation prévue est essentiel en
algorithmique (et donc en programmation). Ce choix influence notamment la complexité de
l’algorithme, comme par exemple celui de choisir un dictionnaire (complexité plus favorable, grâce à
l’utilisation d’une table de hachage), plutôt qu’une liste.

 Analyser une fonction.
Cet exercice met l’accent sur l’analyse du type de variable renvoyé par quatre fonctions Python
indépendantes. L’élève doit s’interroger sur le type de variable manipulé dans la fonction et sur celui
renvoyé en fin de fonction avec le mot-clé return.
04733901_p004-224.pdf 58 11/08/2021 14:50

04733901_p004-224.pdf 59 11/08/2021 14:50

04733901_p004-224.pdf 60 11/08/2021 14:50

04733901_p004-224.pdf 61 11/08/2021 14:50

04733901_p004-224.pdf 62 11/08/2021 14:50

04733901_p004-224.pdf 63 11/08/2021 14:50

04733901_p004-224.pdf 64 11/08/2021 14:50

Proposition 1
La correction Python de ce mini-projet est disponible sur le site ressources et le manuel numérique enseignant.
Ce mini-projet propose de générer une « matrice creuse », c’est-à-dire une matrice essentiellement
composée de zéros, à l’aide d’un dictionnaire. On aurait pu également utiliser une liste de listes, mais
le dictionnaire permet de ne faire figurer que les cases non vides et aucune case contenant un zéro, qui
dès lors seront absentes du dictionnaire. Ceci pourrait d’ailleurs être gênant. L’accès à un dictionnaire
est particulièrement favorable d’un point de vue de la complexité, comparé à une liste de listes.
La question 5 propose de découvrir la méthode get() en consultant l’aide de Python. Cette méthode
permet de parcourir le dictionnaire et de renvoyer une valeur bien précise dans le cas où l’élément
cherché n’a pas été trouvé, une valeur renvoyée par défaut en quelque sorte. Ce sera le cas si la valeur
d’une case vaut zéro.
Proposition 2
Ce mini-projet propose de gérer un jeu de 52 cartes. L’élève pourra programmer des fonctions de base
en mode console : générer des cartes toutes différentes, choisir une structure de données adaptée,
écrire des fonctions permettant d’accéder au contenu du jeu de cartes.
Ce sera par exemple l’occasion de rappeler qu’avant de développer un jeu en mode graphique, il sera
judicieux de le développer en mode console.
04733901_p004-224.pdf 65 11/08/2021 14:50

Thème C : Traitement de données en table
Séquence 4 Données en table
Le thème C (Traitement de données en tables) correspond à la séquence suivante :

 Séquence 4 : « Données en table »
Il est indispensable d’avoir traité au préalable la séquence 3 avant d’aborder la séquence 4.
A. Le programme

Indexation de Importer une table depuis un fichier texte tabulé ou un Activité 1

tables fichier CSV. p. 58
Exercices 1 et 2
p. 64
Recherche dans Rechercher les lignes d’une table vérifiant des critères Activité 2 et 3
une table exprimés en logique propositionnelle. Tests de p. 59 et 60
cohérence.
Exercices 3, 4, 5
p. 65
Tri d’une table Trier une table suivant une colonne. Activité 3
p. 60
Exercices 6 et 7
p. 66
Fusion de tables Construire une nouvelle table en combinant les données Activité 4
de deux tables. p. 61
Exercices 8 et 9
p. 67
69 Thème C  Séquence 4 Données en table
04733901_p004-224.pdf 66 11/08/2021 14:50

ou sur le manuel numérique enseignant.
Activité Quelle est l’extension d’un fichier CSV ?

1
Réponses :
A. .docx
B. .csv (Bonne réponse.)
C. .py
Activité Quelle instruction Python permet d’afficher le premier élément d’une liste L Python ?
1
Réponses :
A. L[0] (Bonne réponse : les indices d’une liste commencent à 0.)
B. L[1]
C. L(0)
Activité Soit l’instruction Python x = '2'. Que renvoie l’instruction float(x) ?

2
Réponses :
A. 2.0 (Bonne réponse : l’instruction float('2') décode la chaîne de caractères '2' en nombre
flottant.)
B. 2
C. '2.0'
Activité Que se passe-t-il si l’on veut supprimer un élément d’une liste Python ?
2
Réponses :
A. C’est impossible, car une liste Python est non modifiable.
B. Cela crée un espace vide dans la liste.
C. Tous les index des éléments qui suivent sont décalés de 1. (Bonne réponse.)
Activité Quel est l’intérêt de trier un tableau ?

3
Réponses :
A. Supprimer les éléments écrits en double dans le tableau.
B. Repérer toute erreur d’insertion dans le tableau.
C. Organiser les éléments du tableau selon un critère précis. (Bonne réponse.)
Activité Quel est selon vous l’intérêt de grouper le contenu de deux tableaux différents ?
4
Réponses :
A. Obtenir un tableau plus grand.
B. Augmenter la quantité d’informations disponibles. (Bonne réponse.)
C. Enlever les informations présentes en double.
04733901_p004-224.pdf 67 11/08/2021 14:50

Histoire des Sciences p. 57 / Histoire des bases de données
 Revoir le format de fichier CSV, muni de descripteurs.
 Découvrir l’ancêtre des tableurs actuels.
Cette activité présente succinctement l’évolution du concept de base de données depuis la première
base de données développée par l’armée américaine en 1964, et la première utilisation du mot
database.
C’est l’occasion de revenir sur le format de fichier CSV, à l’écriture très simple et déjà vu en SNT, qui
permet l’interopérabilité entre différents systèmes en relation. L’importance des descripteurs est revue
à la question 1. Le dernier paragraphe du texte introduit la possibilité de fusionner le contenu de
plusieurs tables, selon une opération de fusion (au programme de Première) ou avec une jointure (au
programme de Terminale NSI).
Activité 1 p. 58 / Importation et indexation de tables

 Importer une table depuis un fichier texte tabulé ou un fichier CSV.
Cette activité est essentielle pour mener à bien les activités et les exercices de cette séquence. Elle
propose d’importer le contenu d’un fichier CSV dans un programme Python sous la forme d’une liste
de listes. Ce type d’importation sera volontairement utilisé dans quasiment toutes les activités et tous
les exercices, de manière à ce que l’élève devienne familier avec le procédé utilisé. Des questions
relatives à ces importations sont d’ailleurs contenues dans les QCM d’évaluation des épreuves
communes.
Comme dans toutes les activités et les exercices de programmation de la séquence, il existe deux
possibilités pour réaliser l’activité :
– en utilisant le lien donné dans l’activité vers le site ressources élève ; le programme Python et
le fichier stations.csv sont alors déjà chargés dans l’éditeur Python Bordas ;
– pour utiliser un autre éditeur Python, il est nécessaire de télécharger le fichier Python
activite_1.py et le fichier stations.csv depuis le site ressources et de les déposer dans le même
dossier de l’ordinateur utilisé. Notons que c’est le module Python csv qui permet d’effectuer
l’importation, il doit donc éventuellement être installé sur l’éditeur Python utilisé.
Il est intéressant de remarquer que seule l’importation d’un fichier CSV est au programme de NSI.
La mobilisation de ce type de structure de données permet de préparer les élèves à aborder la notion de
base de données qui ne sera présentée qu’en classe de Terminale. Les auteurs ont choisi de travailler
uniquement avec des tableaux doublement indexés, et non pas avec des tableaux de p-uplets,
notamment pour pouvoir en modifier directement le contenu par affectation.
04733901_p004-224.pdf 68 11/08/2021 14:50

Néanmoins, les auteurs ont tenu à présenter des instructions Python d’exportation d’une liste de listes
vers un fichier CSV, comme c’est le cas dans l’activité 4. En effet, l’élève trouvera dans le fichier
Python téléchargé une fonction exporter() qui lui permettra d’exporter le contenu d’une liste de
listes (nommée ci-dessous tableau) en un fichier nommé fichier.csv.
Une fois le fichier CSV importé, l’élève peut accéder à son contenu grâce aux index de position (il
s’agit bien d’une liste Python classique) et pourra également en modifier le contenu par affectation.
Activité 2 p. 59 / Recherche dans une table (voir la correction à la fin de la partie C)
 Importer une table depuis un fichier texte tabulé ou un fichier CSV.
 Rechercher les lignes d’une table vérifiant des critères exprimés en logique propositionnelle.
Les corrections Python de cette activité sont disponibles sur le site ressources et sur le manuel numérique
enseignant.
Cette activité propose d’effectuer des premières recherches dans une table, qui sera donc une liste de
listes Python. Dans cette activité, la question 1 permet de visualiser le contenu de la table du fichier
stations.csv, grâce à l’interface « Passer d’un fichier CSV à des points sur une carte ».
le fichier stations.csv sont alors déjà chargés dans l’éditeur Python Bordas ;
activite_2.py et le fichier stations.csv depuis le site ressources et de les déposer dans le même
dossier de l’ordinateur utilisé. Notons que c’est le module Python csv qui permet d’effectuer
À la question 4, l’élève découvre la présence de doublons dans la table. Les fichiers CSV disponibles
en open data sur certains sites officiels présentent souvent des erreurs d’insertion ou des doublons,
quand ils ne sont pas obsolètes. Il est donc délicat de travailler avec ces fichiers bruts et c’est pour
cette raison que les auteurs proposent de travailler avec des fichiers CSV créés par leurs soins.
Dans le cadre de la logique propositionnelle, les questions 9 à 12 permettent d’effectuer une recherche
selon un critère particulier. L’utilisation d’une fonction lambda() en argument de la fonction
selectionner() permet de modifier facilement le critère de recherche en gardant toujours la même
fonction selectionner(), qui sera réutilisée tout au long du chapitre, y compris dans les exercices.
Aux questions 11 et 12, l’élève doit modifier le critère de recherche en s’inspirant du code Python
donné à la question 10.
04733901_p004-224.pdf 69 11/08/2021 14:50

Activité 3 p. 60 / Test de cohérence et tri d’une table (voir la correction à la fin de la partie C)
 La recherche de doublons, les tests de cohérence d’une table sont présentés.
 Trier une table suivant une colonne.
enseignant.
Il convient de vérifier périodiquement l’intégrité d’une base de données, qui pourrait subir des erreurs
d’insertion ou posséder des champs non renseignés par exemple.
– en utilisant le lien donné dans l’activité vers le site ressources élève ; le programme Python
et le fichier stations.csv sont alors déjà chargés dans l’éditeur Python Bordas ;
activite_3.py et le fichier stations.csv depuis le site ressources et de les déposer dans le
même dossier de l’ordinateur utilisé. Notons que c’est le module Python csv qui permet
d’effectuer l’importation, il doit donc éventuellement être installé sur l’éditeur Python utilisé.
L’activité propose d’utiliser la fonction test_id() (disponible dans l’éditeur Python ou le fichier à
télécharger, comme expliqué ci-dessus), qui vérifie si toutes les entrées ont des identifiants id
différents, en renvoyant le liste des id en doublon ou plus. Cette fonction est déjà écrite et l’élève doit
écrire une instruction Python afin de l’appeler et de parcourir la table de données.
Trier une table selon un critère donné est une étape importante de cette activité : on utilisera ici la
méthode sorted(), qui permet de trier selon une clé choisie, de nouveau grâce à une fonction lambda.
La méthode sorted() agissant comme une « boîte noire », l’intérêt de l’activité est ici de déterminer
la clé qui permettra d’effectuer le tri souhaité. Les clés de tri à trouver aux questions 9 et 10 sont du
même type que celle donnée à la question 8. L’élève pourra donc procéder par imitation et/ou par
tâtonnement.
Activité 4 p. 61 / Fusion de deux tables (voir la correction à la fin de la partie C)

 Construire une nouvelle table en combinant les données de deux tables
enseignant.
Les auteurs ont estimé que la jointure de deux tables était totalement hors programme de la classe de
Première. En SQL, les jointures sont faites automatiquement par le SGBDR, qui agit tel une « boîte
noire ». En Python, la programmation d’une jointure à la main est possible, mais ne présente aucun
intérêt pédagogique.
04733901_p004-224.pdf 70 11/08/2021 14:50

On se contentera donc ici d’une fusion de deux tables, à l’aide de l’opérateur de concaténation +, et
présentant les mêmes descripteurs, car sinon le contenu de la table fusionnée serait incohérent, la
rendant inexploitable par la suite.
Dans cette activité, il pourra être pertinent de montrer aux élèves le contenu visuel des deux tables
snack.csv et stations.csv, grâce à l’interface « Passer d’un fichier CSV à des points sur une carte ».
La table fusionnée permettra de rassembler le contenu des deux tables en une seule.
les fichiers snacks.csv et stations.csv sont déjà chargés dans l’éditeur Python Bordas ;
– pour utiliser un autre éditeur Python, il est nécessaire de télécharger le fichier Python et les
fichiers snacks.csv et stations.csv sur le site ressources et de les déposer dans le même dossier
de l’ordinateur utilisé. Notons que c’est le module Python csv qui permet d’effectuer
04733901_p004-224.pdf 71 11/08/2021 14:50

04733901_p004-224.pdf 72 11/08/2021 14:50

04733901_p004-224.pdf 73 11/08/2021 14:50

04733901_p004-224.pdf 74 11/08/2021 14:50

04733901_p004-224.pdf 75 11/08/2021 14:50

04733901_p004-224.pdf 76 11/08/2021 14:50

Pour les exercices1 à 5, les auteurs ont choisi des données permettant une représentation visuelle sur
une carte du monde, rendue possible grâce à l’interface « Passer d’un fichier CSV à des points sur une
carte ». Ceci pourrait servir d’introduction en classe et permet de donner du sens au travail à réaliser
en classe ou à la maison.
possibilités pour travailler sur les exercices :
– en utilisant le lien donné dans l’exercice vers le site ressources élève ; le programme Python et
le ou les fichier(s) CSV sont déjà chargés dans l’éditeur Python Bordas ;
– pour utiliser un autre éditeur Python, il est nécessaire de télécharger le fichier Python et le ou
les fichier(s) CSV sur le site ressources et de les déposer dans le même dossier de l’ordinateur
utilisé. Notons que c’est le module Python csv qui permet d’effectuer l’importation, il doit
donc éventuellement être installé sur l’éditeur Python utilisé.
Les corrections Python des exercices sont disponibles sur le site ressources et le manuel numérique enseignant.

 Importer une table depuis un fichier CSV.
 Utiliser la fonction append().
Cet exercice propose de travailler avec les capitales du monde. Les auteurs ont choisi des données
permettant une sortie graphique. Il est ainsi possible de visualiser ces capitales grâce à l’interface
« Passer d’un fichier CSV à des points sur une carte », en complément de l’activité : un simple copier-
coller du contenu du fichier CSV dans la fenêtre de l’interface, ouvert par exemple avec le bloc-notes,
permet instantanément l’affichage des capitales du monde sur une carte OpenStreetMap.
Cet exercice propose ainsi de vérifier l’absence de la capitale des États-Unis, Washington, dans la
table. Après son ajout grâce à la fonction append(), il est possible d’en vérifier visuellement la
présence dans le nouveau fichier CSV obtenu après exportation de la liste de listes.
La fonction exporter() permet ainsi l’exportation d’une liste de listes Python vers un fichier CSV.

 Importer une table depuis un fichier CSV.
 Modifier une liste de listes par affectation.
Cet exercice propose d’importer le même fichier CSV qu’à l’exercice 1 et d’afficher certaines
données. La donnée à afficher est repérée grâce à ses indices (ou index) de position, qui commencent à
zéro en Python. Ce type de question est courant pour les évaluations communes.
04733901_p004-224.pdf 77 11/08/2021 14:50

 Effectuer une recherche monocritère dans une table.
Cet exercice propose d’importer le même fichier CSV qu’à l’exercice 1 et d’effectuer une recherche
dans la table. La fonction selectionner(tableau, critere) qui a déjà été rencontrée à l’activité 2
permet d’effectuer une recherche dans un tableau selon un critère donné. Il s’agit, là aussi, d’utiliser
une fonction lambda générique, qui permet de passer le critère de recherche en argument de la
fonction selectionner().
Il est possible d’imaginer tout type de recherche, en modifiant le critère de recherche passé en
argument de la fonction selectionner(). On peut ainsi demander aux élèves de proposer un critère
de recherche de leur choix et d’en vérifier ensuite l’exactitude.

 Effectuer une recherche multicritère dans une table.
Il est possible d’effectuer une recherche multicritère en donnant une expression booléenne en
argument de la fonction selectionner(). C’est l’occasion de réutiliser l’opérateur booléen and,
découvert à la séquence 2. Il s’agit ici d’afficher uniquement les capitales d’Amérique du Sud situées
dans l’hémisphère Nord. En effet, de nombreuses capitales d’Amérique du Sud sont dans l’hémisphère
Sud et ont, de fait, une latitude négative, dite latitude Sud.

 Effectuer une recherche multicritère complexe dans une table.
La question 1 propose de retrouver la longitude la ville de Paris, avec une écriture en compréhension
et une condition de filtrage appropriée. La question 2 propose d’effectuer une recherche multicritère
en opérant des calculs de longitude. Il s’agit de trouver toutes les capitales dont la longitude diffère de
celle de Paris d’au plus un degré de longitude, vers l’est ou vers l’ouest.

 Effectuer un tri dans une table.
De nombreux sites web proposent de trier les articles en vente du plus cher au moins cher ou encore de
A à Z, etc. Cet exercice propose de trier des sacs selon une de leurs caractéristiques : longueur,
largeur, prix, légèreté, volume… Les sacs étant tous différents, le résultat du tri sera différent à chaque
question.
04733901_p004-224.pdf 78 11/08/2021 14:50

C’est la méthode sorted() qui est ici à nouveau utilisée, assortie d’une clé de filtrage munie d’une
fonction lambda, à modifier selon le tri à effectuer. L’argument reverse=True permet d’afficher le
résultat du plus grand au plus petit. L’argument reverse=False (ou en omettant de l’écrire) renverra
le résultat du tri du plus petit au plus grand.
À la question 6, la valeur du volume du sac doit être calculée en effectuant la multiplication

largeur × longueur × hauteur.

 Effectuer un tri dans une table selon l’ordre lexicographique.
L’ordre lexicographique est celui du dictionnaire. On peut ainsi comparer deux chaînes de caractères
grâce aux opérateurs < ou >.
Il est donc possible d’effectuer un tri en comparant les noms des sacs, stockés dans des chaînes de
caractères, afin de les trier de A à Z, c’est-à-dire par ordre alphabétique.

 Effectuer la fusion de deux tables partageant les mêmes descripteurs.
Cet exercice propose de fusionner deux tables implémentées en Python par deux listes ayant les
mêmes descripteurs. C’est l’opérateur de concaténation + qui permet de rassembler les informations en
une seule table, à condition que les deux tables partagent les mêmes descripteurs, qui sont redemandés
à la question 1.
Il ne s’agit en aucun cas d’une jointure, qui ne sera découverte qu’en classe de Terminale, en langage
SQL.

 Effectuer la fusion de deux tables partageant les mêmes descripteurs.
Cet exercice propose de fusionner deux tables implémentées en Python par deux listes ayant les
mêmes descripteurs. C’est l’opérateur de concaténation + qui permet de rassembler les informations en
une seule table, à condition que les deux tables partagent les mêmes descripteurs. Dans cet exercice,
l’élève doit remarquer que les valeurs enregistrées dans les deux tables ne sont pas exprimées dans les
mêmes unités de mesure (degrés Celsius et degrés Fahrenheit). Un traitement calculatoire préalable à
la fusion est ici nécessaire car, sinon, les valeurs, une fois fusionnées, pourraient très difficilement être
modifiées.
04733901_p004-224.pdf 79 11/08/2021 14:50

04733901_p004-224.pdf 80 11/08/2021 14:50

04733901_p004-224.pdf 81 11/08/2021 14:50

04733901_p004-224.pdf 82 11/08/2021 14:50

04733901_p004-224.pdf 83 11/08/2021 14:50

à l’adresse : cahier-nsi.fr/#!/revision/seq4.
04733901_p004-224.pdf 84 11/08/2021 14:50

Les corrections Python de ces mini-projets sont disponibles sur le site ressources et sur le manuel numérique
enseignant.
Proposition 1
Ce mini-projet propose de gérer certaines données relatives au personnel d’une entreprise du Web.
Une structure de données de type dictionnaire est ici utilisée pour stocker ces informations. L’objectif
du projet est d’écrire des fonctions réalisant des opérations particulières afin d’extraire certaines
informations de la table.
Ceci permet d’illustrer la différence entre une véritable base de données (qui sera vue en Terminale
NSI) et la table de l’exercice. En effet, une requête précise en SQL permettrait d’obtenir plus
rapidement les informations souhaitées, sans nécessiter l’écriture d’une fonction spécifique.
Proposition 2
Il faudra ici vérifier l’intégrité d’une base de données téléchargée sur le site
https://www.data.gouv.fr/fr/. Il est en effet fréquent que des erreurs d’insertion, des omissions de
champs ou des valeurs erronées soient introduites par mégarde dans une base de données publique. Ce
mini-projet permet de familiariser l’élève avec le caractère imparfait d’une base de données, surtout si
elle comporte un grand nombre d’entrées, et justifie la vérification de son intégrité.
04733901_p004-224.pdf 85 11/08/2021 14:50

Thème D : Interactions entre l’homme et la machine sur le Web
Séquence 5 Interactions entre l’homme

et la machine sur le Web
Le thème D (Interactions entre l’homme et la machine sur le Web) correspond à la séquence suivante :
 Séquence 5 : Interactions entre l’homme et la machine sur le Web
Cette séquence est indépendante des autres et elle peut être traitée à tout moment de l’année.
A. Le programme

Modalités de Identifier les différents composants graphiques permettant Activités 3 et 4

l’interaction entre d’interagir avec une application web. p. 75 et 76
l’homme et la Identifier les événements que les fonctions associées aux
machine différents composants graphiques sont capables de traiter. Exercices 6, 7, 8
et 9 p. 86
Événements
Interaction avec Analyser et modifier les méthodes exécutées lors d’un clic Activité 4 p. 76
l’utilisateur dans sur un bouton d’une page web.
une page web Exercices 7 et 8
p. 86
Interaction client- Distinguer ce qui est exécuté sur le client ou sur le serveur Activités 1, 2, 5, 6
serveur et dans quel ordre. p. 72-74 et 77-78
Distinguer ce qui est mémorisé dans le client et retransmis
Requêtes HTTP, au serveur. Exercices 4, 5, 10
réponses du Reconnaître quand et pourquoi la transmission est p. 85 et 87
serveur chiffrée.
Formulaire d’une Analyser le fonctionnement d’un formulaire simple. Activité 7 p. 79

page web Distinguer les transmissions de paramètres par les
requêtes GET ou POST. Exercices 5 et 11
p. 85 et 87
89 Thème D  Séquence 5 Interactions entre l’homme et la machine sur le Web
04733901_p004-224.pdf 86 11/08/2021 14:50

ou dans le manuel numérique enseignant.
Activité Dans le modèle client-serveur, qui envoie une requête ?

1
Réponses :
A. Le client. (Bonne réponse.)
B. Le serveur.
C. Le client et le serveur.
Activité À quoi sert un cookie ?

2
Réponses :
A. À enregistrer des informations de connexion. (Bonne réponse.)
B. Uniquement à récupérer des informations personnelles pour de la publicité ciblée.
C. À garantir notre anonymat sur Internet.
Activité Qu’est-ce que le langage HTML ?

3
Réponses :
A. Un langage de programmation.
B. Un langage de description d’une page web. (Bonne réponse.)
C. Un langage utilisé pour programmer un robot.
Activité JavaScript est un langage de programmation.

4 À quoi ne pourrait pas servir un script JavaScript inclus dans une page web ?
Réponses :
A. À afficher l’heure.
B. À éteindre l’ordinateur. (Bonne réponse.)
C. À effectuer un calcul.
Activité Dans l’architecture client-serveur, à quoi sert le serveur ?

5
Réponses :
A. À renvoyer une réponse appropriée au client. (Bonne réponse.)
B. À envoyer une requête HTTP.
C. À gérer l’affichage sur un écran.
Activité Je consulte une page web et un cadenas est affiché dans la barre d’adresse.
6
Réponses :
A. Je consulte un site sûr.
B. Je n’ai aucune certitude d’être sur un site sûr. (Bonne réponse.)
C. Les données échangées avec le serveur ne sont pas chiffrées.
04733901_p004-224.pdf 87 11/08/2021 14:50

Histoire des Sciences p. 71 / L’histoire du Web (voir la correction à la fin de la partie C)
 Revoir le rôle joué par HTTP, HTML et URL.
 Distinguer le Web d’Internet.
Cette activité présente succinctement l’histoire du Web, depuis sa création en 1989 jusqu’à
l’apparition du commerce en ligne (1997). Le développement du Web et du e-commerce a été
uniquement possible grâce à l’existence d’un réseau de communication fiable existant entre
ordinateurs distants et serveurs, selon le modèle client-serveur.
Notons, comme on le verra en classe de Terminale NSI, qu’une base de données est souvent
indispensable pour gérer efficacement un service sur le Web. Le modèle client-serveur peut alors être
modifié en une architecture à plusieurs niveaux.
Le développement de la norme Wi-Fi a, quant à elle, permis de connecter toujours plus d’appareils
nomades à Internet, comme les tablettes, les consoles de jeu vidéo ou encore tout type d’objet
connecté (caméra, montre, etc.).
Activité 1 p. 72 / Interaction client/serveur (voir la correction à la fin de la partie C)
 Redécouvrir le modèle client-serveur.
 Examiner et modifier le contenu d’une requête HTTP.
 Utiliser l’inspecteur de propriétés d’un navigateur web.
Cette activité est essentielle pour bien comprendre (ou revoir) le principe du modèle client-serveur,
déjà rencontré en classe de seconde (SNT). L’utilisation de l’inspecteur de propriétés du navigateur
web permet à l’élève d’examiner le contenu d’une requête HTTP, de la modifier et d’interagir avec un
serveur distant. Des codes d’erreur (404, 200, ...) sont systématiquement renvoyés par le serveur et
doivent nous renseigner sur l’état du serveur.
La requête HTTP, composée d’un en-tête et d’un corps, contient beaucoup d’informations exploitables
et non chiffrées.
Cette activité en double page permet à l’élève de se familiariser avec l’inspecteur de propriétés, ce qui
peut constituer un bon réflexe de débogage, tout comme on peut afficher le code source d’une page
web (avec la combinaison de touches CTRL + U sous Windows).
04733901_p004-224.pdf 88 11/08/2021 14:50

Activité 2 p. 74 / Cookies (voir la correction à la fin de la partie C)
 Rappeler le rôle joué par un cookie.
 Lire le contenu d’un cookie dans le disque dur de sa machine.
Cette activité propose de créer puis de supprimer un cookie grâce à une interface web spécialement
développée pour cette activité.
Il s’agit de se connecter à un serveur distant avec un couple (login, mot de passe) de son choix, puis
d’aller retrouver le cookie qui a été déposé par le serveur sur la machine connectée. Le cookie restera
stocké tant que l’utilisateur n’aura pas fait de déconnexion.
Cette activité est intéressante, car les lois sur les données personnelles évoluent rapidement depuis
quelques années. Ainsi en 2021, peut-on lire l’extrait suivant sur le site web de la CNIL (Commission
Nationale de l'Informatique et des Libertés), commission créée par la loi Informatique et Libertés
du 6 janvier 1978 :
Refuser les traceurs doit être aussi simple que les accepter.
L’internaute doit consentir au dépôt de traceurs par un acte positif clair, comme le fait de cliquer sur « J’accepte »
dans une bannière cookie. Son silence, qui peut passer par la simple poursuite de la navigation, doit dorénavant
s’interpréter comme un refus : aucun traceur non essentiel au fonctionnement du service ne pourra alors être
déposé sur son appareil.
La CNIL a également estimé que l’intégration d’un bouton « Tout refuser » sur le même niveau et sur le même
format que le bouton « Tout accepter » permet d’offrir un choix clair et simple pour l’internaute.
Source www.cnil.fr, consulté le 26 juin 2021
La CNIL est chargée de veiller à la protection des données personnelles contenues dans les fichiers
et les traitements informatiques ou papier, aussi bien publics que privés.
À la question 10, l’élève retrouve la notion d’usurpation d’identité, déjà abordée en SNT, et qui avait
été identifiée comme un acte malveillant de cyber harcèlement.
Activité 3 p. 75 / Composants graphiques d’une page web

 Identifier les composants graphiques d’une page web.
 Examiner le code d’une page HTML.
Cette activité pose les jalons des activités qui suivent. Afin de découvrir ce thème sur l’interaction
entre l’homme et la machine sur le Web, elle propose d’apprendre à repérer les composants graphiques
d’une page web, introduits grâce à des balises HTML du genre : <input ''type''= … > .
04733901_p004-224.pdf 89 11/08/2021 14:50

Le code de la page web peut être visualisé avec la commande CTRL + U sur Windows.
Cette activité présente les six principaux composants à connaître en 1re NSI :
 le bouton ;
 la zone de texte ;
 le bouton radio ;
 la zone de mot de passe ;
 la case à cocher ;
 le menu déroulant.
L’élève doit, en particulier, bien identifier le rôle de chacun et utiliser les composants graphiques à
bon escient.
La question 6 fait le lien avec les activités qui suivent dans le chapitre : elle montre que les
composants graphiques peuvent appeler des fonctions écrites en langage JavaScript, grâce par exemple
aux gestionnaires d’événements onclik et onload. Le titre « Interactions entre l’homme et la machine
sur le Web » commence à faire sens.
Activité 4 p. 76 / Analyser et modifier une méthode JavaScript

 Analyser et modifier une méthode JavaScript.
La correction JavaScript de la question 6 de cette activité est disponible sur le site ressources et dans le manuel
Il s’agit ici de modifier une des méthodes JavaScript de l’activité 3. Il n’est pas si simple de modifier
une méthode, surtout quand on est débutant. Aussi cette activité propose-t-elle d’abord de repérer le
code JavaScript, puis la méthode écrite en langage JavaScript et enfin de s’interroger sur le rôle joué
par cette méthode lorsqu’elle est appelée.
L’élève y découvre la méthode getElementById() utilisée pour accéder aux propriétés d’un
composant graphique inséré dans la page web. Cette méthode doit être parfaitement connue des élèves
et sera réutilisée dans les prochaines activités et certains exercices.
La question 6 propose de compléter le code d’une méthode JavaScript, en imitant celui qui a déjà été
écrit. Cette méthode JavaScript Calcul() sera finalement composée d’une structure conditionnelle
introduite par le mot-clé if.
C’est l’occasion de montrer que la structure conditionnelle n’est pas réservée à un langage de
programmation en particulier, comme Python.
04733901_p004-224.pdf 90 11/08/2021 14:50

Activité 5 p. 77 / Langage client et langage serveur (voir la correction à la fin de la partie C)
 Distinguer ce qui est exécuté sur le client ou sur le serveur et dans quel ordre.
Cette activité est composée d’une page web qui affiche deux pendules. Après rafraîchissement de la
page web (touche F5), l’élève découvre que seule la pendule de Paris égrène les secondes. La pendule
affichant l’heure de New York est figée. Si on actualise la page, l’heure de New York est alors mise à
jour.
L’élève doit s’interroger sur la différence de programmation utilisée pour chacune des pendules. Il est
important qu’il fasse le lien entre la mise à jour de l’heure de New York et le rafraîchissement de la
page web.
La pendule de Paris est codée en JavaScript, code qui est exécuté côté client, tandis que la pendule de
New York est codée en PHP, code qui est exécuté côté serveur.
Rappelons qu’un code JavaScript pourrait très bien être exécuté côté serveur et que l’affirmation
« JavaScript est un langage client » est fausse.
Activité 6 p. 78 / Protocole SSL (voir la correction à la fin de la partie C)

 Reconnaître quand et pourquoi la transmission est chiffrée.
Trop d’élèves pensent que la présence d’un cadenas dans l’URL d’une page web est un gage de
sécurité et de chiffrement. Ce cadenas veut simplement dire que le certificat du site est valide et que la
connexion est chiffrée. Mais il est tout à fait possible d’être connecté sur une fausse page web de
banque, avec un vrai certificat SSL.
Cette activité présente le principe de l’activation d’un certificat SSL, qui nécessite de nombreux allers-
retours entre le client et le serveur, de manière totalement transparente pour l’utilisateur.
Le protocole HTTPS permet de chiffrer les échanges de données entre le client et le serveur.
Pour être certain d’être sur une page web sécurisée, il faut donc exiger le cadenas (certificat SSL
valide et HTTPS), mais ce n’est pas suffisant. Il faudra également vérifier que l’URL est exacte : ainsi
l’URL https://votrebanque.com peut-elle sembler correcte, tandis que l’URL
https://votrebanque.dkfsjli.com devrait alerter un internaute avisé !
La question 6 aborde la technique de l’hameçonnage (phishing), très courante, qui exploite la crédulité
des internautes et constitue en soi une escroquerie. En effet, nous recevons chaque jour plusieurs
tentatives de phishing (voire plusieurs dizaines) dans notre boîte e-mail, qui sont en général filtrées par
le système de messagerie.
04733901_p004-224.pdf 91 11/08/2021 14:50

Activité 7 p. 79 / Analyser le fonctionnement d’un formulaire simple
 Analyser le fonctionnement d’un formulaire simple.
 Distinguer les transmissions de paramètres par les requêtes GET ou POST.
Cette activité, que les auteurs ont voulue simple, propose de découvrir un formulaire décrit en langage
HTML. La gestion d’un formulaire nécessite l’interaction avec un serveur web. C’est pour cette raison
que deux interfaces ont été spécialement développées pour réaliser l’activité (une pour GET et une
pour POST).
L’élève doit en particulier comprendre le lien entre la page du formulaire et la page cible.php,
programmée en PHP.
Rappelons la différence essentielle entre les méthodes GET et POST :

 Avec la méthode GET, les attributs sont transmis au serveur via l’URL de la requête et les
champs sont donc parfaitement visibles. Cette méthode est parfaite pour enregistrer les favoris
dans un navigateur web ou pour partager l’URL d’un objet vu sur un site marchand sur un
réseau social
 Avec la méthode POST, les attributs sont transmis au serveur dans le corps de la requête, ce
qui les rend invisibles à l’œil nu, mais lisibles avec l’inspecteur de propriétés du navigateur
web.
 Rappelons qu’aucune de ces deux méthodes n’est sécurisée ni chiffrée. Il ne faut donc pas
confondre GET et POST avec le protocole HTTPS.
04733901_p004-224.pdf 92 11/08/2021 14:50

04733901_p004-224.pdf 93 11/08/2021 14:50

04733901_p004-224.pdf 94 11/08/2021 14:50

04733901_p004-224.pdf 95 11/08/2021 14:50

04733901_p004-224.pdf 96 11/08/2021 14:50

04733901_p004-224.pdf 97 11/08/2021 14:50

04733901_p004-224.pdf 98 11/08/2021 14:50

04733901_p004-224.pdf 99 11/08/2021 14:50

04733901_p004-224.pdf 100 11/08/2021 14:50

04733901_p004-224.pdf 101 11/08/2021 14:50

Les exercices de cette séquence proposent d’en balayer les différents sous-thèmes : révisions de
HTML et de CSS, modèle client-serveur, JavaScript, SSL et GET / POST.
Un devoir maison pourrait permettre à l’élève de valoriser toutes ces connaissances, mais les auteurs
mettent en garde contre les abus du copier-coller par les élèves. Ceci donnera lieu à une très bonne
note dans le cas d’un travail noté, mais à une acquisition très limitée des connaissances nécessaires
pour l’évaluation commune.

 Décrire une page en HTML.
Des propositions de correction des pages accueil.html et photos.html de cet exercice sont disponibles sur le site
ressources et le manuel numérique enseignant.
Même si ce n’est pas explicitement au programme de la classe de Première NSI, le prérequis à

l’écriture de fonctions JavaScript (qui sont, elles, au programme) est la connaissance du langage de
description HTML. Ce premier exercice propose de réactiver les notions vues en SNT avec deux pages
à décrire : accueil.html et photos.html.
L’exercice se termine à la question 3, qui rappelle que le HTML ne permet pas de donner du style à la
page web et qu’il faudra utiliser pour cela un autre langage, le langage CSS, qui fait l’objet de
l’exercice 2.

 Utiliser un fichier CSS.
Des propositions de correction des fichiers accueil.html, photos.html et style.css de cet exercice sont disponibles
sur le site ressources et le manuel numérique enseignant.
Cet exercice montre à l’élève une façon d’insérer du code CSS dans une page web, à l’aide d’un
fichier externe nommé style.css.
Il est préférable d’utiliser un fichier de style externe à la page web car il pourra alors être utilisé par
l’ensemble des pages du site web et une seule modification de ce fichier CSS permettra la mise à jour
de l’ensemble des pages web, accessibles depuis le client-navigateur.
04733901_p004-224.pdf 102 11/08/2021 14:50

 Donner du style à une page web avec le langage CSS.
La correction CSS de cet exercice est disponible sur le site ressources et le manuel numérique enseignant.
Cet exercice propose de donner du style à la page web préparée à l’activité 3 page 75. L’élève peut
laisser libre cours à son imagination. Du code CSS est facilement exploitable sur le web en effectuant
la recherche « code CSS » sur un moteur de recherche.

 Modifier et renvoyer une requête HTTP.
La question 2 propose de découvrir l’existence de nombreux codes renvoyés par le serveur web,
lorsqu’il reçoit une requête. Un des codes les plus connus est le code 404, qui précise que la page web
demandée dans la requête n’existe pas : elle n’existe pas, elle a été déplacée ou a pu changer de nom,
en bref, elle est introuvable sur le serveur.
L’utilisation de l’inspecteur de propriétés permet de lire le contenu de la requête HTTP, de la modifier

et de ré-envoyer la nouvelle requête ainsi modifiée. Il est donc possible de générer volontairement des
codes d’erreur, à condition d’écrire une requête appropriée.
Cet exercice peut être fait en classe entière avec un vidéoprojecteur et un ordinateur connecté à
Internet. Il permet de mettre l’accent sur le modèle-client-serveur en illustrant la communication
permanente qui existe entre le client et le serveur.

 Installer un serveur Wamp local.
 Examiner le contenu d’une requête HTTP.
Cet exercice est difficile car il requiert l’installation d’un serveur Wamp sur l’ordinateur de l’élève.
Le logiciel UwAmp a été testé en classe avec succès et il ne nécessite aucune installation, car il est
portable. Il peut donc être copié-collé sur une clé USB.
Cette méthode de travail en local permet de simuler l’existence d’un serveur web. C’est ainsi qu’un
développeur web peut tester une nouvelle application web avant de la mettre réellement en ligne.
Très formateur, cet exercice nécessite du temps et une bonne compréhension de la méthodologie mise
en place. L’utilisation de l’inspecteur de propriétés permet de lire le contenu de la requête HTTP, de la
modifier et de ré-envoyer la nouvelle requête ainsi modifiée, comme nous l’avons fait à l’exercice 4.
04733901_p004-224.pdf 103 11/08/2021 14:50

 Trouver une erreur dans un programme écrit en JavaScript.
Le débogage d’une fonction JavaScript est souvent fastidieux car aucun message d’erreur n’est
renvoyé par le navigateur. L’élève constate simplement que son programme « ne fonctionne pas » ou
ne donne pas le résultat attendu.
Pour sensibiliser l’élève aux erreurs de casse (majuscule, minuscule) et de syntaxe (accolades,
parenthèses, points-virgules, etc.), cet exercice comporte 4 erreurs que l’élève doit retrouver.
L’utilisation d’un vidéoprojecteur est recommandée en classe. On peut facilement reproduire ce genre
d’exercice très formateur en prenant n’importe quel code JavaScript et en y insérant volontairement
des erreurs.

 Écrire une méthode en JavaScript.
La correction HTML, CSS et JavaScript de cet exercice est disponible sur le site ressources et le manuel
En se basant sur le code du convertisseur de l’activité 3, l’élève peut élaborer son propre convertisseur
de devises (euro/dollar). Cet exercice nécessite l’utilisation des 3 langages : HTML, CSS et
JavaScript.
Cet exercice pourrait faire l’objet d’un devoir maison.

 Modifier une méthode JavaScript.
La correction JavaScript de cet exercice est disponible sur le site ressources et le manuel numérique enseignant.
Cet exercice nécessite d’avoir traité au préalable l’activité 4 page 76. Son objectif est de modifier une
fonction JavaScript déjà écrite de manière à l’améliorer et à ajouter de nouvelles fonctionnalités.
04733901_p004-224.pdf 104 11/08/2021 14:50

 Insérer des composants graphiques dans une page web.
 Écrire une méthode en JavaScript.
L’objectif de cet exercice est de permettre à l’élève de composer une véritable page web, dont le fond
(background) est une couleur choisie par l’internaute. Grâce au clic sur un bouton et via un
gestionnaire d’événements onclick, une fonction JavaScript Couleur() est appelée et change la
couleur du fond de la page.

 Repérer une tentative de phishing (hameçonnage).
 Reconnaître une connexion sécurisée.
L’objectif de cet exercice est de sensibiliser l’élève à une des escroqueries les plus courantes du Web :
le phishing. Son principe est le suivant : un faux site web se présente comme un vrai et l’internaute qui
ne se méfie pas communique ses vrais identifiants à un faux site web. Par la suite, on peut imaginer
que ses informations personnelles seront utilisées à mauvais escient.
L’exercice propose également de tester la sécurité de plusieurs sites web en testant la robustesse de
leurs protocoles de certification SSL. En effet, il existe différents protocoles et algorithmes de
chiffrement et on pourrait s’attendre, par exemple, à ce que des sites bancaires soient très bien
sécurisés, mais ce n’est pas toujours le cas. Tester la sécurité du site de votre choix révèlera à coup sûr
son lot de surprises. L’effet est garanti en classe entière.

 Distinguer une requête GET d’une requête POST.
 Identifier les paramètres transmis par un questionnaire.
Cet exercice propose d’analyser une requête de type GET, puisque les paramètres sont visibles dans
l’URL. Rappelons que, quelle soit la méthode utilisée (GET ou POST), aucun chiffrement n’est utilisé.
04733901_p004-224.pdf 105 11/08/2021 14:50

04733901_p004-224.pdf 106 11/08/2021 14:50

04733901_p004-224.pdf 107 11/08/2021 14:50

04733901_p004-224.pdf 108 11/08/2021 14:50

04733901_p004-224.pdf 109 11/08/2021 14:50

04733901_p004-224.pdf 110 11/08/2021 14:50

Les corrections HTML et JavaScript de ces mini-projets sont disponibles sur le site ressources et sur le
manuel numérique enseignant.
Proposition 1
Ce mini-projet propose de simuler le minage de bitcoin. En cliquant sur le bouton « Bitcoin », on
commence à miner et les bitcoins s’accumulent dans le portefeuille virtuel.
Certaines fonctions JavaScript sont déjà écrites. Ce projet propose de modifier les fonctions déjà
écrites ou d’en écrire d’autres pour modifier les caractéristiques de la ferme de minage et ainsi
optimiser ses capacités de production.
Proposition 2
Il faudra ici résoudre l’énigme proposée puis imaginer une suite en écrivant autant de fonctions
JavaScript que nécessaire pour bâtir un scénario. La longueur du jeu variera en fonction du temps dont
l’élève dispose pour programmer ce jeu.
04733901_p004-224.pdf 111 11/08/2021 14:50

Thème E : Architectures matérielles
et systèmes d’exploitation
Séquence 6 Architecture et systèmes d'exploitation
Le thème E (Architectures matérielles et systèmes d’exploitation) correspond aux deux séquences

suivantes :
 Séquence 6 : Architecture et systèmes d’exploitation
 Séquence 7 : Réseaux et IHM
La séquence 6 ne nécessite pas d’avoir traité au préalable d’autre séquence du cahier.
A. Le programme
thème Architectures matérielles et systèmes d’exploitation seront traités dans la séquence 7.

Modèle Distinguer les rôles et les caractéristiques des différents Activités 1, 2, 7

d’architecture constituants d’une machine. p. 92-93, 98-99
séquentielle Dérouler l’exécution d’une séquence d’instructions
(von Neumann) simples du type langage machine. Exercices 1 et 9
p. 104 et 107
Systèmes Identifier les fonctions d’un système d’exploitation. Activités 2, 3, 4, 5,

d’exploitation Utiliser les commandes de base en ligne de commande. 6, 7
Gérer les droits et permissions d’accès aux fichiers. p. 93 à 97
Exercices 2, 3, 4, 5,
6, 7, 8
p. 104 à 107
115 Thème E  Séquence 6 Architectures matérielles et systèmes d’exploitation
04733901_p004-224.pdf 112 11/08/2021 14:50

QCMCam et aux formats PDF, PPT et ODP sur le site ressources : cahier-nsi.fr/#!/diagnostic/seq6 ou
Activité Les constituants d’une machine sont :

1
Réponses :
A. très différents entre un ordinateur fixe et un ordinateur portable.
B. très différents en fonction de la marque de l’ordinateur.
C. équivalents d’une machine à l’autre. (Bonne réponse.)
Activité Un logiciel libre :

2
Réponses :
A. est un logiciel gratuit.
B. est un logiciel pour lequel l’accès au code source est garanti. (Bonne réponse.)
C. est un logiciel propriétaire.
Activité Un système d’exploitation :

3
Réponses :
A. est un ensemble de programmes qui s’exécutent uniquement au démarrage d’un ordinateur.
B. est un ensemble de programmes qui dirige l’utilisation des ressources d’un ordinateur. (Bonne
réponse.)
C. est un ensemble de programmes qui est utile uniquement sur un smartphone.
Activité Lequel de ces systèmes d’exploitation est libre ?

3
Réponses :
A. Linux. (Bonne réponse.)
B. Windows.
C. iOS.
04733901_p004-224.pdf 113 11/08/2021 14:50

Histoire des Sciences p. 91 / Architecture matérielle (voir la correction à la fin de la partie C)
Cette activité présente succinctement l'évolution de l'architecture matérielle, de l'ENIAC, qui fut le
premier calculateur programmable, jusqu'au premier programme enregistré. La première illustration
permet d’insister sur la programmation par câblage, qui était longue et fastidieuse. Celle-ci était
réalisée par six femmes mathématiciennes. Pour corriger un bogue, il fallait reprendre le câblage de
cette machine imposante. L’objectif de cette machine était de faire du calcul balistique. L’utilisation
de l’ENIAC a permis de diviser par 400 le temps de calcul d’une trajectoire de tir.
Le modèle de von Neumann est vraiment important puisque les ordinateurs actuels suivent toujours
ses principes. Les constituants de la machine de von Neumann seront vus dans l’activité 1 p. 92 et son
fonctionnement sera étudié dans l’activité 7 p. 98-99.
Activité 1 p. 92 / Les constituants et les périphériques d’une machine

 Distinguer les rôles et les caractéristiques des différents constituants d’une machine.
Cette activité propose de découvrir les constituants d’une machine. C’est l’occasion de s’apercevoir
que l’élève ne maîtrise pas toujours les noms de ceux-ci ainsi que leurs rôles. L’utilisation de
l’ordinateur portable rend tous ces composants encore plus opaques. Les auteurs ont choisi de faire
différencier les périphériques d’entrée, de sortie et d’entrée/sortie afin que l’élève différencie bien les
deux fonctionnalités.
Activité 2 p. 93 / Système d’exploitation

 Systèmes d’exploitation : les différences entre systèmes d’exploitation libres et propriétaires sont
évoquées.
Cette activité propose de bien comprendre les enjeux du logiciel libre, comme évoqué dans le
programme officiel. Les questions 1 et 2 permettent à l’élève de différencier un logiciel libre et un
logiciel gratuit et l’absence de lien direct entre ces deux qualificatifs. Un logiciel libre peut être gratuit
ou payant. Un logiciel gratuit peut être libre ou non.
À partir de la question 3, le sujet se recentre sur les systèmes d’exploitation en expliquant rapidement
leur rôle. Le cours revient en détail sur les fonctions d’un système d’exploitation. En général, les seuls
systèmes d’exploitation que l’élève connaît sont propriétaires. La question 3 permet de leur montrer
qu’un système d’exploitation propriétaire n’est ni modifiable ni étudiable ni même améliorable.
04733901_p004-224.pdf 114 11/08/2021 14:50

L’objectif suivant de l’activité est de montrer à l’élève que tous les appareils informatiques ont un
système d’exploitation. Dans la plupart des cas, il s’agit d’un système d’exploitation Linux puisqu’il
est libre, donc modifiable, afin de s’adapter aux fonctionnalités de l’appareil.
Activité 3 p. 94 / Interface en ligne de commande de Linux

 Utiliser les commandes de base en ligne de commande.
Cette activité a pour objectif d’introduire le système d’exploitation Linux, avec son système de
fichiers et son interface en ligne de commande.
Après quelques manipulations de chemins absolus et relatifs sur les répertoires, l’élève est invité à
utiliser un émulateur Linux qui est disponible sur le site ressources élève. Aucune installation n’est
requise, il suffit de suivre le lien sur le site et d’être connecté à Internet. L’émulateur permet de saisir
toutes les commandes Linux classiques, dont celles nécessaires pour traiter le programme officiel.
Le login et le mot de passe renseignés dans le cahier permettent de traiter les droits et les permissions
sur les fichiers. Une vidéo explicative est disponible sur le site ressources enseignant (section
« Présentation des interfaces »). Le système de fichiers est déjà présent dans l’émulateur Linux dès son
lancement. Il est préparé et identique pour toutes les activités et tous les exercices. En appuyant sur la
touche F5, le système d’exploitation est relancé dans l’état d’origine. Les sources d’erreur peuvent
être : les espaces ajoutés ou oubliés, le sens des « / » et les majuscules manquantes ou
supplémentaires.
Activité 4 p. 95 / Commandes de base avec arguments (voir la correction à la fin de la partie C)

Cette activité permet d’aller plus loin dans la syntaxe des commandes de base avec l’introduction
d’arguments. Les différentes questions de l’activité permettent de créer des répertoires, déplacer,
copier et supprimer des fichiers et des répertoires avec des chemins relatifs et absolus. Il est conseillé
d’avoir traité au préalable l’exercice 2 p. 104 afin bien maîtriser les chemins relatifs et absolus.
Activité 5 p. 96 / Étude des droits et des permissions d’accès

 Gérer les droits et permissions d’accès aux fichiers.
Cette activité a pour objectif d’introduire les droits sur les fichiers et les répertoires en manipulant
l’émulateur Linux. Avant de les modifier, l’élève est guidé pour visualiser et comprendre les droits
d’un fichier et d’un répertoire du système de fichier de l’émulateur.
04733901_p004-224.pdf 115 11/08/2021 14:50

Activité 6 p. 97 / Modification des droits et des permissions d’accès
Cette activité permet de modifier les droits de fichiers et répertoires avec les deux syntaxes possibles.
Avec l’habitude, la syntaxe avec les valeurs en octale est très pratique. Même si elle n’est pas
explicitement au programme, les auteurs ont choisi de montrer l’option -R pour montrer l’intérêt de
travailler en ligne de commande.
Activité 7 p. 98 / Machine de von Neumann (voir la correction à la fin de la partie C)

 Dérouler l’exécution d’une séquence d’instructions simples du type langage machine.
Cette activité a pour objectif de dérouler l’exécution d’une séquence d’instructions assembleur 6502.
L’activité n’est pas simple mais s’appuie sur un processeur qui a été réellement utilisé. À la
question 1, la principale difficulté est de comprendre que, dans la deuxième colonne, la valeur en vert
est l’instruction et la valeur en orange représente le(s) opérande(s) éventuel(s). Sur la troisième ligne,
il n’y a pas d’opérande, donc la prochaine adresse est l’adresse 0x605 et non 0x606.
À la question 7, l’élève est invité à utiliser un émulateur processeur qui est disponible sur le site
ressources élève. Aucune installation n’est requise, il suffit de suivre le lien sur le site et d’être
connecté à Internet. L’émulateur permet de saisir toutes les instructions de ce langage. Une vidéo
explicative est disponible sur le site ressources enseignant (section « Présentation des interfaces »).
Avec cet émulateur, l’élève intéressé pourra aller plus loin que les notions vues dans cette activité.
04733901_p004-224.pdf 116 11/08/2021 14:50

04733901_p004-224.pdf 117 11/08/2021 14:50

04733901_p004-224.pdf 118 11/08/2021 14:50

04733901_p004-224.pdf 119 11/08/2021 14:50

04733901_p004-224.pdf 120 11/08/2021 14:50

04733901_p004-224.pdf 121 11/08/2021 14:50

04733901_p004-224.pdf 122 11/08/2021 14:50

04733901_p004-224.pdf 123 11/08/2021 14:50

04733901_p004-224.pdf 124 11/08/2021 14:50

04733901_p004-224.pdf 125 11/08/2021 14:50

 Distinguer les rôles et les caractéristiques des différents constituants d’une machine.
Cet exercice a pour seul objectif de revoir le vocabulaire des machines et des périphériques pour faire
le lien avec ce que l’élève côtoie dans son quotidien.

Cet exercice permet de manipuler les chemin relatifs et absolus sans l’émulateur afin de bien maîtriser
le changement de niveau avec la syntaxe .. .

Cet exercice propose de reconstruire le schéma du système de fichiers à partir des commandes qui ont
permis de le créer. L’énoncé permet également de retravailler les chemins relatifs et absolus.

Cet exercice propose de lister les commandes pour créer le système de fichiers illustré. Il est l’inverse
du précédent pour aider l’élève à s’approprier ces notions.

Cet exercice propose à la fois de lister les commandes à saisir et de faire le schéma du système de
fichiers à partir de besoins formulés sous forme de questions.
04733901_p004-224.pdf 126 11/08/2021 14:50

Cet exercice demande l’effet de commandes sur un système de fichiers. Même si l’énoncé est court, la
rédaction n’est pas si simple pour un élève. Le caractère *, tellement utile en ligne de commande, n’est
pas si facile à maîtriser pour l’élève.

Cet exercice propose de travailler les bases de la consultation et de la modification des droits sur les
fichiers et répertoires.
Cet exercice propose d’écrire les commandes à saisir pour modifier les droits sur le système de
fichiers, avec les deux syntaxes.

 Dérouler l’exécution d’une séquence d’instructions simples du type langage machine.
Cet exercice qui paraît court est relativement compliqué pour un élève. Il demande d’avoir bien
compris l’activité 7 p. 98.
04733901_p004-224.pdf 127 11/08/2021 14:50

04733901_p004-224.pdf 128 11/08/2021 14:50

04733901_p004-224.pdf 129 11/08/2021 14:50

04733901_p004-224.pdf 130 11/08/2021 14:50

04733901_p004-224.pdf 131 11/08/2021 14:50

04733901_p004-224.pdf 132 11/08/2021 14:50

Les corrections Python de ces mini-projets sont disponibles sur le site ressources et dans le manuel numérique
enseignant.
Proposition 1
Ce mini-projet propose d’écrire quatre commandes Linux complexes après avoir cherché le sur Web le
fonctionnement de deux opérateurs Bash. Ce mini-projet mêle les commande Linux, la
programmation, l’autonomie et la prise d’initiative. Il se rapproche de ce que l’on peut demander à un
informaticien : se documenter pour répondre à un besoin spécifique.
Proposition 2
Ce mini-projet a les mêmes qualités que le précédent puisqu’il demande à l’élève de se documenter sur
les instructions du processeur MOS 6502, puis de déterminer ce que fait le programme en déroulant
l’exécution d’une séquence d’instructions.
04733901_p004-224.pdf 133 11/08/2021 14:50

Thème E : Architectures matérielles
et systèmes d’exploitation
Séquence 7 Réseaux et IHM
Le thème E (Architectures matérielles et systèmes d’exploitation) correspond aux deux séquences

suivantes :
 Séquence 6 : Architecture et systèmes d’exploitation
 Séquence 7 : Réseaux et IHM
La séquence 7 ne nécessite pas d’avoir traité au préalable d’autre séquence du cahier. Elle nécessite
uniquement d’avoir revu les bases du langage Python (voir en pages 6 et 7 du cahier) et la
connaissance de la base hexadécimale de la séquence 1 pour traiter l’exercice 3 p. 122.
A. Le programme
thème Architectures matérielles et systèmes d’exploitation ont été traités dans la séquence 6.

Transmission de Mettre en évidence l’intérêt du découpage des données en Activités 1, 2 et 3

données dans un paquets et de leur encapsulation. p. 112 à 115
réseau Dérouler le fonctionnement d’un protocole simple de
Protocoles de récupération de perte de paquets (bit alterné). Exercices 1, 2, 3, 4,
communication Simuler ou mettre en œuvre un réseau. 5, 6, 7, 8
Architecture d’un p. 121 à 123
réseau
Périphériques Identifier le rôle des capteurs et actionneurs. Activité 4

d’entrée et de Réaliser par programmation une IHM répondant à un p. 116-117
sortie cahier des charges donné.
Interface Homme- Exercice 9
Machine (IHM) p. 123
137 Thème E  Séquence 7 Réseaux et IHM
04733901_p004-224.pdf 134 11/08/2021 14:50

dans le manuel numérique enseignant .
Activité À quoi sert un routeur ?

1
Réponses :
A. À augmenter le débit d’un réseau.
B. À assurer le transit des données de proche en proche afin que le message soit acheminé de la
source au destinataire. (Bonne réponse : définition vue en SNT.)
C. À sécuriser une connexion entre deux ordinateurs.
Activité Sur un réseau IP, les données transitent :

2
Réponses :
A. en flux continu de données.
B. en paquets de données. (Bonne réponse.)
C. en flux continu ou en paquets de données, cela dépend du protocole utilisé.
Activité Un protocole de communication est :

3
Réponses :
A. soit le protocole IP soit le protocole TCP puisqu’il n’y en a que deux.
B. un ensemble de règles qui permettent à tous les appareils connectés de communiquer ensemble.
(Bonne réponse.)
C. un ensemble de règles qui permettent uniquement aux ordinateurs de communiquer ensemble.
Activité L’ensemble TCP/IP :

3
Réponses :
A. assure la garantie temporelle puisque l’on peut prédire le temps que mettra un segment à
arriver à destination.
B. assure la fiabilité de transmission. (Bonne réponse.)
C. permet de rendre les communications confidentielles.
Activité Une IHM est :

4
Réponses :
A. une interface hautement matérialisée.
B. une interface qui rend la machine plus humaine.
C. une application qui permet la communication entre l’utilisateur et la machine. (Bonne réponse.)
04733901_p004-224.pdf 135 11/08/2021 14:50

Histoire des Sciences p. 111 / Le réseau Internet (voir la correction à la fin de la partie C)
Cette activité présente succinctement l’évolution du réseau Internet. Elle permet de faire le lien avec le
thème Internet vu en SNT, en revenant sur la fonction d’un routeur et les protocoles TCP et IP. La
commutation par paquets permet de ne pas monopoliser les routeurs pour toute la transmission, mais
uniquement pour la communication des paquets. Le lien peut être fait avec le routage vu en SNT et le
fait que plusieurs paquets de la même transmission peuvent suivre des chemins différents.
Le réseau Internet vient du réseau ARPANET qui a été conçu aux États-Unis grâce à d’importantes
subventions de l’agence gouvernementale américaine. En 1980, ARPANET est divisé en deux réseaux
distincts : le premier réseau est militaire et le deuxième est universitaire. En 1984, ces deux réseaux
sont composés d’environ 4 millions de nœuds et de plus de 1 000 ordinateurs dans le monde.
Le modèle OSI, qui sera réutilisé à l’activité 2 p. 113 pour travailler l’encapsulation, a été conçu dès
les années 1970. À cette époque, plusieurs modèles cohabitent. Ce n’est qu’en 1984 qu’il devient une
norme. Dans certains cas, la séparation entre les couches n’est pas si claire, comme entre les services
réseau et transport qui peuvent fonctionner en mode connecté. Pour retenir l’ordre des couches par
leurs initiales (P L R T S P A), un moyen mnémotechnique consiste à prendre les initiales des mots de
la phrase suivante : « Pour Le Réseau Tout Se Passe Automatiquement ».
Activité 1 p. 112 / Étude d’un réseau local (voir la correction à la fin de la partie C)
 Architecture d’un réseau.
Cette activité propose d’introduire le fonctionnement d’un réseau local sur le cas d’un lycée. Les
réseaux élève et enseignant sont séparés pour plus de sécurité. Dans le réseau élève, le lycée a deux
salles informatiques et un point d’accès élève pour les ordinateurs portables. Le réseau enseignant est
composé d’ordinateurs fixes pour les ordinateurs des enseignants de chaque salle de cours et d’un
point d’accès pour les ordinateurs portables. Il peut être intéressant de souligner que les réseaux sont
séparés, même si un ordinateur professeur est disposé dans une salle informatique.
Après avoir posé tout le vocabulaire associé, les élèves sont guidés pour faire des hypothèses sur
l’origine de diverses pannes classiques. Il est intéressant de montrer qu’un réseau comme celui-ci ne
comporte pas de redondance de routeurs et qu’une panne sur un routeur peut couper d’Internet un
grand nombre d’utilisateurs. Ce travail peut être prolongé avec l’étude du réseau du lycée de l’élève.
04733901_p004-224.pdf 136 11/08/2021 14:50

Activité 2 p. 113 / Découpage en paquets et encapsulation
 Mettre en évidence l’intérêt du découpage des données en paquets et de leur encapsulation.
Cette activité a pour objectif de travailler, dans un premier temps, le découpage en paquets et dans un
deuxième temps, leur encapsulation. Pour la communication par paquets, les deux schémas permettent
de découvrir les deux principaux avantages du découpage des données en paquets, en termes de
paquets perdus et en termes de monopolisation de routeurs et de liens.
Pour l’encapsulation des données, le schéma résume bien la notion à acquérir. L’enseignant peut faire
remarquer que toutes les couches du modèle OSI ne sont pas présentées ici, mais seulement celles qui
sont utiles. Cette activité est l’occasion de montrer que chaque couche ajoute un en-tête qui lui est
propre.
Activité 3 p. 114 / Le protocole du bit alterné (voir la correction à la fin de la partie C)

 Dérouler le fonctionnement d’un protocole simple de récupération de perte de paquets (bit alterné).
Cette activité a pour objectif de découvrir le protocole du bit alterné qui est une simplification du
mécanisme existant dans le protocole TCP. C’est l’occasion de mentionner à l’élève que le protocole
TCP est beaucoup plus complexe que ce qui a été vu en SNT.
Les auteurs ont choisi de présenter les cas à étudier comme dans les études supérieures en réseau.
Dans chaque cas, l’élève découvre le protocole et doit décrire le comportement de l’émetteur et/ou du
récepteur.
Des questions comme la question 4 sont importantes puisqu’elles permettent de découvrir si le

protocole est résistant à la perte de trame et d’acquittement, aux retards. La question 6 n’est pas facile
à traiter, mais montre une faiblesse de ce protocole.
La dernière question demande de compléter les algorithmes de ce protocole du côté émetteur et

également du côté récepteur. Les auteurs ont trouvé pertinent de résumer le comportement de
l’émetteur et du récepteur sous forme d’algorithme. En effet, un algorithme ne sert pas uniquement à
l’écriture de programme.
Cette activité est l’occasion de voir que même un protocole simple est relativement complexe à
travailler.
04733901_p004-224.pdf 137 11/08/2021 14:50

Activité 4 p. 116 / Réalisation d’une IHM (voir la correction à la fin de la partie C)
 Réaliser par programmation une IHM répondant à un cahier des charges donné.
La correction Python de cette activité est disponible sur le site ressources et dans le manuel numérique
enseignant.
Cette activité propose de réaliser la programmation d’une IHM en Python. C’est l’occasion de mettre
l’élève dans la peau d’un programmeur qui doit utiliser des fonctions déjà écrites. Elle permet
également de voir le vocabulaire (actionneur, capteur) de cette partie du programme officiel sur un cas
réel.
Cette activité ne peut être réalisée uniquement qu’à partir du programme de simulation proposé
puisque les fonctions listées dans le tableau sont déjà disponibles dans le module imprimante. L’élève
pourra se rendre compte que la qualité des descriptions des fonctions déjà implémentées est importante
pour s’en servir.
Une fois toutes les fonctions écrites dans la page dédiée, il est demandé à l’élève de les tester, puis de
vérifier que l’IHM correspond bien au cahier des charges. La programmation de deux autres IHM sera
proposée en mini-projet (p. 125).
04733901_p004-224.pdf 138 11/08/2021 14:50

04733901_p004-224.pdf 139 11/08/2021 14:50

04733901_p004-224.pdf 140 11/08/2021 14:50

04733901_p004-224.pdf 141 11/08/2021 14:50

04733901_p004-224.pdf 142 11/08/2021 14:50

04733901_p004-224.pdf 143 11/08/2021 14:50

04733901_p004-224.pdf 144 11/08/2021 14:50

04733901_p004-224.pdf 145 11/08/2021 14:50

Cet exercice relativement simple permet de réinvestir le vocabulaire vu à l’activité 1. Plusieurs mots
peuvent correspondre à un même équipement.

Cet exercice permet de faire formuler des hypothèses sur des pannes liées à un réseau local, comme
cela a déjà été fait à l’activité 2. Le cas du réseau domestique a pour objectif de montrer à l’élève qu’il
peut se servir des cours de NSI pour dépanner le réseau de son domicile.

Cet exercice propose d’identifier des adresses Ipv4 et MAC qui sont incorrectes en justifiant les
réponses. Il permet de revoir les problèmes liés aux encodages des entiers, avec l’utilisation de la base
décimale et de la base hexadécimale. Ce type de question est relativement récurrente dans les sujets
des épreuves communes.

Cet exercice propose d’identifier les commandes réseaux sur un système d’exploitation Linux. Il fait le
lien avec les commandes Linux de la séquence 6. Ce type de question est relativement récurrente dans
les sujets des épreuves communes.
04733901_p004-224.pdf 146 11/08/2021 14:50

 Protocoles de communication : le lien est fait avec ce qui a été vu en classe de Seconde sur le protocole
TCP/IP.
Comme dans le programme officiel il est mentionné de faire le lien avec le protocole TCP/IP, cet
exercice propose de relier chaque protocole à ses caractéristiques. Les auteurs ont choisi d’ajouter le
protocole DNS qui a été vu en SNT et le protocole HTTP qui a été vu en SNT et en NSI.

 Mettre en évidence l’intérêt du découpage des données en paquets et de leur encapsulation.
Cet exercice relativement simple permet de revoir l’encapsulation avec les protocoles connus des
élèves, afin de rendre ces notions un peu moins abstraites.

Cet exercice propose de cocher les différentes caractéristiques du protocole du bit alterné.

Cet exercice propose de répondre à deux cas concrets sur le protocole du bit alterné.

 Identifier le rôle des capteurs et actionneurs.
Cet exercice propose de réinvestir le vocabulaire lié à une IHM, en classant une liste en « capteur »,
« actionneur » et « actionneur et capteur ».
04733901_p004-224.pdf 147 11/08/2021 14:50

04733901_p004-224.pdf 148 11/08/2021 14:50

04733901_p004-224.pdf 149 11/08/2021 14:50

04733901_p004-224.pdf 150 11/08/2021 14:50

04733901_p004-224.pdf 151 11/08/2021 14:50

Proposition 1
Ce mini-projet propose de programmer une IHM pour créer un jeu de casse-brique en langage Python.
L’élève doit utiliser le lien mentionné dans le cahier pour accéder à une page déjà précomplétée. Il est
guidé afin d’utiliser des fonctions déjà écrites et des descriptions comme dans l’activité 4. Si les élèves
travaillent en groupes, ils peuvent se répartir les fonctions à écrire.
Le cahier des charges est donné en commentaire en haut de la page. Cette IHM doit être programmée
dans la page dédiée puisque le module game est déjà importé dans celle-ci et que ce module a été
développé uniquement pour cette IHM. Il n’est pas disponible dans un autre éditeur.
Proposition 2
La correction en langage Web de ce mini-projet est disponible sur le site ressources et le manuel numérique
enseignant.
Ce mini-projet a pour objectif de faire programmer une IHM en langages Web pour programmer un
jeu de tic-tac-toe. L’objectif de programmation est différent du mini-projet 1 puisque l’élève
programme en langage Web.
Avec le lien à disposition, l’élève télécharge un fichier avec un code déjà donné à compléter, ce qui peut
être intéressant pour se partager les fonctionnalités à ajouter au sein d’un groupe d’élèves. L’enseignant
peut choisir dans la liste des fonctionnalités proposées celles qu’il demande à faire à l’élève.
04733901_p004-224.pdf 152 11/08/2021 14:50

Thème F : Langages et programmation
Séquence 8 Langages et programmation
Le thème F (Langages et programmation) correspond à la séquence suivante :

 Séquence 8 : « Langages et programmation »
La séquence 8 ne nécessite pas d’avoir traité au préalable de séquence en particulier.
A. Le programme
Contenus Capacités attendues du BO Activités / Exercices

Constructions Mettre en évidence un corpus de constructions Activité 1 p. 128

élémentaires élémentaires.
Exercices 1 et 2 p. 135
Diversité et unité Repérer, dans un nouveau langage de Activité 2 p. 129

des langages de programmation, les traits communs et les traits
programmation particuliers à ce langage. Exercice 3 p. 136
Spécification Prototyper une fonction. Activité 3 p. 130

Décrire les préconditions sur les arguments.
Décrire des postconditions sur les résultats. Exercice 4 p. 136
Mise au point de Utiliser des jeux de tests. Activité 4 p. 131

programmes
Exercice 6 p. 137
Utilisation de Utiliser la documentation d’une bibliothèque. Activité 3 p. 130

bibliothèques
Exercice 5 p. 137
156 Thème F  Séquence 8 Langages et programmation
04733901_p004-224.pdf 153 11/08/2021 14:50

et sur le manuel numérique enseignant.
Activité Dans la majorité des langages de programmation, pensez-vous que l’on retrouve les mêmes
1 constructions élémentaires (boucle bornée, boucle non bornée, instruction conditionnelle, …) ?
Réponses :
A. Oui. (Bonne réponse.)
B. Non.
Activité Pensez-vous que l’indentation en Python est la seule façon de délimiter des boucles dans les autres
2 langages de programmation ?
Réponses :
A. Oui.
B. Non. (Bonne réponse : en JavaScript, ce sont des accolades.)
Activité Pour pouvoir réutiliser des fonctions Python déjà écrites, pensez-vous intéressant de donner des
3 informations comme le domaine de valeurs valide des arguments en entrée d’une fonction ?
Réponses :
B. Non.
Activité Pour une fonction Python de quelques lignes, pensez-vous qu’il soit pertinent d’écrire une
4 fonction de test ?
Réponses :
B. Non.

Histoire des Sciences p. 127 / Les langages de programmation
Cette activité présente succinctement l’évolution des langages de programmation. La distinction entre
les langages de bas niveau et de haut niveau est d’autant plus intéressante que la programmation en
langage machine est au programme officiel. Dans la séquence 6, l’élève a pu/pourra s’apercevoir de la
complexité de programmer dans un langage machine, avec le langage assembleur. Il comprendra
facilement que les langages très bas niveau étaient réservés aux experts. En langage BASIC, faire une
boucle n’était pas si simple, comme on peut le voir sur l’illustration.
04733901_p004-224.pdf 154 11/08/2021 14:50

Les auteurs ont choisi de mentionner le langage C qui est incontournable. Même si c’est un langage
ancien en comparaison au langage Python, il est toujours très utilisé de nos jours. Comme il est de bas
niveau, il permet de contrôler finement ce que fait la machine, comme la mémoire ou la charge de
calcul.
Les paradigmes de programmation sont introduits et seront retravaillés en Terminale puisqu’ils sont au
programme officiel.
Activité 1 p. 128 / Constructions élémentaires (voir la correction à la fin de la partie C)

 Mettre en évidence un corpus de constructions élémentaires.
Cette activité permet de mettre en place tout le vocabulaire des constructions élémentaires.
Les fonctions sont relativement simples afin que l’élève ne soit pas perturbé par celles-ci.
La question 2 est importante puisqu’elle invite l’élève à faire la distinction entre une boucle bornée et
une boucle non bornée, très utile en étude de la complexité algorithmique. Ces fonctions seront
réutilisées dans l’activité 2 p. 129 afin de comparer la syntaxe du langage Python et la syntaxe du
langage JavaScript.
Activité 2 p. 129 / Comparer deux langages de programmation

 Repérer, dans un nouveau langage de programmation, les traits communs et les traits particuliers à ce
langage.
Cette activité propose de comparer deux langages de programmation. Les auteurs ont choisi de
comparer le langage Python au langage JavaScript qui est également au programme officiel. L’élève
remarque des similitudes comme certains mots-clés.
Le JavaScript permet de montrer que les accolades peuvent servir à délimiter des blocs d’instructions
et que l’indentation n’est pas prise en compte dans ce langage, il sert uniquement à rendre le code
lisible. La version 2 de la fonction maximum devrait être assez parlante pour convaincre les élèves de
l’utilité d’utiliser l’indentation même si elle n’est pas dans la syntaxe du langage. C’est l’occasion de
parler du fait que, dans beaucoup de langages de programmation, les variables doivent être déclarées et
même typées.
La comparaison des fonctions des bibliothèques des langages permet de toucher du doigt le fait que les
bibliothèques dépendent des langages et que l’on ne retrouve pas forcément les mêmes fonctions d’un
langage à l’autre.
En conclusion de cette activité, l’élève peut être sensibilisé au fait qu’un développeur expert dans un
langage peut programmer dans un autre langage (de même paradigme) en s’adaptant à la syntaxe et
aux bibliothèques du nouveau langage.
04733901_p004-224.pdf 155 11/08/2021 14:50

Activité 3 p. 130 / Prototypage d’une fonction
 Prototyper une fonction.
 Décrire les préconditions sur les arguments.
 Décrire des postconditions sur les résultats.
 Utiliser la documentation d’une bibliothèque.
Cette activité permet de découvrir le prototypage d’une fonction. Le tableau à compléter permet de
s’interroger sur les préconditions sur les arguments et les postconditions sur les résultats. L’enseignant
peut insister sur ces réflexions préliminaires à l’écriture d’une fonction afin qu’elle puisse s’adapter à
tous les cas et répondre au problème. Toutes ces informations sont également utiles pour réutiliser une
fonction déjà écrite par le même programmeur ou par quelqu’un d’autre.
À partir de la question 3, les assertions sont introduites et le questionnement permet de comprendre

son intérêt. C’est l’occasion de montrer à l’élève qu’il s’agit d’une bonne habitude à prendre dès
maintenant puisqu’elle est demandée à l’épreuve pratique de Terminale.
La question 7 permet de faire le lien avec le prototypage des fonctions des modules, particulièrement
utile pour utiliser une fonction écrite par un autre programmeur.
Activité 4 p. 131 / Utiliser des jeux de tests (voir la correction à la fin de la partie C)
 Utiliser des jeux de tests.
Cet exercice propose de travailler des jeux de test avec une fonction de test à part entière qui est plus
longue que la fonction à tester. Dans une entreprise, l’écriture de test est une activité à part entière.
Certains tests peuvent être automatisés afin de faciliter ce type de travail. Un « adage » que les auteurs
de ce cahier répètent souvent aux élèves : « Un programme qui n’est pas testé ne fonctionne pas. »
La question 2 permet de vérifier que la fonction est correcte.
À la question 3, l’élève s’aperçoit que seulement deux cas sont testés et que la fonction de test ne
détecte pas le bogue pour la valeur 100.
La question 5 permet de souligner que la fonction de test n’est pas suffisante car elle ne permet pas de
tester le cas pour la valeur 100.
La question 6 permet de souligner qu’une fonction ne peut pas tester toutes les valeurs possibles en
entrée et que les tests doivent être bien réfléchis afin d’être utiles.
La question 8 permet de montrer que l’utilisation d’une fonction de test permet de se prémunir de la
non-régression. En effet, en modifiant une partie d’un programme, on peut dégrader des
fonctionnalités qui étaient correctes.
04733901_p004-224.pdf 156 11/08/2021 14:50

04733901_p004-224.pdf 157 11/08/2021 14:50

04733901_p004-224.pdf 158 11/08/2021 14:50

04733901_p004-224.pdf 159 11/08/2021 14:50

04733901_p004-224.pdf 160 11/08/2021 14:50

04733901_p004-224.pdf 161 11/08/2021 14:50

Cet exercice a pour objectif de faire réutiliser le vocabulaire de certaines constructions élémentaires.
La question 2 permet d’utiliser un tableau pour voir l’évolution des variables de la boucle bornée.

Cet exercice a pour objectif de bien fixer la différence entre une boucle bornée et une boucle non
bornée. L’idée est de transformer une boucle bornée par une boucle non bornée sans changer de
langage de programmation. L’élève s’aperçoit que l’on peut toujours transformer une boucle bornée
par une boucle non bornée en réfléchissant bien à la condition d’arrêt de la boucle non bornée.
On pourrait alors programmer sans jamais faire de boucle bornée. Le lien avec les complexités d’un
parcours total et d’un parcours partiel d’un tableau (vus à la séquence 9 p. 151) peut être fait. Pour la
complexité, le parcours partiel d’un tableau est à privilégier, ce qui est encore un argument pour éviter
l’utilisation d’une boucle bornée. En réalité, la boucle bornée est souvent plus intuitive à programmer.
En revanche, réécrire une boucle non bornée en boucle bornée n’est pas toujours possible puisque l’on
ne sait pas forcément au préalable combien de fois il faut faire le calcul contenu dans la boucle non
bornée.

 Repérer, dans un nouveau langage de programmation, les traits communs et les traits particuliers à ce
langage.
Cet exercice propose de comparer le langage Python au langage C. Le choix du langage C n’a pas été
motivé par son histoire ou son omniprésence, mais par ses caractéristiques. En langage C, les
accolades permettent de délimiter les blocs d’instructions, ce qui permet de faire comprendre à l’élève
que c’est souvent le cas et que la délimitation de blocs d’instructions par indentation est peu courant
dans les autres langages de programmation.
Le langage C est l’occasion de montrer un langage dans lequel des variables sont déclarées à la
première utilisation et sont même typées. Même le type de variable renvoyée par une fonction est typé.
Le travail du prototypage en langage C est indispensable pour écrire une fonction et surtout le
compilateur en a besoin pour compiler.
04733901_p004-224.pdf 162 11/08/2021 14:50

Le langage C a aussi besoin d’un séparateur de fin d’instruction qui est le point-virgule. L’élève
pourra vite se rendre compte de la rigueur nécessaire pour ne pas oublier les points-virgules en fin de
ligne. Toutefois, ce n’est pas la principale difficulté liée à la programmation de ce langage de bas
niveau qui fait du langage C un langage difficile à prendre en main mais très utile, puisqu’il a été
conçu pour écrire le système d’exploitation Unix.

 Prototyper une fonction.
 Décrire les préconditions sur les arguments.
 Décrire des postconditions sur les résultats.
Cet exercice permet de retravailler le prototypage d’une fonction, puis d’écrire les préconditions sur
les arguments et les postconditions sur les résultats sur un exemple de notes qui devrait parler aux
élèves.
La question 3 permet d’écrire la fonction Python demandée avec les assertions sur les préconditions et
les postconditions.

 Utiliser la documentation d’une bibliothèque.
Cet exercice propose de travailler sur des bibliothèques JavaScript et Python.
La question 1 permet d’afficher la documentation d’une fonction Python. La question 2 permet de

comparer des fonctions Python et JavaScript de bibliothèques afin de faire remarquer à nouveau à
l’élève que les bibliothèques dépendent du langage de programmation.

 Utiliser des jeux de tests.
Les corrections Python de cet exercice sont disponibles sur le site ressources et sur le manuel numérique
enseignant.
Cet exercice propose de travailler les jeux de tests avec une fonction qui ne teste pas tous les cas, donc
qui indique seulement que la fonction est correcte sur certains cas. D’autres cas qui n’ont pas été testés
génèrent un bogue. L’élève revoit ainsi que tester une fonction permet de valider certains cas et qu’il
faut bien réfléchir à l’écriture des tests, sur les cas particuliers ou difficiles, pour valider réellement
une fonction.
04733901_p004-224.pdf 163 11/08/2021 14:50

04733901_p004-224.pdf 164 11/08/2021 14:50

04733901_p004-224.pdf 165 11/08/2021 14:50

04733901_p004-224.pdf 166 11/08/2021 14:50

04733901_p004-224.pdf 167 11/08/2021 14:50

Les corrections Python de ces mini-projets sont disponibles sur le site ressources et sur le manuel numérique
enseignant.
Proposition 1
Ce mini-projet propose d’écrire une bibliothèque de fonctions Python, appelée également module,
avec les assertions sur les préconditions et les postconditions de trois situations variées relativement
simples, ce qui permet de se concentrer sur l’écriture des assertions.
Proposition 2
Ce mini-projet propose d’écrire une autre bibliothèque de fonctions Python, appelée également
module, avec les assertions sur les préconditions et les postconditions de conversions relativement
simples, ce qui permet de se concentrer sur l’écriture des assertions.
La dernière question demande de tester les fonctions écrites avec une bibliothèque de test unitaire déjà
écrite dans un module Python.
04733901_p004-224.pdf 168 11/08/2021 14:50

Thème G : Algorithmique
Séquence 9 Les bases de l’algorithmique
Le thème G (Algorithmique) correspond aux deux séquences suivantes :

 Séquence 9 : Les bases de l’algorithmique
 Séquence 10 : Algorithmique avancée
La séquence 9 nécessite d’avoir traité au préalable la séquence 3 puisqu’elle fait référence aux notions
de listes et de p-uplets en Python.
A. Le programme
thème Algorithmique seront traités dans la séquence 10.

Parcours Écrire un algorithme de recherche d’une occurrence sur Activités 3, 4

séquentiel d’un des valeurs de type quelconque. p. 144-145
tableau Écrire un algorithme de recherche d’un extremum, de
calcul d’une moyenne. Exercices 5, 6, 7,
On montre que le coût est linéaire. 8, 9 p. 156-157
Tris par insertion, Écrire un algorithme de tri. Décrire un invariant de boucle Activités 5, 6
par sélection qui prouve la correction des tris par insertion, par p. 146-149
sélection.
La terminaison de ces algorithmes est à justifier. Exercices 10, 11,
On montre que leur coût est quadratique dans le pire cas. 12, 13, 14, 15
p. 158-159
172 Thème G  Séquence 9 Les bases de l’algorithmique
04733901_p004-224.pdf 169 11/08/2021 14:50

QCMCam et aux formats PDF, PPT et ODP sur le site ressources : cahier-nsi.fr/#!/diagnostic/seq9.
Activité Quelle est la particularité essentielle d’une boucle « tant que » ?

1
Réponses :
A. On sait à l’avance combien de tours de boucle vont être effectués.
B. Il est possible de faire une infinité de tours. (Bonne réponse : la condition peut toujours être
vraie.)
C. Au moins un tour de boucle est effectué.
Activité Pour trouver la valeur maximale d’un tableau composé de n nombres entiers :
3
Réponses :
A. Il faut parcourir le tableau n fois.
B. Il faut parcourir le tableau partiellement.
C. Il faut parcourir le tableau en totalité. (Bonne réponse : la valeur maximale peut être à la fin du
tableau.)
Activité Pour trouver la valeur moyenne d’un tableau composé de n nombres entiers :
3
Réponses :
B. Il faut parcourir le tableau en totalité. (Bonne réponse : toutes les valeurs du tableau sont
utilisées pour calculer une moyenne.)
C. Il faut parcourir le tableau partiellement.
Activité Pour savoir si un nombre entier est présent dans un tableau de n nombres entiers :
4
Réponses :
B. On peut parcourir le tableau partiellement. (Bonne réponse : le nombre entier recherché peut
être au début du tableau.)
C. Il faut parcourir le tableau en totalité.
Activité Pour compter combien de fois un nombre entier est présent dans un tableau de n nombres entiers :
4
Réponses :
B. Il faut parcourir le tableau partiellement.
C. Il faut parcourir le tableau en totalité. (Bonne réponse : une occurrence du nombre entier
recherché peut être à la fin du tableau.)
Activité Pour trier un tableau de nombres entiers dans l’ordre décroissant :

5
Réponses :
A. Il faut ranger les nombres entiers du plus petit au plus grand.
B. Il faut ranger les nombres entiers du plus grand au plus petit. (Bonne réponse.)
04733901_p004-224.pdf 170 11/08/2021 14:50

Histoire des Sciences p. 141 / De l’algorithme au langage de programmation
 Distinguer algorithme et programme.
Cette activité présente succinctement l’évolution du concept d’algorithme jusqu’au concept de

programme, afin de bien les différencier.
En effet, les premières traces d’algorithmes remontent à l’ère mésopotamienne (1800 à 1600
avant J.-C.) tandis que le premier programme a été écrit par la comtesse Ada de Lovelace en 1843.
Les cartes perforées sont un des ancêtres des programmes informatiques : elles pouvaient contenir la
liste des instructions qu’une machine doit exécuter, comme par exemple un métier à tisser Jacquard ou
encore le premier ordinateur programmable, le Harvard Mark 1.
Activité 1 p. 142 / De l’algorithme au programme (voir la correction à la fin de la partie C)

 Dérouler à la main un algorithme comportant une boucle non bornée.
 Comprendre le rôle joué par la condition d’arrêt dans une boucle non bornée.
 Écrire un premier algorithme en pseudo-code.
La correction Python de la question 4 est disponible sur le site ressources et sur le manuel numérique enseignant.
Cette activité propose de faire évoluer un algorithme de l’organigramme jusqu’au programme.

L’algorithme choisi est le calcul du PGCD de deux nombres entiers imaginé par Euclide. Cet
algorithme est novateur car Euclide y introduit le concept de boucle « tant que », avec une suite
d’itérations successives. Tant que le reste de la division euclidienne n’est pas nul, on effectue les
instructions de la boucle « tant que ».
C’est également l’occasion de revoir la division euclidienne et d’introduire l’opérateur Python %.
L’écriture d’un algorithme en pseudo-code est une étape importante de cette séquence. Il est important
que les élèves différencient l’algorithme du programme. Dans cette séquence, les algorithmes seront
toujours écrits en pseudo-code, tandis que les programmes seront toujours écrits en langage Python.
Cette activité propose d’adopter des règles d’écriture d’un algorithme en pseudo-code ; par exemple,
les auteurs ont choisi d’indenter le contenu d’une boucle ou d’une structure conditionnelle afin que
l’algorithme ressemble le plus possible à un programme écrit en langage Python.
Une fois l’algorithme écrit, l’élève pourra écrire le programme Python correspondant dans la console
Python, disponible sur le site ressources des Éditions Bordas, ou utiliser l’éditeur de son choix.
Il est important de faire tester un programme par l’élève en lui faisant subir un jeu de tests, comme
nous l’avons vu à la séquence 8. Par exemple, pgcd(48, 36) doit renvoyer 12 et pgcd(782, 221)
doit renvoyer 17.
04733901_p004-224.pdf 171 11/08/2021 14:50

Activité 2 p. 143 / Performance et coût d’un algorithme
 Introduire la notion de coût d’un algorithme.
Cette activité propose d’aborder le concept de coût d’un algorithme qui sera rapidement appelé
complexité. Le terme de complexité est celui utilisé dans l’enseignement supérieur.
Deux algorithmes permettent de calculer 𝑥 𝑛 . L’algorithme 1 a un coût linéaire, tandis que

l’algorithme 2 a un coût logarithmique. La fonction logarithme n’étant abordée qu’en spécialité
mathématiques de la classe de Terminale, il conviendra peut-être d’introduire succinctement l’intérêt
de la fonction log(𝑥).
Le tableau de la question 3 peut être rempli intuitivement en s’interrogeant sur le nombre de tours
nécessaires pour calculer 𝑥 𝑛 . La valeur 13 peut être obtenue à la main : il faut 13 itérations pour
obtenir 0 en calculant les quotients successifs de la division euclidienne (ou entière) de 5 000 par 2.
En effet, on ne garde que le quotient de la division euclidienne, comme indiqué dans l’algorithme
(n ← n // 2) :
5 000 – 2 500 – 1 250 - 625 – 312 - 156 - 78 - 39 - 19 - 9 - 4 - 2 - 1 - 0
L’application « Complexité » proposée permet de représenter graphiquement les courbes souhaitées

afin de les comparer visuellement entre elles : l’élève appréhendera mieux le concept de coût d’un
algorithme en le reliant à la représentation graphique des fonctions : plus la courbe est pentue, plus
cela coûte cher en temps. Cette activité est très importante car elle introduit le concept de coût qui sera
repris dans toutes les activités suivantes.
Activité 3 p. 144 / Recherche d’un extremum et calcul d’une moyenne

 Écrire un algorithme de recherche d’un extremum, de calcul d’une moyenne.
Les algorithmes de recherche d’un extremum et de calcul d’une moyenne nécessitent un parcours total
du tableau de 𝑛 éléments et ont donc un coût linéaire. La notation mathématique grand 𝑂 est
introduite. Un coût linéaire est ainsi simplement qualifié de 𝑂(𝑛), sans entrer dans le détail.
Une fois l’algorithme de recherche de la valeur maximale écrit sur le cahier ou au tableau, il sera
pertinent de le modifier avec un stylo de couleur pour le « transformer » en algorithme de recherche de
la valeur minimale. Il faudra insister sur l’importance de bien nommer les variables utilisées afin de
rendre l’algorithme (et donc le futur programme Python) le plus explicite possible.
L’implémentation en Python sera faite soit en classe soit en exercice à la maison. Des tests seront
effectués afin de vérifier que le programme écrit a bien le comportement attendu.
De la même manière, l’algorithme de calcul d’une moyenne a une complexité en 𝑂(𝑛). Sa structure
ressemble aux deux algorithmes précédents et le parcours est total. Il sera judicieux de faire remarquer
que le coût est linéaire, et que la terminaison de l’algorithme est facile à prouver de par l’utilisation de
la boucle bornée « pour ».
04733901_p004-224.pdf 172 11/08/2021 14:50

Activité 4 p. 145 / Parcours séquentiel total ou partiel d’un tableau
 Écrire un algorithme de recherche d’une occurrence sur des valeurs de type quelconque.
Les algorithmes de parcours et de recherche nécessitent l’emploi d’une structure conditionnelle à

l’intérieur d’une boucle « pour » pour le comptage d’occurrences et à l’intérieur d’une boucle « tant
que » pour la recherche d’une occurrence particulière dans le tableau.
L’écriture en pseudo-code devrait faire apparaître cette double indentation : il faut indenter pour
rentrer dans la boucle et indenter à nouveau pour rentrer dans la structure conditionnelle.
L’algorithme de recherche nécessite un booléen et l’évaluation de l’expression booléenne

tant que trouvé = Faux et i < longueur(tableau). C’est là l’occasion de faire le lien avec
l’évaluation d’une expression booléenne vue à la séquence 2.
C’est également l’occasion d’introduire la terminaison d’un algorithme et le concept de variant de

boucle, avant d’aborder les tris.
Activité 5 p. 146 / Tri par sélection (voir la correction à la fin de la partie C)

 Écrire un algorithme de tri par sélection.
 Décrire un invariant de boucle qui prouve la correction des tris par sélection.
Les corrections Python des questions 7, 8 et 9, ainsi que la correction dans l’interface « Modélisation » de la
question 11, sont disponibles sur le site ressources et sur le manuel numérique enseignant.
Pour cette activité, il est possible de distribuer aux élèves des cartes à jouer (ou en photocopiant les
8 cartes trèfle d’un jeu de cartes à jouer, par exemple) et de les laisser chercher en groupe une manière
de trier les cartes. Souvent, un ou deux groupes proposent spontanément le tri par insertion ou le tri par
sélection.
Une application de tri est également proposée en ligne pour se familiariser avec le principe du tri par
sélection avant de continuer l’activité.
L’algorithme proposé enregistre au fil du parcours l’indice de la carte la plus petite, et non pas sa
valeur. L’échange éventuel sera effectué en fin de tour de boucle, puisque l’indice de la carte la plus
petite est connu.
L’écriture de l’algorithme en pseudo-code n’est pas aisée et les nombreuses indentations devront être
respectées lors de la copie de l’algorithme dans le cahier.
C’est ici l’occasion de revoir le concept d’invariant de boucle afin de montrer que l’algorithme est
partiellement correct, c’est-à-dire qu’il effectue bien le travail attendu (partie « Correction partielle de
l’algorithme). Les élèves doivent être guidés car cette partie de l’activité est délicate. Il est pertinent de
rappeler qu’il est souvent difficile de trouver un invariant de boucle qui convienne.
04733901_p004-224.pdf 173 11/08/2021 14:50

L’activité se poursuit par une détermination expérimentale de la complexité (ou coût) du tri par
sélection. Par des tris successifs sur des tableaux de tailles variables, dont on mesure les durées
d’exécution à l’aide du module time, des données expérimentales peuvent être obtenues pour tracer
𝑡(𝑛) en fonction de la taille du tableau à trier. La modélisation proposée dans l’application
« Modélisation » permettra de mettre en évidence une complexité quadratique, en 𝑂(𝑛²). Un lien
pourra être fait avec la présence de deux boucles imbriquées. Les valeurs du tableau de la question 10
dépendent du tableau trié.
Activité 6 p. 148 / Tri par insertion (voir la correction à la fin de la partie C)

 Écrire un algorithme de tri par insertion.
 Décrire un invariant de boucle qui prouve la correction des tris par insertion.
Les corrections Python des questions 8, 9 et 10, ainsi que la correction dans l’interface « Modélisation » de la
question 12, sont disponibles sur le site ressources et sur le manuel numérique enseignant.
Pour cette activité, il est possible de distribuer aux élèves des cartes à jouer (ou en photocopiant les
8 cartes cœur d’un jeu de cartes à jouer, par exemple) et de les laisser chercher en groupe une manière
de trier les cartes. Souvent, un ou deux groupes proposent spontanément le tri par insertion ou le tri par
sélection.
Une application de tri est également proposée en ligne pour se familiariser avec le principe du tri par
insertion avant de continuer l’activité.
L’écriture de l’algorithme en pseudo-code n’est pas aisée et les nombreuses indentations devront être
respectées lors de la copie de l’algorithme dans le cahier.
La terminaison de l’algorithme sera abordée car la boucle « tant que » pourrait ne jamais se terminer.
C’est l’occasion de réinvestir la notion de variant de boucle, découverte à la question 6 de l’activité 4
p. 145.
Le concept d’invariant de boucle est revu afin de montrer que l’algorithme est partiellement correct
(partie « Correction partielle de l’activité »). Les élèves doivent être guidés car cette partie de l’activité
est délicate. Il est pertinent de rappeler qu’il est souvent difficile de trouver un invariant de boucle qui
convienne.
L’activité se poursuit par une détermination expérimentale de la complexité (ou coût) du tri par
insertion. Il s’agit ici d’effectuer des tris successifs sur des tableaux de tailles variables, au cours
desquels on compte le nombre de comparaisons entre deux valeurs du tableau à trier.
La méthode expérimentale présentée ici est volontairement différente de celle mise en œuvre pour le
tri par sélection (où la mesure de durées d’exécution a été effectuée avec le module time). Elle
consiste à faire compter par le programme le nombre de comparaisons en fonction de la taille du
tableau à trier. Les valeurs du tableau de la question 11 dépendent des valeurs des tableaux triés.
04733901_p004-224.pdf 174 11/08/2021 14:50

04733901_p004-224.pdf 175 11/08/2021 14:50

04733901_p004-224.pdf 176 11/08/2021 14:50

04733901_p004-224.pdf 177 11/08/2021 14:50

04733901_p004-224.pdf 178 11/08/2021 14:50

04733901_p004-224.pdf 179 11/08/2021 14:50

04733901_p004-224.pdf 180 11/08/2021 14:50

04733901_p004-224.pdf 181 11/08/2021 14:50

04733901_p004-224.pdf 182 11/08/2021 14:50

04733901_p004-224.pdf 183 11/08/2021 14:50

 Classer des complexités par ordre croissant de temps d’exécution.
L’utilisation de l’application « Complexité » proposée permet de représenter graphiquement les

courbes des fonctions les plus connues depuis log(𝑛) jusqu’à 𝑛 !. La représentation visuelle est idéale
pour comparer rapidement deux fonctions entre elles en les cochant/décochant, déterminer laquelle
domine l’autre, et pour quelles valeurs de 𝑛.
La croissance rapide d’une courbe sera reliée à une augmentation de la complexité de l’algorithme.

 Estimer et comparer des durées d’exécution.
Cet exercice permet de comparer les durées d’exécution en fonction de la complexité de l’algorithme
utilisé. Une durée de 32 ans pour une complexité 𝑂(𝑛3 ) comparée à 16 min pour 𝑂(𝑛²) justifie
parfaitement l’intérêt porté aux calculs de complexité algorithmique.
Le calcul d’itinéraire pour un GPS embarqué (question 3) est une belle illustration de la nécessité
d’effectuer des calculs de route rapidement, afin de trouver le chemin à suivre dans un temps
raisonnable, c’est-à-dire avant d’atteindre la prochaine intersection.

 Implémenter un algorithme avec le langage Python.
 Mesurer une durée d’exécution avec le module time.
 Comparer des durées d’exécution.
Les corrections Python des questions 1, 2 et 3 sont disponibles sur le site ressources et sur le manuel numérique
enseignant.
Cet exercice propose d’implémenter les deux algorithmes de l’activité 2 p. 143. La mesure des durées
d’exécution d’un même calcul de 𝑥 𝑛 avec les deux algorithmes différents permet de confirmer que
l’algorithme n° 2 est beaucoup plus performant que l’algorithme n° 1 pour calculer 2500 000 (2,0 ms
contre 7,7 s, sur l’ordinateur utilisé).
04733901_p004-224.pdf 184 11/08/2021 14:50

 Comparer des durées d’exécution.
Cet exercice propose de choisir entre un processeur plus rapide ou un algorithme plus performant. Les
calculs montrent qu’il faut choisir la deuxième solution, qui est plus rapide dès que 𝑛 > 6 312.
La détermination d’un rang 𝑛 montre que ces questions de complexité prennent tout leur sens dès que
les nombres à traiter deviennent très grands et que les durées d’exécution s’allongent, jusqu’à atteindre
des durées très longues à l’échelle humaine.

Cet exercice propose de trouver une erreur dans un algorithme écrit en pseudo-code. Il s’agit de l’oubli
de l’incrémentation de 𝑖 dans la boucle « tant que », qui n’est pas automatique, contrairement à la
boucle « pour ».

 Écrire un algorithme de calcul d’une moyenne.
Les corrections Python, ainsi que la correction dans l’interface « Modélisation » de la question 2, sont
disponibles sur le site ressources et sur le manuel numérique enseignant.
Pour la question 1, en utilisant l’éditeur Python Bordas, le fichier data.csv est déjà importé. Il suffit
d’appeler la fonction affiche_points().
Cet exercice propose d’implémenter en langage Python l’algorithme de recherche du minimum et du

maximum dans un tableau de nombres entiers.
Il est également possible de représenter graphiquement le nombre de vues de la chaîne YouTube étudiée
en fonction du temps, en utilisant le module matplotlib ou avec l’application « Modélisation ».
04733901_p004-224.pdf 185 11/08/2021 14:50

 Écrire un algorithme de recherche d’un extremum, de calcul d’une moyenne.
enseignant.
Cet exercice propose d’implémenter en langage Python les différents algorithmes découverts à
l’activité 3 p. 144 (recherche d’extremum et calcul d’une moyenne). À la question 4, il est suggéré de
réutiliser les fonctions maximum(L) et minimum(L) déjà écrites précédemment dans une logique de
programmation fonctionnelle.

enseignant.
Cet exercice propose d’implémenter en langage Python des fonctions de recherche d’occurrences et de
comptage de caractères alphabétiques. Les exercices précédents ont opéré sur des tableaux d’entiers et
cet exercice permet d’utiliser le type str.

enseignant.
Cet exercice propose d’implémenter en langage Python des fonctions de recherche d’occurrences et de
comptage de caractères alphabétiques. Pour compter les lettres identiques d’une fable, le fichier
fable.py a déjà été formaté de manière à n’afficher que des lettres e, et non pas les é, è ê ou É.
La question 5 propose d’utiliser un dictionnaire, qui est une structure de donnée particulièrement
adaptée pour faire un comptage par catégorie : pour toute nouvelle occurrence de lettre trouvée, on
ajoute une entrée au dictionnaire, et si la lettre est déjà présente dans le dictionnaire, on met à jour la
valeur associée.
La question 6 est plus complexe puisqu’elle propose d’écrire une fonction qui déchiffre
automatiquement un message chiffré à l’aide du chiffre de César. Le décalage doit être trouvé en
recherchant la lettre la plus présente dans le texte, soit la lettre e. Le texte utilisé pour déchiffrer doit
donc être assez long de manière à ce que les fréquences calculées soient représentatives des fréquences
usuelles de la langue française.
04733901_p004-224.pdf 186 11/08/2021 14:50

 Écrire un algorithme de tri.
enseignant.
Cet exercice met en œuvre un tri par sélection. L’opérateur < permet de classer deux chaînes de
caractères selon l’ordre du dictionnaire, encore appelé ordre lexicographique.
Il est donc possible d’adapter le programme de tri pour qu’il trie une liste de caractères alphabétiques.

 Écrire un algorithme de recherche.
Pour déterminer si un tableau est déjà trié, il suffit de le parcourir à l’aide d’une boucle non bornée.
En comparant deux à deux les lettres successives, on interrompt le parcours à la première irrégularité
rencontrée. Dans le pire des cas, le tableau sera donc parcouru en entier et la fonction booléenne
renverra True.

 Justifier la terminaison d’un algorithme.
Cet exercice revient sur le concept de variant de boucle. Pour montrer la terminaison de la boucle non
bornée (boucle « tant que »), il faut exhiber un entier naturel qui décroît strictement à chaque tour de
boucle. La quantité len(liste) – k est un variant de boucle.

 Écrire un algorithme de tri par insertion.
Cet exercice revient sur le tri par insertion en abordant la notion de meilleur cas et de pire cas (qui
n’est pas explicitement au programme). Il met l’accent sur la complexité très favorable du tri par
insertion dès lors que le tableau est déjà trié ou quasiment trié. En générant un tableau déjà trié ou trié
à l’envers (il suffira d’inverser un tableau déjà trié), on pourra réutiliser le compteur de comparaison
de l’activité 6 pour compter le nombre de comparaisons entre deux valeurs du tableau.
04733901_p004-224.pdf 187 11/08/2021 14:50

 Écrire un algorithme de tri par sélection.
enseignant.
Cet exercice exploite un tri par sélection pour trier des p-uplets selon leur altitude. Il est plus difficile
que les précédents car le tri ne s’effectue que selon un des termes du p-uplet : le tri par sélection doit
donc être légèrement modifié.
Dans le style de la séquence 4 « Données en table », les questions 4 et 5 proposent d’écrire deux
fonctions de sélection de certaines lignes.

 Utiliser un algorithme de tri.
La correction Python de cet exercice est disponible sur le site ressources et sur le manuel numérique enseignant.
Cet exercice propose d’écrire une fonction de fusion, que l’on rencontrera en Terminale dans le tri
fusion. Cette fonction reçoit en argument deux tableaux triés et les fusionne en un seul tableau trié.
04733901_p004-224.pdf 188 11/08/2021 14:50

04733901_p004-224.pdf 189 11/08/2021 14:50

04733901_p004-224.pdf 190 11/08/2021 14:50

04733901_p004-224.pdf 191 11/08/2021 14:50

04733901_p004-224.pdf 192 11/08/2021 14:50

04733901_p004-224.pdf 193 11/08/2021 14:50

04733901_p004-224.pdf 194 11/08/2021 14:50

à l’adresse : https://cahier-nsi.fr/#!/revision/seq9 et sur le manuel numérique enseignant.
04733901_p004-224.pdf 195 11/08/2021 14:50

Proposition 1
Ce mini-projet propose de gérer une liste d’élèves. Il faudra tout d’abord choisir une structure de
données adaptée et modifiable par affectation, comme vu à la séquence 3 sur les types construits. Une
liste de listes ou un dictionnaire semblent des structures de données adaptées.
Afin de pouvoir mettre à jour les données de la liste d’élèves, il faudra écrire des fonctions Python
munies d’un cahier des charges spécifique. Il est important de prototyper chaque fonction
(la déclaration de son nom, de la liste de ses arguments et de ses valeurs de retour, ainsi que leur type
respectif), comme vu à la séquence 8.
Proposition 2
Il faudra ici modifier la fonction de tri classique déjà étudiée dans la séquence (tri par insertion ou tri
par sélection) pour la rendre compatible avec le tri d’une liste de chaînes de caractères. La complexité
algorithmique dépendra de l’algorithme de tri utilisé.
04733901_p004-224.pdf 196 11/08/2021 14:50

Thème G : Algorithmique
Séquence 10 Algorithmique avancée
Le thème G (Algorithmique) correspond aux deux séquences suivantes :

 Séquence 9 : Les bases de l’algorithmique
 Séquence 10 : Algorithmique avancée
La séquence 10 nécessite d’avoir traité au préalable la séquence 9, puisque toute les bases de
l’algorithmique utilisées dans la séquence 10 ont été posées dans la séquence 9, comme la complexité,
la terminaison et la correction partielle d’un algorithme.
A. Le programme
thème Algorithmique ont été traités dans la séquence 9.
Contenus Capacités attendues du BO Activité / Exercice

Algorithme Écrire un algorithme qui prédit la classe d’un élément en Activité 3

des k plus proches fonction de la classe majoritaire de ses k plus proches p. 168-169
voisins voisins.
Exercices 4, 5, 6
p. 175-176
Recherche Montrer la terminaison de la recherche dichotomique à Activité 4

dichotomique l’aide d’un variant de boucle. p. 170-171
dans un tableau
trié Exercices 7, 8, 9
p. 177
Algorithmes Résoudre un problème grâce à un algorithme glouton. Activités 1 et 2

gloutons p. 164 à 167
Exercices 1, 2, 3
p. 174
200 Thème G  Séquence 10 Algorithmique avancée
04733901_p004-224.pdf 197 11/08/2021 14:50

ou dans le manuel numérique enseignant.
Activité Quelle est la différence essentielle entre une boucle « pour » et une boucle « tant que » ?
1
Réponses :
A. La boucle « pour » se termine toujours. (Bonne réponse.)
B. La boucle « tant que » se termine toujours.
C. La boucle « pour » peut ne pas se terminer.
Activité Quelle pourrait être la définition d’une valeur massique ?

1
Réponses :
A. Une masse multipliée par une valeur.
B. Une masse par unité de valeur.
C. Une valeur par unité de masse. (Bonne réponse.)
Activité Si l’on devait rendre la monnaie dans une boulangerie :

2
Réponses :
A. On rendrait les pièces dans n’importe quel ordre.
B. On rendrait en premier la pièce dont la valeur est la plus petite.
C. On rendrait en premier la pièce dont la valeur est la plus grande. (Bonne réponse.)
Activité Comment montrer qu’un algorithme se termine ?

2
Réponses :
A. Ce n’est pas nécessaire car les algorithmes se terminent toujours.
B. En exhibant un variant de boucle. (Bonne réponse.)
C. En exhibant un invariant de boucle.
Activité Qu’appelle-t-on distance euclidienne entre deux points du plan ?

3
Réponses :
A. Une distance calculée grâce au PGCD d’Euclide.
B. La distance entre les deux points et un troisième point du plan.
C. La distance entre les deux points, exprimée en cm ou en m. (Bonne réponse.)
Activité Dans le jeu « plus petit ou plus grand » qui consiste à faire deviner un nombre inconnu, une
4 bonne stratégie consiste à :
Réponses :
A. tester toutes les solutions une par une.
B. partager en deux l’intervalle de recherche à chaque tour. (Bonne réponse.)
C. tester les valeurs par ordre décroissant.
04733901_p004-224.pdf 198 11/08/2021 14:50

Histoire des Sciences p. 163 / Découverte de la machine de Turing
 Événements clés de l’histoire de l’informatique
Cette activité présente la machine abstraite de Turing qui apporta en 1936 une solution
au 10e problème de Hilbert relatif à la décidabilité. Il est impossible de prédire si une machine de
Turing va s’arrêter, après avoir été programmée, tout comme le théorème de Matiyasevich prouva en
1970 l'impossibilité de l'existence d'un algorithme général permettant de dire si, oui ou non, il existe
une solution à une équation diophantienne.
Présenter cette machine curieuse et pourtant si simple dans son fonctionnement (il en existe faites de
papier ou avec des LEGO®) permet d’aborder le problème délicat de la décidabilité, qui sera revu en
classe de Terminale NSI.
C’est aussi une occasion de faire le lien entre les algorithmes et les machines déterministes, tous deux
généralement définis comme des programmes.
Activité 1 p. 164 / Le problème du sac à dos (voir la correction à la fin de la partie C)
 Résoudre un problème grâce à un algorithme glouton.
Le problème du sac à dos est un grand classique en algorithmique, classé dans la catégorie des
problèmes d'optimisation combinatoire. C’est l'un des 21 problèmes NP-complets de Richard Karp
(1972). La formulation du problème est très simple, mais sa résolution est complexe.
Ce problème d'optimisation est NP-difficile, c’est-à-dire qu’il n'existe pas d'algorithme polynomial
connu pour le résoudre. L’algorithme glouton présenté ici propose une solution rapide mais sans
garantie d’être optimale, comme nous le verrons dans l’activité avec l’examen de contre-exemples
bien choisis.
Le point d’orgue de cette activité est l’écriture de l’algorithme glouton en pseudo-code. Il semble
indispensable d’accompagner les élèves et d’écrire l’algorithme avec eux, en ayant bien expliqué
l’importance du choix d’un critère d’optimisation (ici la valeur massique) et du tri par valeur
décroissante. Ainsi, c’est l’objet ayant la valeur massique la plus élevée qui sera placé en premier dans
le sac à dos, à condition de ne pas dépasser la masse maximale du sac à dos.
À la question 11, on suppose que la complexité pour un algorithme de tri rapide est O(n • log(n)), ce
qui permettra d’évaluer la complexité globale de l’algorithme glouton.
04733901_p004-224.pdf 199 11/08/2021 14:50

Activité 2 p. 166 / Le problème du rendu de monnaie (voir la correction à la fin de la partie C)
Cette activité propose à nouveau la résolution d’un problème de recherche d’optimalité à l’aide d’un
algorithme glouton, comme pour le problème du sac à dos. Le professeur pourra traiter l’une ou l’autre
de ces deux activités ou les deux si la programmation annuelle le permet.
Il s’agit ici de rendre une somme d’argent avec le moins de pièces possibles, selon un critère
d’optimalité. L’algorithme glouton commencera donc par rendre en premier la pièce ayant la valeur la
plus élevée.
Les questions 7 et 8 mettent l’accent sur la présence de deux boucles « tant que » imbriquées l’une
dans l’autre, que l’élève retrouvera lors de l’écriture de l’algorithme en pseudo-code à la question 9. Il
semble indispensable d’accompagner les élèves et d’écrire l’algorithme avec eux.
La question 10 propose d’élaborer une preuve de terminaison, sachant que deux boucles non bornées
ont été utilisées dans l’algorithme. L’élève doit avoir l’idée d’exhiber un variant de boucle, puisque
cette notion a été présentée à la séquence précédente. C’est l’occasion de réinvestir ce savoir-faire
avec un algorithme plus complexe que ceux découverts dans la séquence 9.
Activité 3 p. 168 / Algorithme des k plus proches voisins

 Écrire un algorithme qui prédit la classe d’un élément en fonction de la classe majoritaire de ses k plus
proches voisins.
Cette activité est un grand classique puisqu’elle reprend le thème des iris de Fisher, algorithme simple
de classification très utilisé en intelligence artificielle. Le jeu de données utilisé regroupe les données
de 50 fleurs d’iris appartenant à trois espèces d'iris (Iris Setosa, Iris Virginica et Iris Versicolor).
À l’aide de mesures appropriées des sépales et des pétales (largeur et longueur), Fisher a montré
en 1936 comment faire une discrimination de manière à distinguer les espèces les unes des autres.
Au fur et à mesure de la progression de l’activité, l’élève construit l’algorithme de classification. Le

principe de l’algorithme est tout d’abord abordé sans aucun calcul (questions 1 à 7), puis sous forme
d’algorithme, écrit en pseudo-code à la question 11.
La question 10 propose de revoir comment calculer la distance euclidienne entre deux points du plan,
dont les coordonnées sont connues. Tous les élèves ne suivant pas la spécialité mathématique en classe
de Première, ce complément mathématique semble indispensable.
04733901_p004-224.pdf 200 11/08/2021 14:50

Activité 4 p. 170 / Algorithme de recherche dichotomique
 Montrer la terminaison de la recherche dichotomique à l’aide d’un variant de boucle.
Les corrections Python, ainsi que la correction dans l’interface « Modélisation » des questions 11 et
12, sont disponibles sur le site ressources et sur le manuel numérique enseignant.
L’objectif de cette activité est d’aborder la recherche d’un élément par dichotomie, dans un tableau
préalablement trié. Dichotomie vient du grec ancien dikhotomia qui signifie « division en deux
parties ». Il s’agit donc de couper un ensemble en deux parties, à chaque itération de l’algorithme.
L’algorithme est cette fois-ci donné à l’élève. L’accent a été mis sur la preuve de terminaison, qui est
au programme officiel. On emploiera ici aussi la méthode du variant de boucle, un entier qui doit
décroître strictement à chaque itération. Le variant de boucle identifié ici est la quantité
fin - début, qui est initialisée à longueur(tableau) avant d’entrer dans le premier tour de boucle
et qui sera égale à zéro lorsque la condition fin = début sera vérifiée.
La fin de l’activité traite de complexité. L’élève découvre à la question 12, après avoir fait une
modélisation, que la complexité de l’algorithme est logarithmique. Il pourra alors être pertinent de
remontrer les courbes des fonctions de complexité, grâce à l’interface web nommée « Complexité » de
la séquence 9. Encore une fois, on montre comment un algorithme pertinent est plus performant qu’un
algorithme dit naïf.
04733901_p004-224.pdf 201 11/08/2021 14:50

04733901_p004-224.pdf 202 11/08/2021 14:50

04733901_p004-224.pdf 203 11/08/2021 14:50

04733901_p004-224.pdf 204 11/08/2021 14:50

04733901_p004-224.pdf 205 11/08/2021 14:50

04733901_p004-224.pdf 206 11/08/2021 14:50

04733901_p004-224.pdf 207 11/08/2021 14:50

04733901_p004-224.pdf 208 11/08/2021 14:50

04733901_p004-224.pdf 209 11/08/2021 14:50

04733901_p004-224.pdf 210 11/08/2021 14:50

L’accent ayant été mis sur l’algorithmique dans les activités, de nombreux exercices proposent
d’implémenter ces algorithmes en langage Python, afin de les utiliser sur des exemples précis.
Les corrections Python des exercices 1, 2, 3, 5, 6, 7, 8, 9 sont disponibles sur le site ressources et sur le manuel

Cet exercice propose d’implémenter l’algorithme de l’activité 1 p. 164 en langage Python. Il ne pose
pas de difficulté particulière, à condition de bien respecter les indentations et la syntaxe du langage
Python. C’est l’occasion d’expliquer aux élèves qu’un programme est facile à écrire une fois que
l’algorithme en pseudo-code est validé. Lors de la programmation d’un problème complexe, écrire
l’algorithme en pseudo-code est une étape recommandée avant de l’implémenter dans un langage de
programmation. Cette étape permet également de réfléchir au type de variables à utiliser avant de se
soucier de la syntaxe.

Python.

Cet exercice, difficile, propose de gérer les évolutions d’un Pokémon, à l’aide d’une fonction
evolue_lettre().
La difficulté de l’exercice provient du parcours de la chaîne de caractères, position après position,

repérée par son indice. C’est aussi l’occasion de revoir comment transformer une lettre de l’alphabet
en son code ASCII, grâce à la méthode ord(), ou encore un code ASCII en la lettre de l’alphabet
correspondante, avec la méthode chr().
Cet exercice exigeant nécessite une grande rigueur dans le typage des variables utilisées.
04733901_p004-224.pdf 211 11/08/2021 14:50

proches voisins.
Cet exercice propose de déterminer graphiquement la classe (A ou B) d’une entrée donnée. Il s’agit ici
d’appliquer la méthode de classification découverte à l’activité 3 p. 168, mais sans aucun calcul.
On insiste à la question 3 sur l’importance du paramètre 𝑘 de l’algorithme kNN, qui, selon la valeur
de 𝑘, ne donnera pas le même résultat (la même classe) pour l’entrée testée.

proches voisins.
Cet exercice propose d’implémenter l’algorithme de l’activité 3 p. 168 en langage Python. De par le
nombre élevé de traitements à réaliser pour mettre en œuvre cet algorithme, l’exercice est réputé
difficile. Il pourrait d’ailleurs faire l’objet d’un mini-projet.
Pour assurer la réussite de l’élève, cet exercice est très guidé. L’élève pourra ainsi s’assurer, à chaque
question, que les fonctions écrites sont correctes et effectuent bien le travail attendu.

proches voisins.
Cet exercice original propose de mettre au point un système de reconnaissance de fruits selon ses
caractéristiques physiques (couleur et forme). L’algorithme kNN classique utilise la distance
euclidienne, mais ici c’est la distance de Hamming qui est utilisée. La distance de Hamming entre
deux mots binaires est égale au nombre de bits qui diffèrent d’un mot à l’autre. Ainsi les mots 101 et
100 sont à une distance de 1 (seul le dernier bit diffère) tandis que 1101 et 1110 sont à une distance de
2 (les deux derniers bits diffèrent).
Le tableau de la question 4 est à compléter à la main et peut être complété avec d’autres fruits si
besoin.
La question 5 propose d’écrire une fonction qui permettra de dire de quel fruit un fruit donné est le
plus proche, en se basant sur la distance de Hamming.
04733901_p004-224.pdf 212 11/08/2021 14:50

 Mettre en œuvre une recherche dichotomique dans un tableau trié.
Python.
Attention, cet algorithme de recherche doit être utilisé pour chercher un entier qui est réellement
présent dans la liste. Il ne faut pas l’utiliser pour chercher un entier qui en serait absent.

En guise d’introduction à la méthode du « diviser pour régner » qui sera revue en classe de Terminale
NSI (tri fusion), cet exercice propose de compter le nombre de tours de boucles qu’effectue un
algorithme de recherche dichotomique, dont la complexité est logarithmique.
À la question 3, on montre que si la taille du tableau initial double, un seul tour supplémentaire sera
nécessaire car, en un seul tour, la taille sera divisée par deux. La complexité de cet algorithme est donc
très favorable.

Cet exercice plus difficile propose d’implémenter un algorithme tricheur, c’est-à-dire qu’à chaque tour
de boucle, il faudra changer le nombre à deviner de manière à maximiser le nombre de tours de la
recherche dichotomique. Attention, le nombre modifié devra garder une parfaite cohérence avec les
nombres déjà testés par la personne qui devine, sinon la supercherie sera démasquée, par incohérence.
04733901_p004-224.pdf 213 11/08/2021 14:50

04733901_p004-224.pdf 214 11/08/2021 14:50

04733901_p004-224.pdf 215 11/08/2021 14:50

04733901_p004-224.pdf 216 11/08/2021 14:50

04733901_p004-224.pdf 217 11/08/2021 14:50

04733901_p004-224.pdf 218 11/08/2021 14:50

Les corrections Python des mini-projets sont disponibles sur le site ressources et sur le manuel numérique
enseignant.
Proposition 1
Ce mini-projet propose de simuler la réservation d’une ferme de calcul. Un algorithme glouton va en
effet permettre de maximiser la rentabilité de l’entreprise. Il est fortement suggéré d’écrire un
algorithme en pseudo-code avant de se lancer dans une implémentation en Python.
Ce type d’exercice peut être généralisé avec un visiteur qui voudrait par exemple effectuer un
maximum de spectacles dans un parc d’attraction.
Proposition 2
Ce mini-projet propose de revisiter le fameux jeu « Qui est-ce ? », en ajoutant une page web et une
série de 10 questions successives.
La programmation pourrait s’avérer fastidieuse, car il faut prévoir à l’avance les réponses à chaque
question, pour chacun des 20 personnages. Il est possible mutualiser cette étape. Ce mini-projet
requiert donc de l’organisation et une bonne structuration du travail à effectuer.
04733901_p004-224.pdf 219 11/08/2021 14:50

04733901_p004-224.pdf 220 11/08/2021 14:50
04733901_p004-224.pdf 221 11/08/2021 14:50

LDP Complet

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

LDP Complet

Transféré par

Droits d'auteur :

Formats disponibles

1

Sous la direction de Claire Savinas

04733833_001_003.indd 1 11/08/2021 15:35

04733894_002.indd 2 11/08/2021 16:14

Thème A Représentation des données : types et valeurs de base

Séquence 1 Représentation des nombres ................................................................................................................................. 5

Séquence 2 Encodage des caractères et expressions booléennes .............................................................. 30

Thème B Représentation des données : types construits

Séquence 3 Les types construits ................................................................................................................................................. 46

Thème C Traitement de données en tables

Séquence 4 Données en table ........................................................................................................................................................... 69

Thème D Interactions entre l’homme et la machine sur le Web

Séquence 5 Interactions entre l’homme et la machine sur le Web ................................................................. 89

Thème E Architectures matérielles et systèmes d’exploitation

Séquence 6 Architecture et systèmes d’exploitation ................................................................................................. 1 15

Thème F Langages et programmation

Séquence 8 Langages et programmation .............................................................................................................................. 1 56

Séquence 9 Les bases de l’algorithmique ............................................................................................................................. 172

04733833_001_003.indd 3 11/08/2021 16:13

04733901_p004-224.pdf 1 11/08/2021 14:50

Site ressources pour l’enseignant : nsi.editions-bordas.fr.

Contenus Capacités attendues du BO Activités /

Représentation Évaluer le nombre de bits nécessaires à l’écriture en Activités 3 et 4

Représentation Calculer sur quelques exemples la représentation de Activité 5

5 Thème A  Séquence 1 Représentation des nombres

04733901_p004-224.pdf 2 11/08/2021 14:50

Activité Le résultat du calcul 2 × 103 + 3 × 102 + 1 × 101 + 7 est :

Activité Le résultat du calcul 23 + 22 + 21 + 20 est :

Activité Sur un affichage à deux chiffres, combien de valeurs peut-on afficher ?

Activité Le résultat du calcul − 7 + 5 est :

6 Thème A  Séquence 1 Représentation des nombres

04733901_p004-224.pdf 3 11/08/2021 14:50

Cette activité présente succinctement l’évolution des systèmes de numération, de l’Antiquité à la

Activité 1 p. 10 / Base décimale et base binaire (voir la correction à la fin de la partie C)

7 Thème A  Séquence 1 Représentation des nombres

04733901_p004-224.pdf 4 11/08/2021 14:50

Avant la question 4, il a paru nécessaire aux auteurs de redonner le vocabulaire de la division

Activité 2 p. 11 / Base hexadécimale

Cette activité propose de découvrir et de manipuler uniquement la base hexadécimale. L’activité 2

La contextualisation de l’activité 2 a pour objectif de réévoquer le langage de description web : le

Le texte d’au-dessous permet d’introduire la base hexadécimale sur un exemple concret et de

8 Thème A  Séquence 1 Représentation des nombres

04733901_p004-224.pdf 5 11/08/2021 14:50

Activité 3 p. 12 / Integer Overflow

9 Thème A  Séquence 1 Représentation des nombres

04733901_p004-224.pdf 6 11/08/2021 14:50

Activité 5 p. 14 / Représentation approximative d’un nombre flottant

10 Thème A  Séquence 1 Représentation des nombres

04733901_p004-224.pdf 7 11/08/2021 14:50

11 Thème A  Séquence 1 Représentation des nombres

04733901_p004-224.pdf 8 11/08/2021 14:50

04733901_p004-224.pdf 9 11/08/2021 14:50

04733901_p004-224.pdf 10 11/08/2021 14:50

04733901_p004-224.pdf 11 11/08/2021 14:50

04733901_p004-224.pdf 12 11/08/2021 14:50

04733901_p004-224.pdf 13 11/08/2021 14:50

04733901_p004-224.pdf 14 11/08/2021 14:50

04733901_p004-224.pdf 15 11/08/2021 14:50

Exercice 2 page 19 (voir la correction à la fin de la partie D)

Exercice 3 page 19 (voir la correction à la fin de la partie D)

Exercice 4 page 20 (voir la correction à la fin de la partie D)

Exercice 5 page 20 (voir la correction à la fin de la partie D)

19 Thème A  Séquence 1 Représentation des nombres