Numérique et sciences informatiques (spécialité) · TerminaleBac

Paradigmes de programmation : cours de Terminale NSI

Publié le 7 novembre 2026 · Mis à jour le 7 novembre 2026 · Signaler une erreur

L'essentiel

Un paradigme est une manière d'aborder la programmation et d'imaginer la solution d'un problème ; il façonne la vue qu'on a de l'exécution du programme.
Impératif : une suite d'instructions qui modifient l'état (les variables). Procédural et structuré en sont des dérivés.
Fonctionnel : le programme est une suite d'évaluations de fonctions sans état ; on évite les effets de bord.
Objet : le programme est une collection d'objets en interaction (attributs + méthodes). Logique : faits, règles, requêtes. Concurrent : plusieurs tâches en même temps.
Un langage comme Python accepte plusieurs paradigmes : le paradigme est une manière de penser le code, pas une propriété exclusive du langage.

Pourquoi parler de paradigmes ?

Tu sais déjà écrire des programmes en Python : des boucles, des fonctions, des classes, de la récursivité. Pourtant, deux programmes qui résolvent le même problème peuvent avoir un aspect très différent, parce que leurs auteurs n'ont pas raisonné de la même façon. Ce cours donne un nom et une structure à ces façons de raisonner : les paradigmes de programmation.

Cette notion arrive après la récursivité et la modularité, que tu as déjà rencontrées, et elle prépare la mise au point des programmes : pour corriger un programme, il faut d'abord comprendre comment il est pensé. Au bac, des exercices portent sur la programmation Python, la programmation orientée objet et les structures de données ² : savoir nommer le style d'un code t'aide à lire un énoncé plus vite.

Un paradigme n'est donc pas un langage, ni une technique isolée. C'est un point de vue. Il détermine la vue que le développeur a de l'exécution de son programme ³. Selon le point de vue, un même programme est une recette qu'on suit pas à pas, un réseau d'objets qui se parlent, ou un assemblage de fonctions.

Paradigmes

Impératif
- Instructions
- Variables
- Procédural
Fonctionnel
- Fonctions
- Sans état
- Récursivité
Objet
- Classes
- Attributs
- Méthodes
Logique
- Faits
- Règles
- Requêtes
Concurrent
- Threads
- Tâches parallèles

Les grandes familles de paradigmes · Chaque paradigme est une façon de penser le même programme.

Le paradigme impératif : donner des ordres

Le paradigme impératif est le paradigme originel et le plus courant ³. Tu l'as pratiqué dès tes premiers programmes : le programme est une suite d'instructions exécutées dans l'ordre, qui modifient l'état de la machine, c'est-à-dire le contenu des variables. Quand on cherche des langages qui l'implémentent, on peut citer le C, le Pascal, le Fortran ou encore le Cobol ⁴.

ExempleSomme des carrés, version impérative

def somme_carres(liste):
    total = 0
    for x in liste:
        total = total + x * x
    return total

print(somme_carres([1, 2, 3]))   # 14

On lit le code comme une recette : on part de total = 0, puis on modifie total à chaque tour de boucle. Ce qui caractérise le style impératif, c'est cette variable qui change au fil du temps.

Des dérivés du paradigme impératif sont à connaître :

la programmation structurée, qui cherche à organiser les programmes impératifs pour en faire disparaître les instructions goto ³. Tes boucles for, while et tes if sont des structures de contrôle de ce style ;
la programmation procédurale, qui isole des morceaux de programme dans des procédures ou fonctions, paramétrables et utilisables de façon répétée ⁴. Selon le paradigme, ces morceaux s'appellent procédures, fonctions ou méthodes ⁴.

Le paradigme fonctionnel : composer des fonctions

En programmation fonctionnelle, un programme est vu comme une suite d'évaluations de fonctions sans états ³. On ne cherche pas à modifier des variables : on calcule une valeur à partir d'autres valeurs, comme en mathématiques. Haskell est un exemple de langage conçu pour supporter ce paradigme ³.

