OK, on fait un gros bloc unique, mais lis‑le tranquille, pas en mode panique.

C’est une
fiche “dernière veille NSI” : formes de code à copier‑coller depuis ta tête demain, + pièges
classiques à éviter.

1. Python : listes, piles, files

1.1 Listes Python (base)

Formes à connaître :

python
# Parcourir une liste
for x in L:
...

# Parcourir avec index

for i in range(len(L)):
...

# Copier une liste (important !)

L2 = list(L) # ou [Link]()

# Ajouter / retirer
[Link](x)
[Link]() # enlève et renvoie le dernier
[Link](i) # enlève et renvoie l’élément d’indice i

# Tester l’appartenance
if x in L:
...

Pièges :

●​ Ne pas modifier une liste pendant que tu fais un for x in L sans faire très
attention.
●​ Se rappeler que L2 = L ne copie pas, ça pointe vers la même liste.

1.2 Pile (LIFO) avec liste

Définition : on ajoute et retire au même bout. C’est du LIFO : Last In, First Out.

Implémentation classique :

python
def pile_vide():
return []

def est_vide(pile):
return len(pile) == 0

def empiler(pile, element):

[Link](element)

def depiler(pile):
# On suppose que la pile n'est pas vide
return [Link]()

Pièges :

●​ Ne pas faire pile = [Link](x) (car append renvoie None).

●​ Toujours penser à gérer le cas pile vide avant depiler dans un vrai sujet (au moins
dans le texte).

1.3 File (FIFO) simple

Définition : on ajoute en queue, on retire en tête. C’est du FIFO : First In, First Out.

Implémentation simple :

python
def file_vide():
return []

def est_vide_file(file):
return len(file) == 0

def enfiler(file, element):

[Link](element)

def defiler(file):
# On suppose que la file n'est pas vide
 return [Link](0)

2. Récursivité : formes à maîtriser

2.1 Schéma général

Une fonction récursive a toujours :

●​ un cas de base (simple, sans appel récursif),

●​ un cas récursif (appel sur une version plus “petite” du problème).

Si le cas de base n’est pas atteint → risque de boucle infinie.

2.2 Somme d’une liste (classique)

python
def somme(L):
if L == []: # cas de base
return 0
else: # cas récursif
return L[0] + somme(L[1:])

Pièges :

●​ Oublier le cas L == [].

●​ Faire somme(L[0:]) au lieu de L[1:] (la liste ne rétrécit pas).

2.3 Recherche dichotomique récursive

Précondition : L triée croissante.

Version avec indices (plus propre) :

python
def rech_dicho(L, x, debut, fin):
if debut > fin: # cas de base : intervalle vide
return False
m = (debut + fin) // 2
if L[m] == x:
 return True
elif L[m] < x:
return rech_dicho(L, x, m+1, fin)
else:
return rech_dicho(L, x, debut, m-1)

3. Arbres binaires / ABR

On manipule souvent :

python
class Noeud:
def __init__(self, valeur, gauche=None, droite=None):
[Link] = valeur
[Link] = gauche
[Link] = droite

On considère qu’un arbre est soit None soit un Noeud.

3.1 Définitions
●​ Arbre : structure hiérarchique sans cycles.
●​ Racine : nœud sans parent.
●​ Feuille : nœud sans enfant.
●​ Taille : nombre total de nœuds.
●​ Hauteur (convention terminale) :
○​ arbre vide → hauteur 0
○​ arbre juste racine → hauteur 1
●​ Arbre binaire : chaque nœud a au plus deux enfants (gauche, droite).
●​ ABR : pour chaque nœud, les valeurs du sous-arbre gauche ≤ valeur du nœud,
celles du sous-arbre droit ≥.[[Link]]

3.2 Taille d’un arbre

python
def taille(arbre):
if arbre is None:
return 0
else:
return 1 + taille([Link]) + taille([Link])
3.3 Hauteur d’un arbre
python
def hauteur(arbre):
if arbre is None:
return 0
else:
h_g = hauteur([Link])
h_d = hauteur([Link])
return 1 + max(h_g, h_d)

Piège : bien gérer arbre is None en cas de base, sinon AttributeError.

