Programmation Fonctionnelle : Python

Concepts et applications pratiques

Klazé Faı̈rousse DAO

20 mai 2026

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 1 / 30

Plan du module

1 Introduction à la programmation fonctionnelle

2 Fonctions de première classe et d’ordre supérieur

3 Récursion et immutabilité

4 Opérations fonctionnelles en Python

5 Composition et curryfication

6 Programmation fonctionnelle avancée

7 Cas d’usage pratiques

8 Conclusion

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 2 / 30

Qu’est-ce que la programmation fonctionnelle ?

Paradigme de programmation basé sur les fonctions mathématiques

Traite le calcul comme l’évaluation de fonctions mathématiques
Évite les changements d’état et les données mutables
Se concentre sur ce qui doit être calculé, plutôt que sur comment
Origines : Lambda-calcul (Alonzo Church, années 1930)

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 3 / 30

Principes fondamentaux

Fonctions de première classe : Les fonctions sont des valeurs

Fonctions pures : Pas d’effets secondaires, sortie déterminée
uniquement par entrée
Récursion : Forme principale d’itération
Immutabilité : Les données ne changent pas après création
Transparence référentielle : Une expression peut être remplacée par
sa valeur
Évaluation paresseuse : Évaluer une expression seulement quand
nécessaire

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 4 / 30

Avantages de la programmation fonctionnelle

Concision : Moins de code pour exprimer des concepts complexes

Prédictibilité : Comportement plus facile à anticiper
Testabilité : Fonctions pures faciles à tester
Parallélisation : Absence d’état partagé facilite l’exécution parallèle
Modularité : Composition de fonctions facilite la réutilisation
Raisonnement mathématique : Plus proche des abstractions
mathématiques
Moins d’erreurs : Réduction des bugs liés aux états partagés

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 5 / 30

Python et la programmation fonctionnelle

Python est un langage multi-paradigme

Support de nombreux concepts fonctionnels :
Fonctions anonymes (lambda)
Fonctions d’ordre supérieur
Fonctions pures
Compréhensions de liste, de dictionnaire, etc.
Fonctions intégrées map, filter, reduce
Modules de support (functools, itertools)
Pas un langage fonctionnel pur, mais offre de bonnes capacités
fonctionnelles

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 6 / 30

 Fonctions de première classe

Les fonctions sont des objets comme les autres

Peuvent être :
Assignées à des variables
Passées en arguments
Retournées par d’autres fonctions
Stockées dans des structures de données
1 om
2 salutation = saluer print(salutation("Alice")) "Bonjour, Alice"
3 Fonction dans une structure de donn
4 !es fonctions = [saluer, [Link], len] for f in fonctions
print(f("Python")) :

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 7 / 30

 Fonctions d’ordre supérieur (I)

Fonctions qui prennent d’autres fonctions comme arguments

Permettent des abstractions puissantes
1 Utilisation avec diffrentes fonctions print(appliquer(len, "Python")) 6
print(appliquer(sum, [1, 2, 3, 4])) 10 print(appliquer(lambda x
2 x * x, 5)) 25 :

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 8 / 30

 Fonctions d’ordre supérieur (II)

Fonctions qui retournent d’autres fonctions

Permettent de créer des générateurs de fonctions
5 doubler = multiplicateur(2) tripler = multiplicateur(3)
6 print(doubler(5)) 10 print(tripler(5)) 15

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 9 / 30

 Fonctions lambda

Fonctions anonymes définies avec le mot-clé lambda

Syntaxe : lambda arguments: expression
Limitées à une seule expression
Utiles pour des fonctions simples utilisées une seule fois
7 Lambda avec condition estp air = lambdaxxprint(estp air (4))True
8 Lambda dans un tri personnes = [("Alice", 25), ("Bob", 30), ("Charlie",
22)] personnest riees = sorted(personnes, key = lambdapp[1])Tripar
9 ge print(personnest riees)

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 10 / 30

 Récursion en programmation fonctionnelle

Alternative aux boucles dans les langages fonctionnels purs

Une fonction qui s’appelle elle-même
Composants :
Cas de base (condition d’arrêt)
Appel récursif (réduction du problème)
10 print(factorielle(5)) 120

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 11 / 30

 Récursion terminale

Forme spéciale où l’appel récursif est la dernière opération

Peut être optimisée par le compilateur (pas en Python standard)
Évite la consommation excessive de la pile d’appels
11 print(factoriellet erminale(5))120
12 Note Python n’optimise pas la r
13 :cursion terminale par dfaut (limite de rcursion 1000 appels) ~

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 12 / 30

 Immutabilité en Python