ExempleSomme des carrés, version fonctionnelle

def somme_carres(liste):
    if liste == []:
        return 0
    return liste[0] ** 2 + somme_carres(liste[1:])

print(somme_carres([1, 2, 3]))   # 14

Aucune variable n'est modifiée. Le résultat pour [1, 2, 3] est défini par le résultat pour [2, 3], lui-même défini par celui pour [3], puis par celui de la liste vide. Tu retrouves la récursivité du chapitre précédent : elle est l'outil naturel de ce style, puisqu'elle remplace la boucle et son compteur.

ExempleAvec et sans effet de bord

def ajoute_a_la_fin(liste, valeur):      # effet de bord
    liste.append(valeur)

def liste_avec(liste, valeur):           # sans effet de bord
    return liste + [valeur]

L = [1, 2]
liste_avec(L, 3)         # L vaut toujours [1, 2]
ajoute_a_la_fin(L, 3)    # L vaut maintenant [1, 2, 3]

La seconde fonction renvoie une nouvelle liste et laisse L intact : son résultat ne dépend que de ses arguments, et elle ne change rien d'autre. Appelée deux fois avec les mêmes arguments, elle donne deux fois la même réponse.

Le lien avec ton cours est direct : pour prouver qu'une fonction récursive sans effet de bord est correcte, il suffit de raisonner sur ses arguments et sa valeur de retour. Avec des effets de bord, il faut aussi suivre l'état de tout ce qu'elle peut modifier.

Le paradigme orienté objet : des objets qui collaborent

En programmation orientée objet (POO), les développeurs considèrent le programme comme une collection d'objets en interaction ³. Smalltalk et Java sont des exemples de langages conçus pour supporter ce paradigme ³ ; on cite aussi C++, Simula et Swift ⁴. Au bac, la programmation orientée objet en Python est une compétence régulièrement évaluée ².

Dans ce style, on commence par se demander : quels sont les « êtres » du problème, que savent-ils et que peuvent-ils faire ? Les données (les attributs) et les opérations qui les concernent (les méthodes) sont regroupées dans une classe. Une méthode est l'un des noms que prennent les morceaux réutilisables de programme selon le paradigme ⁴.

ExempleUn compte bancaire

class Compte:
    def __init__(self, titulaire, solde):
        self.titulaire = titulaire
        self.solde = solde

    def deposer(self, montant):
        self.solde = self.solde + montant

    def retirer(self, montant):
        if montant <= self.solde:
            self.solde = self.solde - montant

c = Compte("Inès", 100)
c.deposer(50)
c.retirer(30)
print(c.solde)   # 120

Ici, l'état (solde) appartient à l'objet c, et seules ses méthodes le modifient. Le programme principal ne manipule pas des variables isolées : il envoie des messages à un objet (« dépose 50 », « retire 30 »).

Les paradigmes logique et concurrent

D'autres paradigmes élargissent ta vision de la programmation. Ce ne sont pas ceux que tu pratiques le plus en NSI, mais ils montrent qu'un programme n'est pas toujours une liste d'ordres.

Ces notions se sont surtout répandues quand les ordinateurs ont reçu plusieurs processeurs capables de mener des tâches en parallèle ⁴. C++ et Java permettent de créer et manipuler des threads, et des langages comme Go ont été conçus entièrement pour la gestion de la concurrence ⁴. On parle aussi de programmation orientée processus, où les applications sont des ensembles de processus agissant sur des structures de données partagées ³.

Tu retrouves ce thème dans les sujets du bac : un exercice recensé réunit la programmation orientée objet, une structure de données (la file), l'ordonnancement des processus et l'interblocage ². La concurrence pose en effet des questions nouvelles : que se passe-t-il quand deux tâches veulent la même ressource ?

Un langage, plusieurs paradigmes

