Fluent Python

1. Les décorateurs : sublimer les fonctions grâce à une syntaxe élégante

Un décorateur est un objet appelable qui prend une autre fonction en argument (la fonction décorée).

Une élégance syntaxique. Les décorateurs offrent une manière claire et lisible de modifier ou d’enrichir le comportement des fonctions sans toucher à leur logique fondamentale. Ils s’appliquent via la syntaxe « @ », qui constitue en réalité un sucre syntaxique facilitant le passage d’une fonction en argument à une autre fonction. Cela ouvre la voie à des techniques puissantes de métaprogrammation, permettant d’ajouter des fonctionnalités telles que la journalisation, la mesure de performance ou le contrôle d’accès à des fonctions existantes.

Moment d’exécution. Un point essentiel concernant les décorateurs est qu’ils s’exécutent immédiatement lors du chargement d’un module, généralement à l’importation. Ils peuvent ainsi servir à enregistrer des fonctions, modifier des attributs de classes ou de fonctions, ou effectuer d’autres tâches préparatoires avant que la fonction décorée ne soit réellement appelée. En revanche, la fonction décorée elle-même ne s’exécute que lorsqu’elle est invoquée explicitement.

Usages courants des décorateurs :

• Journalisation et débogage
• Analyse de performance et chronométrage
• Contrôle d’accès et authentification
• Mise en cache et mémoïsation
• Validation des entrées et vérification de types

2. Les closures : capturer et préserver l’état dans des fonctions imbriquées

Une closure est une fonction qui conserve les liaisons des variables libres existant lors de sa définition, afin de pouvoir les utiliser ultérieurement, même lorsque le contexte d’origine n’est plus accessible.

Préserver le contexte. Les closures représentent une fonctionnalité puissante en Python, permettant aux fonctions internes de capturer et de mémoriser l’état des variables de leur portée externe, même après la fin d’exécution de cette dernière. Cela facilite la création de « fabriques » de fonctions et l’implémentation de l’encapsulation et du masquage des données sans recourir aux classes.

Applications pratiques. Les closures sont au cœur de nombreux schémas de programmation en Python, notamment les décorateurs, les callbacks et certaines techniques de programmation fonctionnelle. Elles permettent de créer des fonctions dotées d’une « mémoire », particulièrement utiles pour maintenir un état entre plusieurs appels ou pour générer des fonctions spécialisées selon des paramètres d’exécution.

Points clés sur les closures :

• Elles « capturent » les variables de leur portée lexicale
• Les variables capturées sont stockées dans l’attribut closure de la fonction
• Elles facilitent l’application partielle et le currying
• Elles constituent la base de nombreuses fonctionnalités avancées et patrons de conception en Python

3. Règles de portée des variables : comprendre les variables locales, globales et nonlocales

En présence d’une déclaration nonlocal x, x provient et est affectée à la variable locale x de la fonction englobante la plus proche où x est définie.

Hiérarchie des portées. Les règles de portée des variables en Python déterminent comment les noms sont résolus dans les fonctions imbriquées. Maîtriser ces règles est indispensable pour écrire un code correct et efficace, notamment lorsqu’on manipule des closures ou des décorateurs. L’ordre de recherche suit la séquence : locale, fonctions englobantes, globale, puis portée intégrée.

Le mot-clé nonlocal. Introduit en Python 3, nonlocal permet aux fonctions internes d’affecter des variables dans leur portée englobante. Cela est crucial pour les closures qui doivent modifier un état capturé dans leur contexte extérieur. Sans nonlocal, une affectation créerait une nouvelle variable locale, ce qui peut entraîner des comportements inattendus.

Règles de portée des variables en Python :

1. Portée locale (fonction)
2. Fonctions englobantes (nonlocal)
3. Portée globale (module)
4. Portée intégrée (noms intégrés de Python)

• Le mot-clé global sert à indiquer qu’un nom fait référence à une variable globale
• nonlocal s’applique aux variables dans des portées englobantes (mais non globales)

4. Implémenter des décorateurs : du simple au paramétré

Pour accepter des paramètres, le nouveau décorateur register doit être appelé comme une fonction.

Fonctions imbriquées. La mise en œuvre des décorateurs repose généralement sur des définitions de fonctions imbriquées. La fonction la plus externe (le décorateur lui-même) reçoit la fonction à décorer en argument. Elle définit ensuite et retourne une fonction interne qui enveloppe la fonction originale, ajoutant la fonctionnalité souhaitée.

Décorateurs paramétrés. Pour créer des décorateurs acceptant des arguments, il faut ajouter un niveau supplémentaire d’imbrication. La fonction la plus externe devient une fabrique de décorateurs qui prend les paramètres et retourne le décorateur proprement dit. Cela permet d’obtenir des décorateurs plus flexibles et configurables, au prix d’une complexité accrue.

Structure d’un décorateur basique :

1. Fonction décoratrice (prend la fonction à décorer)
2. Fonction wrapper (ajoute la fonctionnalité et appelle la fonction originale)

Structure d’un décorateur paramétré :

1. Fabrique de décorateur (prend les paramètres du décorateur)
2. Fonction décoratrice (prend la fonction à décorer)
3. Fonction wrapper (ajoute la fonctionnalité et appelle la fonction originale)

5. Décorateurs de la bibliothèque standard : exploiter des outils puissants intégrés

functools.cache a été ajouté en Python 3.9. Pour exécuter ces exemples en Python 3.8, remplacez @cache par @lru_cache.

