Utiliser les paradigmes impératifs et fonctionnels
- Fiche de cours
- Quiz
- Profs en ligne
- Videos
- Application mobile
- 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.
- 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.
Définir et écrire une fonction en Python (1re).
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.
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.
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 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.
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.
En Python, le code suivant permet de calculer la moyenne du tableau tab = [1, 2, 3, 4, 5].
| Python | Explication |
|
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.
| Python | Explication |
| 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. |
|
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. |
| print(moyenne(tab)) | On affiche la moyenne. |
Ce code peut paraitre 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.
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.
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.
En Python, on considère la fonction func1(a) suivante.
| Python | Explication |
| n = 5 | On affecte 5 à la variable n. |
| def func1(a): | On définit la fonction func1(a) |
| 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 + a | On affecte n + a à la variable n |
| return n | On retourne n. |
Cette fonction est impure car n est une variable externe à la fonction func1(a).
En testant func1(2) deux fois de suite, on n’obtient d’ailleurs pas le même résultat.
On peut également considérer la fonction func2(a) suivante, qui est pure.
| Python | Explication |
| def func2(a): | On définit la fonction func2(a). |
| return a + 5 | On retourne a + 5. |
Si on teste func2(2) deux fois de suite, on obtient ici le même résultat.
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.
Voici deux manières d’écrire la fonction carre qui prend en paramètre un nombre a et retourne son carré.
| Fonction classique | Lambda fonction |
|
def carre(a): return a*a |
carre = lambda a : a*a |
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.
map(func, tab) prend ainsi en paramètres une fonction func 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 func.
La fonction list() permet d’en obtenir une liste.
Pour créer le tableau des carrés du tableau tab = [1, 2, 3, 4, 5], il suffit d’exécuter le code list(map(lambda x : x*x, tab)).
filter(func, tab) prend ainsi en paramètres une fonction func 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 func.
Pour créer le tableau des nombres pairs de tab = [1, 2, 3, 4, 5], il suffit d’exécuter le code list(filter(lambda x : x%2 == 0, tab)).
reduce(func, tab), du module functools, prend ainsi en paramètres une fonction func à deux paramètres et un tableau tab (ou un objet itérable) ; cette fonction retourne une valeur.
- Au premier appel, les deux premiers éléments de tab sont les arguments de func.
- Le résultat et le troisième élément de tab sont ensuite les arguments de func, et ainsi de suite.
- Ainsi, après le parcours de tous les éléments de tab, la valeur finale est retournée.
Pour calculer la somme des éléments de tab = [1, 2, 3, 4, 5], il suffit d’exécuter le code reduce(lambda a, b : a+b, tab).
Voici un code qui permet de calculer la moyenne des éléments de tab = [1, 2, 3, 4, 5].
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.
Comment as-tu trouvé ce cours ?
Évalue ce cours !
Vous avez obtenu75%de bonnes réponses !
Recevez l'intégralité des bonnes réponses ainsi que les rappels de cours associés :
Fiches de cours les plus recherchées
NSI
Utiliser le paradigme objet
NSI
Repérer les bugs : typages, effets de bords, débordements
NSI
Repérer les bugs : structures
NSI
Anticiper les erreurs classiques
NSI
Utiliser Python pour déterminer les mesures des arbres binaires
NSI
Utiliser Python dans les arbres binaires de recherche
NSI
Rechercher et insérer une clé dans un arbre binaire de recherche
NSI
Parcourir un arbre binaire
NSI
Se déplacer dans un graphe
NSI
Utiliser la méthode « diviser pour régner »
Fermer
Accédez gratuitement à