Types immuables natifs : int, float, str, tuple, frozenset

Types mutables : list, dict, set
L’immutabilité facilite le raisonnement sur le code
Patterns pour l’immutabilité :
14 Crer de nouvelles structures plutt que modifier def
ajoutere lement(t, element)
15 return t + (element,) Nouveau tuple
16 point3 d = ajoutere lement(point, 5)(3, 4, 5)print(point)Toujours(3, 4):

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 13 / 30

 Classes immuables

Création de classes dont les instances sont immuables

Utilisation de slots et propriétés en lecture seule
1 def i nit( self ,x,y )self .x =xself .y =y

2 @property def x(self) return self.x

3 @property def y(self) return self.y
4 def deplacer(self, dx, dy) Retourne un nouveau point plut
5 :::t que modifier return Point(self.x + dx, self.y + dy)

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 14 / 30

 Map, Filter, Reduce

Fonctions fondamentales de traitement de collections

Paradigme ”appliquer-à-tous” plutôt que boucles explicites
1 Map Applique une fonction
2 : chaque lment nombres = [1, 2, 3, 4, 5] carres = list(map(lambda
x x**2, nombres)) print(carres) [1, 4, 9, 16, 25]
3 Filter Filtre selon un pr::dicat pairs = list(filter(lambda x x
print(pairs) [2, 4]
4 Reduce R::duit une valeur unique somme = reduce(lambda x, y x + y,
nombres) print(somme) 15 :

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 15 / 30

 Compréhensions

Alternative pythonique à map/filter

Plus lisible et souvent plus rapide
Types : liste, dictionnaire, ensemble, générateur
17 Avec filtre (quivalent filter) pairs = [x for x in nombres if x
18 Comprhension de dictionnaire carred ict = x
19 x**2 for x in nombres print(carred ict)1 : 1, 2 : 4, 3 : 9, 4 : 16, 5 : 25
20 Compréhension d’ensemble voyelles = c for c in "programmation" if c in
"aeiouy" print(voyelles) ’a’, ’i’, ’o’

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 16 / 30

 Générateurs et évaluation paresseuse

Générateurs : séquences calculées à la demande

Avantages :
Économie de mémoire
Possibilité de traiter des séquences infinies
Composition efficace de transformations
21 Fonction gnratrice def nombresp remiers()
22 """G:nrateur infini de nombres premiers""" premiers = [] n = 2
while True if all(n [Link](n) yield n n += 1 :

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 17 / 30

 Le module itertools

Bibliothèque d’outils pour manipuler des itérateurs

Inspiré par les séquences de Haskell
Fonctions pour combinaisons, permutations, produits, etc.
1 Produit cartsien for p in [Link]("AB", [1, 2])
2 print(p) (’A’, 1), (’A’, 2), (’B’, 1), (’B’, 2)
3 Combinaisons for c in [Link]([1, 2, 3, 4], 2) print(c)
(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)
4 Cycle infini cycle = [Link]([1, 2, 3]) print([next(cycle) for
i nrange(7)])[1, 2, 3, 1, 2, 3, 1]::

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 18 / 30

 Composition de fonctions

Combiner des fonctions pour en créer de nouvelles

f ◦ g (x) = f (g (x))
Construction de pipelines de traitement
23 incr = lambda x x + 1 double = lambda x x * 2
24 f(g(x)) = double(incr(x)) = (x+1)*2
incrp uisd ouble = composer (double, incr )print(incrp uisd ouble(3))8
25 Module [Link] (Python 3.11+) from functools import compose
Disponible dans Python 3.11+ incrp uisd ouble = compose(double, incr )
26 ::

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 19 / 30

 Curryfication

Transformer une fonction à plusieurs arguments en chaı̂ne de

fonctions à un argument
f (x, y , z) ⇒ f ′ (x)(y )(z)
Facilite la composition et l’application partielle
27 Version currifie def additionc urry (x)
28 def ajoutery (y )defajouterz (z)returnx + y + zreturnajouterz returnajoutery
29 Utilisation
ajouter5 = additionc urry (5)ajouter5e t3 = ajouter5 (3)resultat = ajouter5e t3 (2)10:

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 20 / 30

 Application partielle

Fixer certains arguments d’une fonction

Créer une nouvelle fonction avec moins de paramètres
Module [Link]
5 Fonction originale def puissance(base, exposant) return base ** exposant
6 Application partielle carre = partial(puissance, exposant=2) cube =
partial(puissance, exposant=3)
7 print(carre(5)) 25 print(cube(5)) 125
8 Application pour les fonctions int
9 :gres from operator import mul doubler = partial(mul, 2)
print(list(map(doubler, [1, 2, 3, 4]))) [2, 4, 6, 8]

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 21 / 30

 Décorateurs

Fonctions qui modifient d’autres fonctions

Application du principe des fonctions d’ordre supérieur
Permet la séparation des préoccupations
30 def chronometre(fonction) def wrapper(*args, **kwargs) debut =
[Link]() resultat = fonction(*args, **kwargs) fin = [Link]()
print(f"Temps d’ex
31 ::cution fin - debut.4f secondes") return resultat return wrapper
32 @chronometre def operationl ente()[Link](1)return”Op ::rationtermine”
33 operationl ente()Afficheletempsd : ’excution

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 22 / 30

 Fermetures (Closures)

Fonctions qui ”capturent” leur environnement lexical

Permettent de conserver un état sans variables globales
Base des fabriques de fonctions
3 def incrementer() nonlocal count R
4 :frence la variable externe count += 1 return count
5 return incrementer
6 Cration de deux compteurs indpendants compteur1 = compteur() compteur2 =
compteur()
7 print(compteur1()) 1 print(compteur1()) 2 print(compteur2()) 1
(indpendant de compteur1)

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 23 / 30

 Monades

Concept avancé pour encapsuler des calculs et effets

Permet de chaı̂ner des opérations tout en gérant les cas spéciaux
Populaire en Haskell, moins courant en Python
34 def bind(self, func) if [Link] is None return Maybe(None) return
func([Link])
35 @staticmethod def unit(value) return Maybe(value)
36 Utilisation def diviserp ar (x)defdivision(y )ifx ==
0returnMaybe(None)returnMaybe(y /x)returndivision
37 resultat = Maybe(10).bind(diviserp ar (2)).bind(diviserp ar (0))
38 :::

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 24 / 30

 Traitement de données

La programmation fonctionnelle est idéale pour :

ETL (Extract, Transform, Load)
Data Science
Traitement en flux
39 def normaliser(donnees) mx = max(donnees) return [d / mx for d in
donnees]
40 def traiter(donnees) return list(map(lambda x x**2, donnees))
41 Pipeline complet pipeline = lambda donnees
traiter(normaliser(nettoyerd onnees(donnees)))
42 resultat = pipeline([1, None, 3, None, 5])
43 ::::

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 25 / 30

 Tests unitaires

Les fonctions pures sont faciles à tester

Entrées et sorties bien définies
Pas d’état externe à gérer
44 Tests unitaires def testf ibonacci()Entr
45 es et rsultats attendus bien dfinis assert fibonacci(0) == 0 assert
fibonacci(1) == 1 assert fibonacci(2) == 1 assert fibonacci(3) == 2
assert fibonacci(4) == 3 assert fibonacci(5) == 5 print("Tous les
tests passent ")
46 testf ibonacci()!

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 26 / 30

 Concurrence et parallélisme

L’absence d’état partagé facilite la parallélisation

Mapping sur plusieurs cœurs avec multiprocessing
10 Fonction de calcul intensif def calculer(n) return sum(i*i for i in
range(n))
11 Ex
12 :cution squentielle
resultatss eq = [calculer (n)fornin[10 ∗ ∗6, 10 ∗ ∗6, 10 ∗ ∗6, 10 ∗ ∗6]]
13 Excution parallle with Pool(processes=4) as pool
resultatsp ar = [Link](calculer , [10 ∗ ∗6, 10 ∗ ∗6, 10 ∗ ∗6, 10 ∗ ∗6])
14 Les deux approches donnent le m:me rsultat assert
resultatss eq == resultatsp ar

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 27 / 30

Récapitulatif

La programmation fonctionnelle offre :

Code plus concis et déclaratif
Meilleure testabilité et prédictibilité
Facilité de parallélisation
Réduction des bugs liés à l’état
Python n’est pas un langage fonctionnel pur mais :
Offre de nombreuses fonctionnalités fonctionnelles
Permet un style hybride pragmatique
Bon langage pour s’initier aux concepts fonctionnels

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 28 / 30

Ressources d’apprentissage

Livres :
”Functional Programming in Python” - David Mertz
”Python Cookbook” - David Beazley & Brian K. Jones
En ligne :
Documentation Python : functools, itertools
Real Python : Tutoriels sur la programmation fonctionnelle
GitHub : Awesome Functional Python
Bibliothèques :
toolz : Utilitaires fonctionnels
[Link] : Extensions fonctionnelles
pymonad : Implémentation de monades

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 29 / 30

 Merci de votre attention !
Questions ?

Klazé Faı̈rousse DAO Programmation Fonctionnelle : Python 20 mai 2026 30 / 30