3.4 Insertion dans un ABR

python
class Noeud:
def __init__(self, valeur, gauche=None, droite=None):
[Link] = valeur
[Link] = gauche
[Link] = droite

def ajouter(self, x):

if x <= [Link]:
if [Link] is None:
[Link] = Noeud(x)
else:
[Link](x)
else:
if [Link] is None:
[Link] = Noeud(x)
else:
[Link](x)

4. Graphes : définitions + parcours

4.1 Définitions indispensables

 ●​ Graphe : ensemble de sommets reliés par des arêtes (non orienté) ou des arcs
(orienté).[info-mounier]
●​ Sommet (nœud) : élément du graphe.
●​ Arête : lien entre deux sommets (non orienté).
●​ Arc : lien dirigé de u vers v dans un graphe orienté.
●​ Graphe orienté / non orienté : selon si les liens ont un sens ou non.[info-mounier]
●​ Degré d’un sommet : nombre de voisins (arêtes qui partent de ce
sommet).[stephane]

Représentation bac classique : dictionnaire d’adjacence :

python
graphe = {
"A": ["B", "C"],
"B": ["A"],
"C": ["A"]
}

4.2 DFS (parcours en profondeur)

Idée : on va le plus loin possible, puis on revient en arrière.​
Utilise un set visites.[[Link]]

python
def dfs(graphe, depart):
visites = set()
ordre = []

def visite(s):
if s in visites:
return
[Link](s)
[Link](s)
for voisin in graphe[s]:
visite(voisin)

visite(depart)
return ordre

4.3 BFS (parcours en largeur)

Idée : on explore d’abord les voisins, puis les voisins des voisins.​
Adapté pour trouver un chemin de longueur minimale dans un graphe non
pondéré.[pixees]

python
from collections import deque

def bfs(graphe, depart):

visites = set([depart])
ordre = []
file = deque([depart])

while file:
s = [Link]()
[Link](s)
for voisin in graphe[s]:
if voisin not in visites:
[Link](voisin)
[Link](voisin)
return ordre

Phrase à sortir si besoin :

●​ BFS visite les sommets par distance croissante depuis le départ, donc la première
fois qu’on atteint un sommet, on a un chemin avec un nombre minimal d’arêtes.

5. SQL : formes à connaître

Tu dois savoir écrire des requêtes en mode débranché (papier).[pixees]

5.1 Schéma relationnel

Vocabulaire :

●​ Table / relation : ensemble de lignes (enregistrements / n‑uplets) avec mêmes

colonnes (attributs).
●​ Clé primaire : identifie de façon unique chaque ligne, non nulle.
●​ Clé étrangère : attribut qui référence la clé primaire d’une autre table (pour lier les
tables).
5.2 Requête simple
sql
SELECT colonne1, colonne2
FROM Table
WHERE condition
ORDER BY colonne1 DESC;

Exemple : élèves avec moyenne > 15 :

sql
SELECT nom, prenom, moyenne
FROM Eleve
WHERE moyenne > 15
ORDER BY moyenne DESC;

5.3 Agrégation + GROUP BY

Forme générale :

sql
SELECT attribut_groupe, AVG(colonne) AS alias
FROM Table
GROUP BY attribut_groupe;

Exemple : moyenne des moyennes par classe :

sql
SELECT classe,
AVG(moyenne) AS moyenne_classe
FROM Eleve
GROUP BY classe;

Pièges :

●​ Tout attribut dans le SELECT qui n’est pas le résultat d’une fonction d’agrégat doit
apparaître dans le GROUP BY.[[Link]]

5.4 Jointure de base

Forme type :
sql
SELECT ...
FROM A
JOIN B ON [Link] = [Link]
WHERE ...

Avec 3 tables :

sql
SELECT [Link],
[Link],
[Link],
[Link]
FROM Note
JOIN Eleve ON Note.id_eleve = [Link]
JOIN Matiere ON Note.id_matiere = [Link]
WHERE [Link] < 8;

Moyenne en NSI par élève :

sql
SELECT [Link],
[Link],
[Link],
AVG([Link]) AS moyenne_nsi
FROM Note
JOIN Eleve ON Note.id_eleve = [Link]
JOIN Matiere ON Note.id_matiere = [Link]
WHERE [Link] = 'NSI'
GROUP BY [Link], [Link], [Link];

