Programmation fonctionnelle

I. Les paradigmes impératif et fonctionnel

Objectifs

• Comprendre la notion de paradigme de programmation
• Comprendre les notions de paradigme impératif et de paradigme fonctionnel
• Utiliser le paradigme impératif et le paradigme fonctionnel en Python

A savoir

• Un paradigme de programmation est la manière de formuler le traitement informatique de la résolution d’un problème.
• Le paradigme impératif consiste à écrire les instructions des codes les unes à la suite des autres dans l’ordre de leur exécution.
• Le paradigme impératif autorise l’utilisation des fonctions pour éviter de répéter du code.
• Le paradigme fonctionnel consiste à écrire les codes sous la forme d’un ensemble de fonctions.

II. Les paradigmes de programmation

Lorsque l’on veut écrire un programme informatique pour résoudre un problème, on choisit une manière d’écrire le code, une manière de structurer et d’écrire les instructions : on choisit un paradigme de programmation. Un paradigme de programmation est la manière de formuler le traitement informatique de la résolution d’un problème.

Les paradigmes de programmation | Cédric Gerland (20:51)

III. Le paradigme impératif

3.1. Généralités

Le paradigme de programmation le plus ancien est le paradigme impératif, autrement appelé « programmation impérative ».

Ce paradigme est à l’origine de nombreux langages de programmation tels que les langages C, Pascal ou Basic. Dans un paradigme impératif, les instructions sont exécutées de manière séquentielle, c’est-à-dire les unes après les autres dans l’ordre dans lequel elles ont été écrites. En programmation impérative, l’ordre d’exécution du code a de l’importance.

Ce type de programmation est à l’origine de tous les autres types de programmation et se base sur l’utilisation des structures conditionnelles (if), des boucles (while et for) ainsi que des affectations. On distingue deux sous-types de paradigmes impératifs : le paradigme séquentiel et le paradigme procédural. Leur différence tient dans le fait que la programmation procédurale autorise l’usage de fonctions pour réutiliser du code, alors que la programmation séquentielle ne l’autorise pas.

On apprend généralement la programmation en commençant par le paradigme impératif. En pratique, lorsque l’on parle de paradigme impératif, il s’agit en réalité du paradigme procédural, car l’usage des fonctions est recommandé pour éviter de répéter du code.

3.2. Exemple avec Python

Le paradigme impératif est supporté par la plupart des langages de programmation.

Le langage Python est un langage multi-paradigme, qui autorise naturellement la programmation impérative.

Exemple de code en programmation impérative

🐍 Editeur

"""
Code permettant de calculer la moyenne du tableau tab = [1, 2, 3, 4, 5]
"""
tab = [1, 2, 3, 4, 5]     # On définit le tableau.
somme = 0                 # On initialise la somme des éléments de tab à 0.
for elt in tab:           # On parcourt le tableau tab et on affecte à elt les éléments de tab.}
    somme = somme + elt   # On ajoute elt à la somme précédente.
moyenne = somme/len(tab)  # On affecte à la variable moyenne le quotient de la variable somme et de la taille du tableau tab.
print(moyenne)            # On affiche la moyenne.

On utilise ici le paradigme séquentiel car les instructions sont exécutées ligne par ligne.

En programmation procédurale, cela peut donner le code suivant :

Exemple de code en programmation procédurale

🐍 Editeur

"""
Autre code permettant de calculer la moyenne du tableau tab = [1, 2, 3, 4, 5]
"""
tab = [1, 2, 3, 4, 5]             # On définit le tableau.

def somme(tab):                   # On définit la fonction somme qui prend en paramètre tab un tableau de nombres et retourne la somme de ses éléments.
    resultat = 0
    for elt in tab:
        resultat = resultat + elt
    return resultat

def moyenne(tab):                 # On définit la fonction moyenne qui prend en paramètre tab un tableau de nombres et retourne la moyenne de ses éléments.
    n = len(tab)
    return somme(tab)/n

print(moyenne(tab))               # On affiche la moyenne.

Ce code peut paraître plus long que le précédent, mais les fonctions somme(tab) et moyenne(tab) seront directement réutilisables sans nécessité de les coder à nouveau car elle ont été définies.

3.3. Avantages et inconvénients

L’avantage principal de la programmation impérative est que le code est très lisible, ce qui en facilite l’apprentissage.

Ce paradigme produit toutefois vite des programmes volumineux, les codes peuvent ainsi perdre en clarté. De plus, en cas de modification ou de mise à jour du code, la programmation impérative peut induire un bon nombre de bugs puisque il faut relire le code dans son entier et effectuer de nombreuses retouches.

IV. Le paradigme fonctionnel

4.1. Généralités

Le paradigme fonctionnel consiste à décomposer les programmes réalisés en un ensemble de fonctions.

En programmation fonctionnelle l’ordre d’exécution du code n’a aucune importance.