Solutions prêtes à l’emploi. La bibliothèque standard de Python propose plusieurs décorateurs puissants qui répondent à des problématiques courantes. On trouve notamment property pour créer des attributs gérés, classmethod et staticmethod pour modifier le comportement des méthodes, ainsi que divers outils dans le module functools dédiés à l’optimisation et à la manipulation des fonctions.

Décorateurs d’optimisation. Le module functools offre des décorateurs particulièrement utiles pour améliorer les performances. Le décorateur @cache (et son prédécesseur @lru_cache) implémente la mémoïsation, stockant les résultats des fonctions pour éviter des calculs redondants. Le décorateur @singledispatch permet de créer des fonctions génériques dont le comportement varie selon le type du premier argument.

Décorateurs clés de la bibliothèque standard :

• @property : créer des attributs gérés
• @classmethod : définir des méthodes opérant sur la classe, non sur les instances
• @staticmethod : définir des méthodes indépendantes de la classe ou des instances
• @functools.cache : mémoïser les résultats des fonctions
• @functools.lru_cache : mémoïser avec une taille de cache limitée
• @functools.singledispatch : créer des fonctions à dispatching basé sur le type

6. Fonctions génériques à dispatching simple : le polymorphisme en Python

L’avantage de @singledispatch est de permettre une extension modulaire : chaque module peut enregistrer une fonction spécialisée pour chaque type qu’il supporte.

Dispatching basé sur le type. Le décorateur @singledispatch offre un moyen de créer des fonctions dont le comportement varie selon le type du premier argument. Cela introduit une forme de surcharge fonctionnelle ou de polymorphisme ad hoc en Python, particulièrement utile pour implémenter des opérations différenciées selon les types.

Extensibilité. Un des atouts majeurs de @singledispatch est sa capacité à favoriser un code modulaire et extensible. De nouvelles implémentations spécifiques à un type peuvent être enregistrées à tout moment, y compris pour des types définis dans des bibliothèques tierces. Cela permet d’adapter et d’étendre les fonctionnalités sans modifier le code original.

Avantages de @singledispatch :

• Permet un dispatching fonctionnel basé sur le type
• Facilite l’extension avec de nouveaux types
• Supporte l’enregistrement d’implémentations pour des classes abstraites
• Maintient une structure de code propre et modulaire

Mode d’emploi :

1. Décorer la fonction de base avec @singledispatch
2. Enregistrer les implémentations spécifiques avec @base_function.register(type)

7. Mémoïsation et mise en cache : optimiser les performances des fonctions

functools.cache implémente la mémoïsation : une technique d’optimisation qui consiste à sauvegarder les résultats d’appels précédents d’une fonction coûteuse, évitant ainsi des calculs répétés sur des arguments déjà traités.

Gain de performance. La mémoïsation est une technique puissante qui peut considérablement améliorer les performances des fonctions effectuant des calculs lourds, surtout lorsqu’elles sont appelées plusieurs fois avec les mêmes arguments. Les décorateurs @functools.cache et @functools.lru_cache offrent des implémentations simples et efficaces de cette technique.

Compromis. Si la mise en cache accélère l’exécution, elle engendre un coût en mémoire. Le décorateur @cache conserve tous les résultats indéfiniment, ce qui peut entraîner une consommation mémoire importante sur des processus longs. Le décorateur @lru_cache permet de limiter la taille du cache via son paramètre maxsize, évacuant automatiquement les entrées les moins récemment utilisées.

Quand utiliser la mémoïsation :

• Fonctions aux calculs coûteux
• Fonctions pures (même entrée produit toujours la même sortie)
• Fonctions appelées fréquemment avec les mêmes arguments

Points à considérer :

• Usage mémoire versus temps de calcul
• Taille du cache et politique d’éviction (@lru_cache)
• Sécurité en environnement concurrent

8. L’art du typage progressif : concilier flexibilité et sécurité

Les annotations de type sont optionnelles à tous les niveaux : vous pouvez avoir des packages entiers sans annotations, désactiver le vérificateur de types lors de l’import d’un tel package dans un module annoté, et ajouter des commentaires spéciaux pour que le vérificateur ignore certaines lignes de code.

Outils améliorés. Le système de typage progressif de Python, introduit avec la PEP 484, permet aux développeurs d’ajouter des annotations de type de manière incrémentale. Ces annotations sont exploitées par les analyseurs statiques et les environnements de développement pour détecter précocement des erreurs potentielles et offrir une meilleure complétion et refactorisation. Elles n’ont toutefois aucun impact sur l’exécution du programme.

Flexibilité préservée. La nature progressive du typage en Python autorise à annoter uniquement les parties du code où cela apporte une réelle valeur, sans contraindre à documenter l’intégralité du code. Cela conserve la souplesse et la simplicité de Python, tout en renforçant la sécurité et les outils dans les zones critiques ou complexes.

Avantages du typage progressif :

• Détecter les erreurs plus tôt dans le cycle de développement
• Améliorer la lisibilité et l’auto-documentation du code
• Bénéficier d’un meilleur support des IDE et outils
• Faciliter la maintenance et le refactoring

Défis et points d’attention :

• Courbe d’apprentissage de la syntaxe et des concepts
• Risque de complexification excessive dans les scripts simples
• Nécessité d’équilibrer flexibilité et rigueur
• Compatibilité avec les bibliothèques tierces

Dernière mise à jour: February 19, 2025