Pièges :

●​ Oublier ON après JOIN.

●​ Oublier GROUP BY quand tu utilises AVG, COUNT avec d’autres colonnes dans le
SELECT.

6. POO : formes indispensables

6.1 Classe basique

python
class MaClasse:
def __init__(self, attribut):
[Link] = attribut

def methode(self, x):

# [Link] est accessible
...
return ...

Mots à savoir :

●​ Classe : modèle d’objets.

●​ Objet / instance : réalisation concrète de la classe.
●​ Attribut : donnée stockée dans l’objet.
●​ Méthode : fonction définie dans la classe.
●​ Constructeur : méthode __init__ appelée à la création d’un objet.

7. Pièges récurrents (check rapide)

Quand tu reliras cette fiche, regarde surtout ces points :

●​ Python :
○​ ne pas confondre return (sortir de la fonction) et print (afficher
seulement).
○​ bien gérer les cas “liste vide”, “arbre vide”, “pile/file vide”.
○​ en récursif, vérifier que l’argument se “rapproche” du cas de base.
●​ Arbres / graphes :
○​ bien traiter le cas None pour un sous-arbre.
○​ utiliser un set visites en DFS/BFS pour éviter les boucles.
○​ pour le plus court chemin dans un graphe non pondéré : BFS, pas DFS.
●​ SQL :
○​ syntaxe : SELECT ... FROM ... WHERE ... dans cet ordre.
○​ penser à GROUP BY avec les AVG, COUNT (et autres agrégats).
○​ bien écrire les jointures JOIN ... ON ....

Lis ce bloc une fois calmement, éventuellement reviens seulement sur les bouts de code
(les cadres Python/SQL) demain matin 5–10 minutes, et ensuite tu laisses ton cerveau faire
le reste.

Tu veux qu’on fasse un dernier micro‑check (par exemple je te demande juste : “écris
rapidement une requête SQL moyenne par classe” ou “écris la fonction taille(arbre) de
mémoire”) ou tu préfères t’arrêter là et te reposer ?
Tu as bien ciblé deux blocs “archi” qui peuvent tomber : processeur / architecture von
Neumann / processus et routeurs / routage (RIP, OSPF). Je te fais un bloc unique, lisable
d’une traite, avec juste ce qu’il faut pour le bac.

1. Comment “pensent” les ordis : processeur et

architecture

1.1 Architecture de von Neumann (version bac)

Un ordinateur (modèle de von Neumann) est composé de 4 grandes parties :[annabac]

●​ CPU (processeur) : exécute les instructions et effectue les calculs.

●​ Mémoire : stocke les programmes et les données ensemble.[ldm]
●​ Bus : “fils” qui transportent les signaux entre processeur, mémoire,
périphériques.[[Link]]
●​ Entrées/Sorties : clavier, écran, disque, réseau, etc..[[Link]]

Idée clé :

Le processeur lit des instructions en mémoire, les décodent et les exécute

sur des données, aussi stockées en mémoire.[ldm]

1.2 À l’intérieur du processeur (CPU)

Le processeur est lui‑même composé principalement de :[axelnax]

●​ UAL / ALU (Unité Arithmétique et Logique) : fait les opérations arithmétiques

(addition, soustraction, etc.) et logiques (ET, OU, NON).
●​ Unité de commande / de contrôle (UC) : orchestre l’exécution des instructions
(séquenceur).[[Link]]
●​ Registres : petites mémoires ultra rapides à l’intérieur du processeur pour stocker
des valeurs temporaires.[[Link]]

Phrase à sortir :

Le processeur exécute des instructions machine en s’appuyant sur l’unité de

commande, l’UAL et des registres.[axelnax]

1.3 Cycle d’instruction : FETCH–DECODE–EXECUTE

Le processeur répète en boucle un cycle d’instruction :[allophysique]

●​ Fetch / LI (Lire Instruction) : lire l’instruction actuelle en mémoire, à l’adresse

