Les cours du BTS SIO

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Python : programmation fonctionnelle ======
===== Ressources =====
  * https://python.developpez.com/tutoriels/apprendre-programmation-fonctionnelle/
===== Présentation =====
Le **paradigme de programmation fonctionnelle** se caractérise essentiellement par l'**absence d'effets de bord**. 

Pour cela, le code défini à l'intérieur d'une fonction :
    * **ne dépend pas** de données se trouvant à l'extérieur de cette fonction courante ;
    * et le code à l'intérieur de la fonction **ne modifie pas** des données à l'extérieur de cette fonction.

===== Exemples =====
  * voici une fonction **qui n'utilise pas ce paradigme de programmation fonctionnelle** :
<code python>
a = 0
def augmenter():
    global a
    a = a + 1
</code>

<WRAP center round info>
**Explications** :
  * la variable **a** est définie à l'extérieur de la fonction **augmenter()** ;
  * Il est précisé dans le corps de la fonction **augmenter()** que la variable **a** est définie comme **globale** ;
  * lors de l'exécution de la fonction **augmenter()**, la valeur de la variable **a** est **changée** pour **passer de 0 à 1**. Comme il s'agit d'une variable **a** **globale**, sa valeur est maintenant **changée pour l'ensemble du programme** et pas seulement à l'intérieur de la fonction **augmenter()**.
</WRAP>
  * Voici la même fonction une fonction **augmenter()** en utilisant la programmation fonctionnelle :
<code python>
def increment(a):
    return a + 1
</code>
<WRAP center round info>
**Explications** :
  * la variable **a** est passée en paramètre à la fonction **augmenter()** ;
  * cette fonction retourne la **valeur de a augmentée de 1** mais **sans modifier** la valeur intiale de a qui reste alors à 0.
  * Il n'y a pas d'effet de bord : à l'issue de l'exécution de la fonction **augmenter()**, la valeur de la variable **a n'a pas changée**.
</WRAP>

====== Itérer sur des listes ======
La programmation fonctionnelle est particulièrement intéressant pour intervenir sur des listes. Les exemple qui suivent s'appuie sur la liste de Todos suivantes :
<code python>
taches = [{"id":"1","libelle":"Préparer mon sac", "accomplie":True},
          {"id":"2","libelle":"Prendre mon petit-déjeuner", "accomplie":False},
          {"id":"3","libelle":"Partir au lycée", "accomplie":False}]
</code>

===== La fonction map =====
  * La fonction **map** prend en argument une **fonction** et une **collection de données** ; 
  * Elle **crée** une nouvelle collection vide ; 
  * **applique** la fonction à chaque élément de la collection d'origine et insère les valeurs de retour produites dans la nouvelle collection ;
  * elle renvoie alors la nouvelle collection.

Voici l'utilisation de la fonction **map** pour avoir une nouvelle liste **tachesfinies** avec toutes les tâches finies :

<code python>
# definition de la fonction qui met la valeur True pour la donnée acccomplie 
def fini(tache):
  return {"id":tache["id"],"libelle":tache["libelle"], "accomplie":False}

#nouvelle liste avec toutes taches accomplies
tachesfinies = list(map(fini,taches))
</code>

Il est possible d'utiliser une **fonction anonyme lambda** directement dans la fonction map : 
<code python>
# utilisation d'une fonction anonyme lambda
#nouvelle liste avec toutes taches accomplies
tachesfinies = list(map(lambda tache: {"id":tache["id"],"libelle":tache["libelle"], "accomplie":False}, taches))
</code>

<WRAP center round info>
Les **fonctions lambda** sont des **fonctions anonyme**s, c'est à dire des fonctions qui** n'ont pas de nom**. Une fonction anonyme : 
  * est définie à l'aide du **mot-clef lambda** ;
  * les **paramètres** de la fonction lambda sont définis** à gauche du caractère deux-points** :
  * le **corps** de la fonction est **défini à sa droite** ;
  * le **résultat** de l'exécution du corps de cette fonction, ce qui correspond à l'instruction **return** est **renvoyé implicitement**.

Une fonction anonyme peut être **placée** :
  * **directement** dans une fonction qui accepte en **paramètre** une fonction ;
  * dans une **variable** pour être utiliser ultérieurement.
Exemple avec une variable : 
<code python>
# definition de la fonction anonyme et affectation dans la variable fois2
fois2 = lambda x: x * 2

#utilisation 
>>> print(fois2(4))
>>> 8
</code>
</WRAP>

Même résultat avec un générateur  : 
<code python>
#nouvelle liste avec les taches modifiées pour les indiquer accomplies (finies)
tachesfinies = [fini(tache) for tache in taches]
</code>
===== La fonction filter =====
  * La fonction **filter** prend en argument une **fonction** qui est une **condition** et une **collection de données** ; 
  * Elle **crée** une nouvelle collection vide ; 
  * **applique** la fonction à chaque élément de la collection d'origine et **insère ** dans la nouvelle collection uniquement les **éléments qui répondent à la condition** ;
  * Elle renvoie alors la nouvelle collection.

Voici l'utilisation de la fonction **filter** pour avoir une nouvelle liste **tachesfinies** qui ne contient que les tâches finies :

<code python>
# definition de la fonction qui teste la valeur True pour la donnée acccomplie 
def fini(tache):
  return tache["accomplie"] == True

#nouvelle liste avec uniquement les taches accomplies (finies)
tachesfinies = list(filter(fini,taches))
</code>

Même résultat avec une fonction anonyme : 
<code python>
#nouvelle liste avec uniquement les taches accomplies (finies)
tachesfinies = list(filter(lambda tache:tache["accomplie"] == True, taches))
</code>

Même résultat avec un générateur  : 
<code python>
#nouvelle liste avec uniquement les taches accomplies (finies)
tachesfinies = [tache for tache in taches if tache["accomplie"] == True]
</code>
===== La fonction reduce =====
La fonction **reduce** prend en entrée une fonction et une collection d'éléments. Elle renvoie une valeur créée en combinant les éléments de la collection.
Exemple qui calcule la somme des éléments d'un tableau
<code python>
# importation de la fonction reduce
from functools import reduce

tableau = [0, 1, 2, 3, 4]

somme = reduce(lambda a, x: a + x, tableau)
# somme contient 10
</code>
<WRAP center round info>
**Explications** : 
  * **x** est l'élément courant de l'itération et **a** est **l'accumulateur** ;
  * l'accumulateur est la valeur renvoyée par l'exécution de la fonction lambda sur l'élément précédent ;
  * la fonction **reduce()** parcourt les éléments de la liste et, pour chacun d'eux, exécute la fonction lambda sur les valeurs courantes de a et de x et renvoie le résultat qui devient le a de l'itération suivante ;
  * la valeur de a lors de la première itération est la première valeur de la liste ; la première valeur de x est donc le second élément de la liste.
  * pour préciser une valeur initiale différente de a,  on le précise en 3ème paramètre de la fonction reduce :
<code python>
somme = reduce(lambda a, x: a + x, tableau, 50)
</code>
</WRAP>

====== Trier des listes ======
<code python>
taches.sort(key=lambda tache: tache["id"], reverse=True)
</code>
  * le paramètre **key** permet de préciser sur quelle données trier ;
  * le paramètre **reverse** permet de changer **l'ordre** du tri.

==== Retour au cours : Les instructions du langage Python ====
<WRAP center round info >
  * [[.:c_langage_python|Cours : Les instructions du langage Python]]
</WRAP>