Chaque langage de programmation reflète un ou plusieurs paradigmes, avec un ensemble de notions qui servent à exprimer une solution ⁴. Une fois la solution imaginée selon un paradigme, un langage qui le suit permet de l'exprimer ⁴.

La relation entre paradigmes et langages peut donc être complexe. Prenons C++ : il offre des éléments de programmation procédurale, orientée objet et générique, mais rien n'oblige à tous les employer. On peut y écrire un programme entièrement procédural, ou entièrement orienté objet ³. Ce sont les concepteurs et les développeurs qui choisissent la façon de construire le programme ³.

Paradigmes, idée centrale et langages cités
Paradigme	Idée centrale	Exemples de langages
Impératif	Suite d'instructions qui modifient l'état	C, Pascal, Fortran, Cobol
Fonctionnel	Évaluations de fonctions sans états	Haskell
Orienté objet	Objets en interaction	Smalltalk, Java, Simula, Swift
Logique	Recherches dans un ensemble de faits par déduction	Langages à règles et requêtes
Concurrent	Plusieurs tâches en même temps	C++, Java, Go
Multi-paradigmes	Plusieurs approches possibles	Python, C++, OCaml, Scala

Paradigmes, idée centrale et langages cités · D'après les exemples de langages donnés dans les sources du cours.

Comparer et reconnaître les paradigmes

Au bac comme dans la vie courante, tu dois pouvoir regarder un morceau de code et dire dans quel style il est écrit. Voici une grille de lecture.

ExempleUn même problème, plusieurs écritures

Calculer le prix total d'une liste de prix en appliquant une réduction de 10 %.

# impératif : on accumule dans une variable
def total_imperatif(prix):
    t = 0
    for p in prix:
        t = t + p * 0.9
    return t

# fonctionnel : on compose des évaluations
def total_fonctionnel(prix):
    if prix == []:
        return 0
    return prix[0] * 0.9 + total_fonctionnel(prix[1:])

# objet : l'état est dans un panier
class Panier:
    def __init__(self):
        self.prix = []
    def ajouter(self, p):
        self.prix.append(p)
    def total(self):
        return sum(p * 0.9 for p in self.prix)

Mathématiquement, les trois donnent le même total (aux arrondis des nombres à virgule près). Ce qui change, c'est la manière d'organiser le calcul : un compteur qui évolue, une définition par réduction du problème, ou un objet qui garde ses données.

Paradigmes et programmation au bac

À l'épreuve écrite de NSI, le candidat traite plusieurs exercices indépendants, sans calculatrice ; les programmes s'écrivent en Python et les requêtes de base de données en SQL ². Une épreuve pratique d'une heure sur machine s'y ajoute ². Les paradigmes n'apparaissent pas toujours sous leur nom, mais tu les mobilises à chaque question de programmation.

Exercices corrigés

Exercice 1 Même calcul, deux styles

★☆☆Environ 10 min

On veut calculer la somme des carrés des entiers de 1 à 5.

Écris une fonction impérative somme_carres_imp(n) qui utilise une boucle for et une variable total.
Écris une fonction récursive sans variable modifiée somme_carres_rec(n).
Donne la valeur renvoyée pour n = 5.

Indice 1

Pour la version récursive, la somme des carrés de 1 à n vaut n au carré plus la somme des carrés de 1 à n-1.

Indice 2

Le cas de base est n = 0, avec la valeur 0.

Voir la correction pas à pas

Version impérative : on initialise total = 0, on parcourt for k in range(1, n + 1) et on fait total = total + k * k, puis return total.
Version récursive : si n == 0, on renvoie 0 ; sinon on renvoie n * n + somme_carres_rec(n - 1).
Calcul pour n = 5 : 1 + 4 + 9 + 16 + 25 = 55.
Les deux versions donnent 55, mais seule la première modifie une variable au fil de l'exécution.

Le résultat est 55. La version impérative repose sur l'évolution de total ; la version fonctionnelle définit le résultat par réduction du problème, sans état modifié.

Exercice 2 Un compte en objet

★★☆Environ 15 min