donnée par le compteur ordinal (PC).
●​ Decode / DI : décoder l’instruction (quel type d’opération, quels registres, quelles
données).[pixees]
●​ Execute / EX : exécuter l’opération dans l’UAL (calcul ou test).[annabac]
●​ Optionnel : Accès mémoire (M) et écriture résultat (ER / Write‑back) pour
mémoriser le résultat.[annabac]

Idée :

À chaque cycle, le processeur lit une instruction, la décode, l’exécute, puis

passe à la suivante.

1.4 Processus (niveau système d’exploitation)

En terminale NSI, on parle aussi de processus :[[Link]]

●​ Un processus = un programme en cours d’exécution, avec :

○​ son code en mémoire,
○​ ses données,
○​ son état (en cours, prêt, bloqué),
○​ son espace mémoire propre (pile, tas, etc.).

Le système d’exploitation :

●​ gère plusieurs processus en même temps,

●​ planifie lequel a le processeur à un instant donné.[qkzk]

Phrase à connaître :

Le processeur n’exécute qu’une instruction à la fois, mais l’OS alterne très vite
entre plusieurs processus pour donner l’illusion du
multitâche.[[Link]]

2. Routeurs et routage (RIP / OSPF)

2.1 Rôle d’un routeur et table de routage

Un routeur est une machine qui possède au moins deux interfaces réseau et qui sert à
rediriger les paquets entre réseaux.[[Link]]

●​ Il reçoit des paquets IP.

 ●​ Il regarde l’adresse IP de destination.
●​ Il consulte sa table de routage pour savoir par quelle interface les renvoyer.[pixees]

Une table de routage, c’est en gros :[lyceum]

Destination Interface / Next hop Métrique (coût)

(réseau)

Métrique = “distance” ou “coût” pour atteindre la destination.​

Règle : plus la métrique est petite, meilleure est la route.[[Link]]

2.2 Routage statique vs dynamique

Deux façons de remplir cette table :[[Link]]

●​ Routage statique :
○​ L’administrateur configure à la main les routes (utilisable sur de très petits
réseaux).
●​ Routage dynamique :
○​ Des protocoles de routage (RIP, OSPF) permettent aux routeurs d’échanger
des informations et de mettre à jour automatiquement leur table de
routage.[pixees]

Question type bac :

Avantage du routage dynamique ?​

Réponse : il s’adapte automatiquement aux changements (lien coupé, nouveau
routeur) sans reconfigurer manuellement toutes les tables.[info-mounier]

2.3 Protocole RIP (Routing Information Protocol)

●​ Catégorie : protocole à vecteur de distance.[pixees]
●​ Chaque routeur maintient, pour chaque destination, une distance = nombre de
sauts (nombre de routeurs traversés).[[Link]]
●​ Les routeurs échangent régulièrement leur vecteur de distances avec leurs voisins.
●​ Chacun met à jour sa table si un voisin propose un chemin plus court (moins de
sauts).[zonensi]
●​ But : minimiser le nombre de routeurs traversés (nombre de
sauts).[[Link]]

À retenir :

RIP minimise le nombre de sauts.

2.4 Protocole OSPF (Open Shortest Path First)
●​ Catégorie : protocole à état de liens.[pixees]
●​ Chaque lien entre routeurs a un coût (souvent inversement proportionnel au débit :
plus le débit est élevé, plus le coût est faible).[novelclass]
●​ OSPF cherche à minimiser la somme des coûts des liaisons sur le chemin.
●​ Donc il privilégie les liaisons rapides, même si cela fait passer par plus de
routeurs.[[Link]]

À retenir :

OSPF minimise le coût (temps de parcours), pas juste le nombre de sauts.

2.5 Comparaison RIP / OSPF (version “phrase bac”)

On peut résumer ainsi :[pixees]

●​ RIP :
○​ Protocole simple, adapté aux petits réseaux.
○​ Métrique : nombre de sauts.
○​ Cherche le chemin avec le moins de routeurs traversés.
●​ OSPF :
○​ Plus sophistiqué, adapté aux grands réseaux.
○​ Métrique : coût des liens (lié au débit).
○​ Cherche le chemin avec le coût total minimal, donc privilégie les liens
rapides.