La programmation fonctionnelle consiste à écrire le résultat que devra rendre la fonction selon les données fournies. Ce résultat est décrit par une expression dépendant des paramètres de la fonction et est noté en Python après le mot-clé return. Il n’est plus utile ici de décrire une suite d’instructions, comme en programmation impérative. Seul le résultat compte. Si l’écriture de l’expression résultat est trop complexe, il est possible de décomposer le problème et de présenter l’écriture du résultat comme la composition de plusieurs fonctions intermédiaires. Il est aussi possible de décomposer par cas grâce à l’expression conditionnelle.

Fonctions pures et impures

Les fonctions doivent idéalement produire des sorties qui ne dépendent strictement que de leurs arguments, sans que ces sorties ne dépendent de variables externes à la fonction elle-même. On parle alors de « fonctions pures ».

A contrario, les fonctions qui ne respectent pas ce principe sont appelées des « fonctions impures ».

Exemple de fonction impure

🐍 Editeur

n = 5          # On affecte 5 à la variable n.

def fonc1(x):  # On définit la fonction fonc1(x).
    global n   # Dans la fonction, on déclare la variable n comme globale, elle est la même que celle de la première ligne.
    n = n + x  # On affecte n + x à la variable n.
    return n   # On retourne n.

Cette fonction est impure car n est une variable externe à la fonction fonc1(a).

En testant fonc1(2) deux fois de suite, on n’obtient d’ailleurs pas le même résultat.

Exemple de fonction pure

🐍 Editeur

def fonc2(x):     # On définit la fonction fonc2(x).
    return x + 5  # On retourne x + 5.

Si on teste fonc2(2) deux fois de suite, on obtiendra bien alors le même résultat.

4.2. Avec Python

Le paradigme impératif n’est pas supporté par tous les langages de programmation.

Le langage Python offre un certain nombre d’outils pour utiliser le paradigme fonctionnel.

• Les lambda fonctions ou fonctions anonymes Elles permettent de définir des fonctions sans le mot-clé def et pour lesquelles le mot-clé return est implicite. Ces fonctions utilisent le mot-clé lambda.

  Exemple de lambda fonction

  🐍 Editeur

  """
  Deux façons d’écrire la fonction carre qui prend en paramètre un nombre a et retourne son carré.
  """
  carre(a):               # Fonction classique
      return a*a
  
  carre = lambda a : a*a  # Lambda fonction
  

  Dans les deux cas, l’utilisation de la fonction est la même. Par exemple, carre(3) retournera 9.

  Dans cet exemple, la lambda fonction est référencée par la variable carre.

  Il est possible de ne pas utiliser de variable qui référence une lambda fonction, notamment avec les fonctions map, filter et reduce.

• La fonction map

  La fonction map permet d’appliquer une fonction à tous les éléments d’un tableau.

  map(fonc, tab) prend ainsi en paramètres une fonction fonc et un tableau tab (ou un objet itérable) ; cette fonction retourne un itérateur dont les éléments sont les images des éléments de tab par la fonction fonc.

  La fonction list() permet d’en obtenir une liste.

  Exemple d'utilisation de la fonction map

  🐍 Editeur

  """
  On veut créer le tableau des carrés du tableau tab = [1, 2, 3, 4, 5].
  """
  list(map(lambda x : x*x, tab))
  

• La fonction filter

  La fonction filter permet de filtrer les éléments d’un tableau.

  filter(fonc, tab) prend ainsi en paramètres une fonction fonc qui retourne True ou False et un tableau tab (ou un objet itérable) ; cette fonction retourne un itérateur dont les éléments de tab ont True pour image par la fonction fonc.

  Exemple d'utilisation de la fonction filter

  🐍 Editeur

  """
  On veut créer le tableau des nombres pairs de tab = [1, 2, 3, 4, 5].
  """
  list(filter(lambda x : x%2 == 0, tab))
  

• La fonction reduce

  La fonction reduce permet de calculer une valeur à partir d’une fonction et de tous les éléments d’un tableau.

  reduce(fonc, tab), du module functools, prend ainsi en paramètres une fonction fonc à deux paramètres et un tableau tab (ou un objet itérable) ; cette fonction retourne une valeur.

  Principe

  Au premier appel, les deux premiers éléments de tab sont les arguments de fonc.

  Le résultat et le troisième élément de tab sont ensuite les arguments de fonc, et ainsi de suite.

  Ainsi, après le parcours de tous les éléments de tab, la valeur finale est retournée.

  Exemple d'utilisation de la fonction reduce

  🐍 Editeur

  """
  On veut calculer la somme des éléments de tab = [1, 2, 3, 4, 5].
  """
  reduce(lambda a, b : a+b, tab)
  

4.3. Avantages et inconvénients

L’avantage principal du paradigme fonctionnel est de produire des codes courts et faciles à débugger. Il suffit de tester chacune de ses fonctions pour valider les codes.

La programmation fonctionnelle n’est toutefois pas facile à appréhender, elle demande une certaine expertise. Elle ne convient de plus pas à toutes les tâches.

Le paradigme fonctionnel (doc. Eduscol)

Fichier PDF

Block2py : programmation impérative ou fonctionelle par blocs

Application Block2py (en ligne)