Paradigmes de programmation

Langages de programmation

Paradigme de programmation

Il existe un grand nombre de paradigmes de programmation, le programme de la NSI se concentre sur la programmation impérative, la programmation fonctionnelle et la programmation objet.

Certains langages sont très liés à certains paradigmes mais la plupart permettent de mettre en œuvre plusieurs paradigmes ; c’est le cas de Python :

• Impératif : Simple statements et Compound statements ;
• Fonctionnel : Functional Programming HOWTO ;
• Objet : Classes.

Programmation impérative

Les « langages impératifs » sont les plus répandus parmi l’ensemble des langages de programmation et sont ceux qui sont les plus proches du fonctionnement des processeurs : exécuter une suite d’instructions élémentaires.

Mots clés pour repérer un langage impératif

• affectation, mémoire, instruction, boucle, mutabilité, effets de bord, …

Exemples de langages impératifs

• Langage machine, C, Bash, Perl, Tcl, Python, PHP, Java, JavaScript, …

Usage typique

• Lorsque le programme à réaliser s’exprime sous forme d’actions à réaliser. Les actions reflètent les changements dans l’environnement (mémoire) du programme.
• Dans le cadre de la programmation système, pour une gestion manuelle, potentiellement fine, de l’allocation mémoire.

Programmation fonctionnelle

Remarque

• La mise en œuvre des langages fonctionnels fait un usage sophistiqué de la pile (cf. chapitre 1 sur la récursivité et chapitre 8 sur la structure de pile) car, afin de s’affranchir de la nécessité de stocker des données temporaires dans des tableaux, ils font largement appel à la récursivité. L’une des multiples techniques pour rendre la compilation de la récursivité plus efficace est une technique dénommée récursion terminale (en anglais : tail-recursion), qui consiste à accumuler les résultats intermédiaires dans une case mémoire de la pile et à la passer en paramètre dans l’appel récursif. Ceci permet d’éviter d’empiler les appels récursifs dans la pile en les remplaçant par une simple succession de sauts. Le code généré par le compilateur est alors similaire à celui généré par une boucle en impératif.

• La programmation fonctionnelle éliminant les effets de bord (fonctions pures), il est plus facile de faire effectuer des calculs en parallèle aux programmes développés dans un style fonctionnel pur.

Mots clés pour repérer un langage impératif

• déclaratif, expressions, immutabilité, ordre supérieur, $\lambda$-calcul, fonction pure, …

Exemples de langages fonctionnels

• Haskell, Lisp, Scheme, OCaml, …

Usage typique

• Manipulations de haut niveau ;
• Calculs algébriques, abstraits ;
• Écriture de compilateurs.

Comparaison des deux styles de programmation

1. Style impératif

   1 2 3 4 5 6 7 8 9 10

   from typing import List def somme(liste: List[float]) -> float: """ Calcule la somme des éléments de la liste liste. """ somme = 0 for nbre in liste: somme = somme + nbre return somme

   Cette fonction manipule la variable locale somme et utilise une boucle for. Le paradigme utilisé est bien impératif.

2. Style fonctionnel

   1 2 3 4 5 6 7 8 9 10

   from typing import List def somme(liste: List[float]) -> float: """ Calcule la somme des éléments de la liste liste. """ if len(liste) == 0: return 0 else: return liste[0] + somme(liste[1:])

   Cette fonction ne manipule aucune variable et n’utilise pas de boucle mais la récursivité. Le paradigme employé est bien fonctionnel.

Remarque : liste[1:] est une sous-liste de liste dans laquelle le premier élément de liste n’est pas présent.

2. Style fonctionnel avec récursion terminale

   1 2 3 4 5 6 7 8 9 10

   from typing import List def somme(liste: List[float], total: float = 0) -> float: """ Calcule la somme des éléments de la liste liste. """ if len(liste) == 0: return total else: return somme(liste[1:], liste[0] + total)

1
2
3
4

def elevation_puissance(n: int) -> float:
    """
    Retourne le nombre demandé à l'utilisateur à la puissance n.
    """

1
2
3
4
5
6
7

def elevation_puissance(n: int) -> float:
    """
    Retourne le nombre demandé à l'utilisateur à la puissance n.
    """
    x = float(input("Veuillez entrer le nombre à élever à la puissance n : "))

    return x**n

Il est évident que deux appels successifs à la fonction elevation_puissance avec le même argument (2 par exemple) pourront renvoyer des valeurs différentes puisque celles-ci dépendent de la valeur entrée par l’utilisateur. Cette fonction n’est pas une fonction pure ; sa définition n’est pas acceptable du point de vue de la programmation fonctionnelle.

1. Style impératif avec effet de bord.

   1 2 3 4 5 6 7 8 9 10 11

   from typing import List def liste_carre(liste: List[float]) -> None: """ Élève au carré chaque élément de la liste liste. """ for i in range(len(liste)): liste[i] = liste[i]**2 l = [1, 2, 3, 4] liste_carre(l)

   La fonction modifie la liste globale liste ! Le problème a pour origine la mutabilité de la structure de données « liste » et le passage d’une référence à la fonction, et non pas une copie de cette liste.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

from typing import List

def liste_carre(liste: List[float]) -> List[float]:
    """
    Élève au carré chaque élément de la liste liste.
    """
    newList = liste[:]

    def eleve_carre(liste: List[float]) -> List[float]:
        if len(liste) == 0:
            return liste
        else:
            return [liste[0]**2] + eleve_carre(liste[1:])
    
    return eleve_carre(newList)

Programmation objet

Mots clés pour repérer un langage objet

• classes ou prototype, objet, méthode, attribut, champ, statique, encapsulation, héritage, polymorphisme, …

Exemples de langage orientés objets

• C++, Java, Python, OCaml, …

Usage typique

• Développement en équipe de logiciels comportant un très grand nombre de lignes de code.