NSI – Paradigmes de Programmation : Cours et Exemples (Terminale NSI) - Math93

Détails
Etoiles inactivesEtoiles inactivesEtoiles inactivesEtoiles inactivesEtoiles inactives
 

Les Paradigmes de Programmation

Un paradigme de programmation est une approche théorique, une "philosophie" qui guide la manière de structurer un algorithme et de traiter les données. En Terminale NSI, nous étudions comment un même problème peut être résolu selon des angles différents : l'exécution d'ordres (impératif), l'évaluation mathématique (fonctionnel) ou la manipulation d'entités (objet).

1. Le Paradigme Impératif

Le paradigme impératif est le plus proche du fonctionnement physique des ordinateurs (architecture de Von Neumann). Le programme est une suite d'instructions qui modifient l'état de la mémoire.

Définition : État mutable

L'état est l'ensemble des valeurs des variables à un instant donné. On parle de mutation lorsque l'on utilise l'affectation (=) pour changer la valeur d'une variable existante.

Grace Hopper et les débuts : Ce style domine les langages "historiques" comme le Fortran, le C ou le Pascal. On dit à la machine comment faire les choses étape par étape.

Exemple : Somme et Puissance (Style Impératif)

def somme_imperative(n):
    total = 0 # Initialisation de l'état
    for i in range(1, n + 1):
        total = total + i # Mutation de la variable
    return total

def puissance_imperative(x, n):
    r = 1
    for i in range(n):
        r = r * x # Mutation de la variable
    return r

2. Le Paradigme Fonctionnel

Inspiré des mathématiques, ce paradigme traite le programme comme une succession d'évaluations de fonctions. On cherche à supprimer les variables globales et les changements d'état intempestifs.

Concept : Immuabilité

En programmation fonctionnelle pure, les données sont immuables : on ne modifie jamais une liste ou une variable, on en crée une nouvelle version transformée.

Inventé par Alonzo Church dans les années 1930, le lambda-calcul est la base théorique de ce paradigme. Il a donné naissance à des langages comme Lisp, Haskell ou OCaml.

Exemple : Somme et Puissance (Récursivité)

def somme_fonctionnelle(n):
    if n == 0:
        return 0
    return n + somme_fonctionnelle(n - 1)

def puissance_fonctionnelle(x, n):
    if n == 0:
        return 1
    return x * puissance_fonctionnelle(x, n - 1)

3. Focus : Les Effets de Bord

C'est un point central du programme NSI. La distinction entre un code "propre" et un code "imprévisible" repose souvent sur la gestion des effets secondaires.

Définition : Effet de bord

Une fonction possède un effet de bord si elle modifie l'environnement extérieur à sa propre portée. Cela inclut :

  • La modification d'une variable globale.
  • La modification d'un objet (liste, dictionnaire) passé en argument.
  • Une action d'affichage (print()) ou d'écriture disque.

Une fonction sans effet de bord est appelée fonction pure. Elle est prévisible : pour une même entrée, elle donnera toujours la même sortie (transparence référentielle).

Exemple de différence en Python :

# AVEC effet de bord (Impératif)
L = [1, 2, 3]
def ajoute_impure(val):
    L.append(val) # On modifie la liste L externe

# SANS effet de bord (Fonctionnel)
def ajoute_pure(liste, val):
    return liste + [val] # On renvoie une NOUVELLE liste

4. La Programmation Orientée Objet (POO)

Ce paradigme regroupe les données et les traitements dans des entités nommées Objets, issus de modèles appelés Classes.

Les trois piliers :
  • Encapsulation : On protège les données internes.
  • Héritage : On crée des classes à partir de classes existantes.
  • Polymorphisme : Une même méthode s'adapte à l'objet qui l'appelle.

Exemple : Somme et Puissance (Style Objet)

class Calculateur:
    def __init__(self, n):
        self.n = n

    def somme(self):
        return sum(range(self.n + 1))

class Nombre:
    def __init__(self, x):
        self.valeur = x

    def puissance(self, n):
        return self.valeur ** n

5. Le Paradigme Déclaratif

Contrairement aux styles précédents qui décrivent comment résoudre le problème, le style déclaratif décrit quel résultat est attendu.

Le langage SQL est l'exemple type : SELECT nom FROM table WHERE age > 18;. On ne programme pas la boucle de recherche, on définit les critères du résultat.

6. Synthèse Comparative

CritèreImpératifFonctionnelObjet
Philosophie Séquence d'ordres Évaluation de fonctions Interaction d'objets
Données Mutables (changeantes) Immuables (fixes) Encapsulées
Somme 
def somme(n):
    t = 0
    for i in range(n+1):
        t += i
    return t
 
def somme(n):
    if n == 0:
        return 0
    return n + somme(n-1)
 
class Calc:
    def __init__(self, n):
        self.n = n
    def res(self):
        return sum(range(self.n+1))
Puissance 
def p(x, n):
    r = 1
    for i in range(n):
        r *= x
    return r
 
def p(x, n):
    if n == 0:
        return 1
    return x * p(x, n-1)
 
class Num:
    def __init__(self, x):
        self.x = x
    def exp(self, n):
        return self.x ** n

Articles Connexes