3. Ce que tu risques de voir au bac sur ces chapitres

En gros, on peut te demander :

●​ Architecture / processeur :
○​ Nommer les éléments de l’architecture de von Neumann (CPU, mémoire,
bus, E/S).[[Link]]
○​ Expliquer le rôle du processeur, de l’UAL, de l’unité de commande et des
registres.[[Link]]
○​ Décrire le cycle d’instruction (fetch, decode, execute, write‑back).[annabac]
○​ Dire ce qu’est un processus (programme en cours d’exécution) et ce que
gère l’OS.[qkzk]
●​ Routeurs / routage :
 ○​ Expliquer l’intérêt d’un routeur, et lire / interpréter une table de
routage.[[Link]]
○​ Différencier routage statique et routage
dynamique.[[Link]]
○​ Dire ce que minimisent RIP (sauts) et OSPF (coût/temps).[[Link]]
○​ Choisir un chemin “meilleur” selon la métrique donnée dans l’énoncé.

Lis ce bloc une fois ce soir, éventuellement une fois très rapide demain matin, et ça suffira
largement pour ne pas te faire piéger sur ces chapitres.

Tu veux que je te fasse 4–5 questions ultra courtes type bac (QCM mental) sur processeur +
routage pour vérifier que c’est bien clair, ou tu préfères juste relire ça calmement et couper
là ?

Tu as raison de penser aux tris (insertion, fusion, etc.) : ça fait partie du bloc “algorithmique”
du programme, et c’est déjà tombé (tri par insertion en 2022, tri fusion en 2024). Je vais te
faire un bloc récap global de tous les gros chapitres NSI bac + un zoom sur les
tris.[pixees]

1. Vue d’ensemble des chapitres NSI Terminale

Le programme officiel organise la NSI autour de quelques grandes parties :[pixees]

●​ Structures de données : listes, piles, files, dictionnaires, arbres,

graphes.[groupe-reussite]
●​ Bases de données : modèle relationnel, schémas, SQL.[annabac]
●​ Architectures / OS / réseaux : architecture matérielle (CPU, mémoire), processus,
routage, sécurisation.[annabac]
●​ Langages et programmation : modularité, récursivité, POO,
paradigmes.[[Link]]
●​ Algorithmique avancée : algorithmes de tri, diviser pour régner, programmation
dynamique, graphes, arbres.[[Link]]

Les annales récentes montrent que les plus fréquents au bac sont :

●​ listes / piles / files,

●​ récursivité,
●​ SQL,
●​ graphes / arbres,
●​ POO,
●​ tris (insertion, fusion).[diplomeo]
2. Algorithmes de tri à connaître
En NSI, on s’attend à ce que tu connaisses tri par insertion, tri par sélection (vu en 1re) et
surtout tri fusion (diviser pour régner).[snt-nsi]

2.1 Tri par insertion (classique au bac)

Idée : on construit petit à petit une partie triée à gauche du tableau, et on insère chaque
nouvel élément à sa place.[sherpas]

Pseudo‑code classique :[[Link]]

python
def tri_insertion(T):
for i in range(1, len(T)):
x = T[i]
j = i
while j > 0 and T[j-1] > x:
T[j] = T[j-1]
j = j - 1
T[j] = x

●​ Au rang i, on “insère” T[i] dans la partie [0..i-1] déjà triée.

●​ Complexité temporelle : en gros O(n2)O(n^2)O(n2) dans le pire cas.[pixees]

Ce tri est déjà tombé explicitement au bac (jour 1 de 2022).[diplomeo]

2.2 Tri fusion (merge sort, diviser pour régner)

Idée :

●​ diviser la liste en deux moitiés,

●​ trier récursivement chaque moitié,
●​ fusionner deux listes triées en une seule liste triée.[snt-nsi]

On combine deux idées :

1.​ Diviser pour régner : on résout un grand problème en résolvant deux

sous‑problèmes plus petits.[[Link]]
2.​ Fusion de deux listes déjà triées, en temps linéaire O(n)O(n)O(n).[snt-nsi]

Schéma Python typique :