On reprend la classe Compte du cours. On exécute :

c = Compte("Inès", 200)
c.deposer(80)
c.retirer(50)
c.deposer(20)

Quel est l'attribut modifié par les appels de méthodes ?
Quelle est la valeur de c.solde à la fin ?
Peut-on dire que deposer est une fonction sans effet de bord ? Justifie.

Indice 1

Suis la valeur de solde après chaque appel.

Indice 2

Demande-toi si deposer renvoie quelque chose, ou si elle change l'objet.

Voir la correction pas à pas

L'attribut modifié est solde : chaque méthode agit sur self.solde.
Après la création, le solde vaut 200.
Après deposer(80) il vaut 280 ; après retirer(50) (50 est inférieur ou égal à 280) il vaut 230 ; après deposer(20) il vaut 250.
La méthode deposer ne renvoie rien : son rôle est de modifier l'objet. Elle a donc un effet de bord, et c'est normal en programmation objet, où l'état appartient à l'objet.

Le solde final est 250. En POO, les méthodes modifient l'état de l'objet : ce n'est pas du style fonctionnel pur, mais cela reste maîtrisé puisque seul l'objet touche à ses données.

Exercice 3 Réécrire sans effet de bord

★★★Environ 15 min

Voici une fonction :

def double(liste):
    for i in range(len(liste)):
        liste[i] = 2 * liste[i]

On exécute L = [1, 2, 3] puis double(L). Que vaut L ensuite ?
Explique pourquoi cette fonction a un effet de bord.
Écris une version double_pure(liste) sans effet de bord, qui laisse liste intacte.
Dans quel paradigme se range chacune des deux versions ?

Indice 1

La fonction n'a pas de return : où le résultat est-il donc stocké ?

Indice 2

Construis une nouvelle liste plutôt que de modifier celle reçue.

Voir la correction pas à pas

