Paradigmes impératif, fonctionnel et objet

Décrire des changements avec l’impératif

Dans une approche impérative, le programme précise une suite d’instructions qui transforment un état. Un accumulateur initialement nul peut recevoir successivement les carrés des valeurs d’une liste. Les affectations, conditions et boucles rendent explicite l’ordre des opérations.

total = 0
for x in [2, 3, 4]:
    total = total + x * x

Cette forme est naturelle pour suivre une procédure étape par étape. Pour comprendre le résultat, on suit l’évolution de total : zéro, quatre, treize, puis vingt-neuf. Les états intermédiaires sont une aide, mais deviennent difficiles à suivre si beaucoup de variables partagées changent à plusieurs endroits.

Composer des transformations avec le fonctionnel

Une approche fonctionnelle privilégie l’expression de résultats par des fonctions et leur composition. Une fonction pure renvoie un résultat déterminé par ses arguments et n’a pas d’effet de bord observable. Elle est facile à tester isolément : les mêmes arguments donnent le même résultat dans le modèle considéré.

def carre(x):
    return x * x

total = sum(carre(x) for x in [2, 3, 4])

Cette expression met en avant « transformer chaque valeur puis additionner ». Python permet ce style sans être un langage exclusivement fonctionnel. Une fonction qui modifie une liste reçue n’est pas pure simplement parce qu’elle est écrite avec def.

Regrouper état et opérations avec les objets

Le paradigme objet organise des entités possédant des attributs et des méthodes. Un compteur peut conserver une valeur et proposer une méthode incrementer. Plusieurs instances partagent les mêmes règles tout en conservant des états distincts. Cette organisation convient notamment à la modélisation d’entités qui évoluent et interagissent.

Pour reprendre le même calcul de somme de carrés, un objet peut conserver le total et proposer une opération d’ajout. Chaque instance commence avec son propre total nul.

class SommeCarres:
    def __init__(self):
        self.total = 0

    def ajouter(self, valeur):
        self.total += valeur * valeur

calcul = SommeCarres()
for valeur in [2, 3, 4]:
    calcul.ajouter(valeur)
print(calcul.total)  # 29

Un objet n’est pas seulement un dictionnaire déguisé : son interface peut exprimer les opérations autorisées et préserver des règles. Pour une pile, empiler et dépiler définissent un usage cohérent. En NSI, classes, attributs, objets et méthodes suffisent à travailler cette approche ; héritage et polymorphisme ne sont pas des exigences de cette introduction.

Choisir en fonction de la tâche

Une petite boucle de recherche peut être très claire en impératif. Une chaîne de transformations de données peut se lire naturellement en style fonctionnel. Une simulation de véhicules, de capteurs ou de joueurs peut bénéficier d’objets représentant les entités. Ces exemples donnent des raisons de choisir, pas des règles absolues.

Un même programme peut combiner plusieurs paradigmes : un objet expose une méthode dont le corps utilise une boucle et appelle une fonction pure. Le langage autorise des styles ; il ne suffit pas de connaître son nom pour classer chaque programme. Pour justifier une réponse, citez des caractéristiques observables plutôt qu’une étiquette isolée.

Choisir un style implique aussi de préciser ce qui change et ce qui reste observable. Pour comparer deux versions, fixez la même entrée, le même résultat attendu et les mêmes obligations sur la mutation. Une fonction qui renvoie la bonne somme mais efface l’entrée ne respecte pas forcément le même contrat.

Exemple suivi : trois organisations pour le même traitement

On veut totaliser les carrés des seules valeurs positives de [-2,3,0,4]. En impératif, un accumulateur part de zéro et reçoit le carré de chaque valeur vérifiant x > 0. Il devient 9 puis 25. En style fonctionnel, on exprime la transformation puis l’agrégation avec sum(x*x for x in valeurs if x > 0). Les valeurs négatives et zéro sont filtrées ; les carrés restants sont additionnés.

En objet, une instance peut conserver un total et proposer une méthode qui ajoute une mesure positive après l’avoir mise au carré. Ce choix devient utile si les mesures arrivent successivement et si plusieurs calculs indépendants coexistent. Pour un calcul unique de quatre nombres, la classe ajoute des éléments à comprendre ; elle ne garantit pas une meilleure solution. Comparez la correspondance avec le problème, l’interface, les effets observables et la facilité des tests.

Exemple suivi : repérer un état caché

Une fonction reçoit x, ajoute x à une liste globale puis renvoie la somme de cette liste. Avec une liste globale vide, l’appel sur 2 renvoie 2 ; le second appel sur 2 renvoie 4. Le résultat dépend donc de l’histoire du programme. Une fonction carre(x) renvoyant x*x conserve au contraire le même résultat pour les mêmes arguments et ne modifie aucun état extérieur.

Pour rendre le premier traitement explicite, on peut recevoir une liste en paramètre et renvoyer une nouvelle liste contenant l’élément ajouté. L’appelant choisit ensuite de conserver ou non ce nouvel état. On peut aussi encapsuler l’historique dans un objet dont l’interface annonce la mutation. Les deux organisations rendent le changement identifiable, mais seule la première peut être pure si elle ne modifie pas l’entrée. La présence de def, d’une compréhension ou d’un objet ne suffit pas à conclure sans examiner les effets.

De la compréhension à l’autonomie

À vous de résoudre

Cherchez d’abord par vous-même. Vérifiez les résultats demandés, utilisez les indices si nécessaire, puis comparez votre méthode à la correction.

Les erreurs qui méritent un détour

Assimiler toute fonction à la programmation fonctionnelle.

Une fonction peut modifier des états et être utilisée dans tous les styles.

Chercher un paradigme meilleur dans tous les cas.

La structure du problème et la lisibilité motivent le choix.

Le prochain pas

• Mutabilité, références et effets de bord
• Concevoir et mener un projet de NSI

Retrouver le catalogue de Terminale

Ce chapitre s’appuie sur le programme officiel de Terminale (PDF, nouvel onglet). Les explications et exercices sont proposés pour l’apprentissage.