python
def fusion(L1, L2):
i, j = 0, 0
R = []
while i < len(L1) and j < len(L2):
if L1[i] <= L2[j]:
[Link](L1[i])
i += 1
else:
[Link](L2[j])
j += 1
# on ajoute le reste
while i < len(L1):
[Link](L1[i])
i += 1
while j < len(L2):
[Link](L2[j])
j += 1
return R

def tri_fusion(L):
if len(L) <= 1:
return L
m = len(L) // 2
G = tri_fusion(L[:m])
D = tri_fusion(L[m:])
return fusion(G, D)

●​ Complexité du tri fusion : O(nlog⁡n)O(n \log n)O(nlogn) (bien plus efficace que
O(n2)O(n^2)O(n2)).[pixees]
●​ Ce tri est tombé dans le jour 1 de 2024.[diplomeo]

2.3 Pourquoi on insiste dessus au bac

Les documents de synthèse et les annales soulignent que :

●​ tri par insertion et tri fusion sont des exemples types d’algos à connaître (avec leurs
idées et leurs complexités);[sherpas]
●​ ils servent aussi à illustrer la méthodologie diviser pour régner (tri fusion) et les
notions de complexité.[[Link]]

Dans un sujet, on peut te demander :

 ●​ de compléter / corriger un code de tri,
●​ d’expliquer l’idée du tri,
●​ de donner l’ordre de complexité,
●​ ou de montrer l’état du tableau après quelques étapes.

3. Synthèse : tous les gros chapitres NSI à garder en

tête
En reprenant la liste officielle, les chapitres que tu dois avoir au moins vus sont:[pixees]

Structures de données
●​ Listes, piles, files (implémentation Python, LIFO / FIFO, opérations de
base).[groupe-reussite]
●​ Dictionnaires (clé → valeur, table de hachage).
●​ Arbres (arbres binaires, ABR, taille, hauteur, parcours
préfixe/infixe/postfixe).[[Link]]
●​ Graphes (sommets, arêtes/arcs, représentations, DFS/BFS).[[Link]]

Bases de données
●​ Modèle relationnel : tables, attributs, clé primaire, clé étrangère.[pixees]
●​ SQL : SELECT, FROM, WHERE, ORDER BY, JOIN, GROUP BY avec AVG, COUNT,
etc..[lyceum]

Architectures / OS / réseaux
●​ Architecture matérielle : modèle de von Neumann, CPU, mémoire, bus,
périphériques.[ldm]
●​ Processus : programme en cours d’exécution, géré par
l’OS.[[Link]]
●​ Protocoles de routage : routeur, table de routage, routage statique vs dynamique,
RIP (minimise les sauts), OSPF (minimise le
coût).[[Link]]
●​ Sécurisation (souvent en lien avec HTTPS / chiffrement, mais un peu moins central
que le reste).

Langages, programmation, algorithmique

●​ Récursivité : cas de base, cas récursif, exemples sur listes/arbres.[[Link]]
●​ POO : classes, objets, attributs, méthodes, __init__.[annabac]
●​ Algorithmes de tri : insertion, sélection (revu), fusion.[sherpas]
 ●​ Algorithmes sur les arbres : taille, hauteur, recherche dans un ABR,
parcours.[[Link]]
●​ Algorithmes sur les graphes : DFS, BFS, plus court chemin non pondéré.[pixees]

Les analyses de sujets 2022–2025 + pronostics 2026 mettent en avant en priorité :

●​ structures linéaires,
●​ récursivité,
●​ SQL,
●​ graphes/arbres,
●​ tris (insertion / fusion),
●​ POO,
●​ routage.[[Link]-toulouse]

Pour ce soir, c’est suffisant de savoir situer chaque truc (“ah oui, ça c’est dans quel
chapitre, je sais grosso modo ce que c’est”) et d’avoir en tête les formes de code qu’on a
vues. Tu n’as pas besoin d’ouvrir chaque cours en détail maintenant.

Si tu veux, je peux te faire un tout petit exercice type bac sur tri par insertion ou tri fusion
(par exemple compléter une fonction ou expliquer une étape), et tu me renvoies juste ta
version pour une dernière vérification rapide. Tu préfères qu’on prenne tri par insertion (plus
simple) ou tri fusion (plus “bac 2024”) ?