Après l'appel, L vaut [2, 4, 6] : la liste d'origine a été modifiée en place.
Il y a effet de bord car la fonction change un objet qui existe hors d'elle (la liste reçue en argument) au lieu de renvoyer une valeur.
Version sans effet de bord : def double_pure(liste): return [2 * x for x in liste]. Elle crée une nouvelle liste ; l'originale reste [1, 2, 3].
double relève du style impératif (modification d'un état) ; double_pure suit l'esprit fonctionnel (résultat dépendant uniquement de l'argument, sans modification).

Quand une fonction modifie son argument, elle a un effet de bord. La version qui renvoie une nouvelle liste est plus facile à raisonner, ce qui rejoint l'intérêt du style fonctionnel pour vérifier un programme.

Quiz

8 questions · correction immédiate · ton score reste sur ton appareil.

Que désigne un paradigme de programmation ?
Un langage de programmation particulierUne façon d'approcher la programmation et de formuler la solution d'un problèmeUne méthode d'organisation d'une équipe de développeursUn type de variable
Dans quel paradigme le programme est-il vu comme une collection d'objets en interaction ?
FonctionnelLogiqueOrienté objetStructuré
Quelle technique la programmation fonctionnelle pure interdit-elle ?
La récursivitéLes effets de bordL'usage de fonctionsLes listes
Python supporte plusieurs paradigmes de programmation.
VraiFaux
Quelle instruction la programmation structurée cherche-t-elle à supprimer des programmes impératifs ?
La boucle forL'instruction ifL'instruction gotoL'affectation
Quelles affirmations sur le paradigme concurrent sont correctes ? (plusieurs réponses)

Plusieurs réponses possibles.
Un programme peut effectuer plusieurs tâches en même tempsIl introduit la notion de threadIl interdit toute variableIl permet de créer et de manipuler des threads, par exemple en Java
On considère :
```
def f(liste):
    if liste == []:
        return 0
    return liste[0] ** 2 + f(liste[1:])
```
Quelle valeur renvoie f([1, 2, 3]) ?
Ta réponse
On calcule 1 + 4 + 9 = 14. La fonction est récursive et sans effet de bord : chaque appel renvoie une valeur, aucune variable n'est modifiée. Oublier le carré donne 6, ce qui serait la somme simple des éléments.
Une fonction reçoit une liste en argument, la modifie en place avec append, et ne renvoie rien. Que peut-on dire ?
Elle est une fonction pureElle a un effet de bordElle est forcément récursiveElle relève du paradigme logique

Les questions qu'on se pose

Faut-il choisir un seul paradigme pour un programme ?

Non. La plupart des langages contemporains permettent d'adopter plusieurs paradigmes à condition qu'ils soient compatibles ⁴. Dans un même programme Python, tu peux avoir des classes (objet), des méthodes qui modifient des attributs (impératif) et des fonctions récursives sans effet de bord (fonctionnel). L'important est que le style soit cohérent dans chaque partie du code.

À quoi sert de connaître les paradigmes si je programme déjà en Python ?

À mieux choisir comment écrire une solution et à mieux lire le code des autres. Un paradigme détermine la vue qu'on a de l'exécution du programme ³ : savoir en changer te donne plusieurs façons d'attaquer un problème. C'est aussi utile pour répondre à une question d'examen qui demande de justifier un choix de conception.

Comment savoir si un code est fonctionnel ou impératif ?

Regarde si des variables sont modifiées au fil de l'exécution. Si oui (compteur dans une boucle, liste modifiée en place), le style est impératif. Si le résultat est obtenu en composant des appels de fonctions qui ne modifient rien, souvent par récursivité, le style est fonctionnel. Un indice fiable : la présence ou non d'effets de bord, que la programmation fonctionnelle pure interdit ³.

La programmation orientée objet est-elle au programme du bac NSI ?

Oui : des sujets recensés comportent des exercices sur la programmation orientée objet en Python, associée à l'algorithmique ou aux structures de données ². Prépare-toi à lire une classe, à compléter une méthode et à comprendre comment l'état d'un objet évolue (voir l'exercice sur le compte).

Les paradigmes logique et concurrent sont-ils à connaître en détail ?

Dans ce cours, retiens leur idée de base : le paradigme logique répond à une question par des recherches dans un ensemble de faits, avec des règles de déduction ⁴, et le paradigme concurrent permet d'exécuter plusieurs tâches en même temps ⁴. Il s'agit surtout de reconnaître ces paradigmes et de les distinguer de l'impératif, de l'objet et du fonctionnel que tu pratiques en Python.

Sources

Programme visé : Programmes et ressources - Numérique et Sciences Informatiques (voie générale) · Ministère de l'Éducation nationale / Éduscol

Programmes et ressources - Numérique et Sciences Informatiques (voie générale), Ministère de l'Éducation nationale / Éduscol. Consulté le 7 novembre 2026.
Spécialité NSI - Numérique et Sciences Informatiques, Éduscol STI. Consulté le 7 novembre 2026.
Paradigme (programmation), Wikipédia. Consulté le 7 novembre 2026.
Langage de programmation, Wikipédia. Consulté le 7 novembre 2026.

Les numéros dans le texte renvoient à ces sources. Une source qui ne dit pas ce qu'on lui fait dire ? Signale-le.

Signaler une erreur sur cette page

Paradigmes de programmation : cours de Terminale NSI

L'essentiel

Pourquoi parler de paradigmes ?

Le paradigme impératif : donner des ordres

Le paradigme fonctionnel : composer des fonctions

Le paradigme orienté objet : des objets qui collaborent

Les paradigmes logique et concurrent

Un langage, plusieurs paradigmes

Comparer et reconnaître les paradigmes

Paradigmes et programmation au bac

Exercices corrigés

Exercice 1 Même calcul, deux styles

Exercice 2 Un compte en objet

Exercice 3 Réécrire sans effet de bord

Quiz

Les questions qu'on se pose

Sources

Primaire

Collège

Lycée

Supérieur