Métaprogrammation#
Qu’est-ce que la métaprogrammation ?#
La métaprogrammation est l’art d’écrire du code qui raisonne sur d’autres programmes — ou sur lui-même. En Python, cette notion recouvre deux activités distinctes mais complémentaires. La première est l”introspection : interroger un objet pour connaître sa nature, ses attributs, ses méthodes ou sa hiérarchie de classes, sans en avoir lu la définition statique. La seconde est la génération ou modification de code : créer des classes à la volée, intercepter la création d’instances, modifier le comportement d’attributs à l’aide de descripteurs, ou contrôler la construction de classes entières grâce aux métaclasses.
Ce qui rend Python particulièrement propice à la métaprogrammation, c’est que tout est un objet. Une classe est un objet de type type. Une fonction est un objet de type function. Un module est un objet de type module. On peut donc les manipuler, les inspecter, les passer en argument ou les retourner comme n’importe quelle autre valeur. Cette uniformité permet d’écrire des abstractions très puissantes, comme celles que l’on trouve dans les ORM (Django Models, SQLAlchemy), les frameworks de test (pytest, unittest) ou les bibliothèques de validation (Pydantic).
La métaprogrammation est parfois considérée comme une technique réservée aux experts, car elle peut rendre le code difficile à comprendre si elle est mal utilisée. Mais elle est omniprésente dans Python : chaque fois que vous utilisez @property, @dataclass, @staticmethod ou que vous héritez d’une classe abstraite, vous bénéficiez de mécanismes métaprogrammatiques. Comprendre ces mécanismes de l’intérieur vous permettra de mieux utiliser les bibliothèques existantes et, le cas échéant, d’en créer de nouvelles.
Introspection#
L’introspection désigne la capacité d’un programme à examiner sa propre structure pendant l’exécution. Python offre un riche ensemble de fonctions et de modules dédiés à cette tâche.
Les fonctions intégrées d’introspection#
Les fonctions getattr, setattr, hasattr et delattr forment le quatuor fondamental pour manipuler les attributs d’un objet de façon dynamique.
Définition 31 (Fonctions d’accès dynamique aux attributs)
getattr(obj, name, default): retourne la valeur de l’attributnamesurobj. Si l’attribut n’existe pas, retournedefaults’il est fourni, sinon lèveAttributeError.setattr(obj, name, value): définit l’attributnamesurobjavec la valeurvalue. Équivalent àobj.name = value, mais le nom est une chaîne dynamique.hasattr(obj, name): retourneTruesiobjpossède un attributname(sans lever d’exception).delattr(obj, name): supprime l’attributnamesurobj. Équivalent àdel obj.name.
class Robot:
def __init__(self, nom, vitesse):
self.nom = nom
self.vitesse = vitesse
def deplacer(self):
return f"{self.nom} se déplace à {self.vitesse} m/s."
r = Robot("R2D2", 3)
# Accès dynamique à un attribut dont le nom est connu à l'exécution
attribut = "vitesse"
print(getattr(r, attribut)) # 3
# Modification dynamique
setattr(r, "vitesse", 5)
print(r.vitesse) # 5
# Vérification
print(hasattr(r, "deplacer")) # True
print(hasattr(r, "voler")) # False
# Accès à une méthode par son nom et appel
methode = getattr(r, "deplacer")
print(methode()) # R2D2 se déplace à 5 m/s.
3
5
True
False
R2D2 se déplace à 5 m/s.
La fonction vars() retourne le dictionnaire __dict__ d’un objet ou d’une classe, c’est-à-dire l’ensemble de ses attributs d’instance ou de classe sous forme de dictionnaire mutable. La fonction dir() retourne une liste triée de tous les noms accessibles sur un objet — y compris les attributs hérités.
print(vars(r))
# {'nom': 'R2D2', 'vitesse': 5}
# dir() inclut les attributs hérités de object
noms = [n for n in dir(r) if not n.startswith("__")]
print(noms)
# ['deplacer', 'nom', 'vitesse']
{'nom': 'R2D2', 'vitesse': 5}
['deplacer', 'nom', 'vitesse']
Le module inspect#
Le module inspect de la bibliothèque standard pousse l’introspection bien plus loin. Il permet d’examiner les fonctions (leur signature, leurs annotations, leur code source), les classes (leur hiérarchie, leurs membres) et les cadres d’exécution (la pile d’appels).
import inspect
def additionner(a: int, b: int = 0) -> int:
"""Additionne deux entiers."""
return a + b
# Signature complète
sig = inspect.signature(additionner)
print(sig) # (a: int, b: int = 0) -> int
# Paramètres individuels
for nom, param in sig.parameters.items():
print(f" {nom}: annotation={param.annotation}, "
f"défaut={param.default}")
# Vérifier si un objet est une fonction, une classe, etc.
print(inspect.isfunction(additionner)) # True
print(inspect.isclass(Robot)) # True
# Source du code (quand disponible)
# print(inspect.getsource(additionner))
(a: int, b: int = 0) -> int
a: annotation=<class 'int'>, défaut=<class 'inspect._empty'>
b: annotation=<class 'int'>, défaut=0
True
True
__init_subclass__#
Le hook __init_subclass__ est une méthode de classe appelée automatiquement chaque fois qu’une classe hérite de la classe qui le définit. C’est une façon élégante d’effectuer des traitements sur les sous-classes au moment de leur création, sans recourir aux métaclasses.
```{prf:definition} __init_subclass__
:label: definition-17-02
__init_subclass__(cls, **kwargs) est un hook de classe appelé par type.__init_subclass__ lorsqu’une classe hérite de la classe courante. cls est la sous-classe nouvellement créée. Les arguments de classe supplémentaires (class Enfant(Parent, option=True)) sont transmis via **kwargs.
```{code-cell} python
class PluginBase:
_registry: dict = {}
def __init_subclass__(cls, commande: str = None, **kwargs):
super().__init_subclass__(**kwargs)
if commande is not None:
PluginBase._registry[commande] = cls
print(f"Plugin enregistré : '{commande}' → {cls.__name__}")
class PluginBonjour(PluginBase, commande="bonjour"):
def executer(self):
return "Bonjour, monde !"
class PluginAuRevoir(PluginBase, commande="aurevoir"):
def executer(self):
return "Au revoir !"
# Le registre est rempli automatiquement à la définition des classes
print(PluginBase._registry)
plugin = PluginBase._registry["bonjour"]()
print(plugin.executer())
Ce pattern est utilisé dans de nombreux frameworks (Django REST Framework, Celery, Click) pour enregistrer automatiquement des composants sans que le développeur ait à les déclarer manuellement dans un registre central.
Descripteurs#
Un descripteur est un objet qui définit comment l’accès à un attribut d’une autre classe se comporte. C’est le mécanisme sous-jacent de @property, @staticmethod, @classmethod et des champs des ORM comme Django.
Définition 32 (Protocole descripteur)
Un objet est un descripteur s’il implémente au moins une de ces méthodes :
__get__(self, obj, objtype=None): appelée lors de la lecture de l’attribut (obj.attr).__set__(self, obj, value): appelée lors de l’écriture (obj.attr = value).__delete__(self, obj): appelée lors de la suppression (del obj.attr).
Un descripteur qui implémente __set__ ou __delete__ est dit descripteur de données (data descriptor) ; il a la priorité sur le __dict__ de l’instance. Un descripteur qui n’implémente que __get__ est un descripteur non-données (non-data descriptor).
class PositifOuNul:
"""Descripteur qui valide qu'une valeur est >= 0."""
def __set_name__(self, owner, name):
self._name = name
self._private = f"_{name}"
def __get__(self, obj, objtype=None):
if obj is None:
return self
return getattr(obj, self._private, 0)
def __set__(self, obj, value):
if value < 0:
raise ValueError(
f"'{self._name}' doit être positif ou nul, reçu : {value}"
)
setattr(obj, self._private, value)
class Produit:
prix = PositifOuNul()
quantite = PositifOuNul()
def __init__(self, nom, prix, quantite):
self.nom = nom
self.prix = prix
self.quantite = quantite
p = Produit("Pomme", 0.50, 100)
print(p.prix) # 0.5
p.prix = 0.75
print(p.prix) # 0.75
try:
p.prix = -1
except ValueError as e:
print(e) # 'prix' doit être positif ou nul, reçu : -1
0.5
0.75
'prix' doit être positif ou nul, reçu : -1
Métaclasses#
En Python, tout objet est une instance d’une classe. Mais une classe elle-même est aussi un objet — une instance de sa métaclasse. Par défaut, toutes les classes sont des instances de type, qui est à la fois une classe et sa propre métaclasse.
Définition 33 (Métaclasse)
Une métaclasse est la classe d’une classe. Elle contrôle la création de classes : quand Python rencontre l’instruction class Foo(Bar):, il appelle la métaclasse de Bar pour construire l’objet classe Foo. La métaclasse par défaut est type. On peut spécifier une métaclasse différente avec class Foo(Bar, metaclass=MaMeta):.
# type() à trois arguments crée une classe dynamiquement
# type(nom, bases, dictionnaire)
Animal = type("Animal", (object,), {
"cri": "...",
"parler": lambda self: f"Je fais '{self.cri}' !"
})
class Chien(Animal):
cri = "Ouaf"
d = Chien()
print(d.parler()) # Je fais 'Ouaf' !
print(type(Chien)) # <class 'type'>
print(type(type)) # <class 'type'>
Je fais 'Ouaf' !
<class 'type'>
<class 'type'>
Créer une métaclasse#
On crée une métaclasse en héritant de type et en surchargeant __new__ (qui construit l’objet classe) et/ou __init__ (qui l’initialise).
class SingletonMeta(type):
"""Métaclasse qui implémente le patron Singleton."""
_instances: dict = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super().__call__(*args, **kwargs)
return cls._instances[cls]
class ConfigurationApp(metaclass=SingletonMeta):
def __init__(self, chemin="/etc/app.conf"):
self.chemin = chemin
print(f"Configuration chargée depuis {chemin}")
c1 = ConfigurationApp("/home/user/.apprc")
c2 = ConfigurationApp("/autre/chemin") # __init__ non rappelé
print(c1 is c2) # True
print(c1.chemin) # /home/user/.apprc
Configuration chargée depuis /home/user/.apprc
True
/home/user/.apprc
Remarque 31
__new__ vs __init__ dans une métaclasse : __new__(mcs, nom, bases, namespace) est appelée en premier et retourne le nouvel objet classe. __init__(cls, nom, bases, namespace) reçoit ensuite cet objet pour l’initialiser. Dans la majorité des cas pratiques, on surcharge __new__ pour modifier le dictionnaire d’attributs avant que la classe ne soit créée, et __init__ pour effectuer des actions après la création. La méthode __call__ de la métaclasse est invoquée lorsqu’on appelle la classe pour créer une instance.
Cas d’usage réels#
Les ORM Django utilisent une métaclasse (ModelBase) pour transformer les déclarations de champs (CharField, IntegerField) en descripteurs actifs, enregistrer les modèles dans un registre global et générer automatiquement les requêtes SQL. SQLAlchemy utilise un mécanisme similaire. Ces usages justifient les métaclasses : quand on a besoin d’agir sur la structure d’une classe au moment de sa définition, pas à celui de son instanciation.
Remarque 32
Quand utiliser les métaclasses ? La réponse honnête est : rarement. Pour la plupart des problèmes, __init_subclass__, les décorateurs de classe ou les descripteurs suffisent et sont plus lisibles. Les métaclasses s’imposent lorsqu’on doit modifier le comportement de type.__new__ lui-même, ou lorsqu’on crée un framework qui doit agir sur des centaines de classes d’utilisateurs de façon transparente. Comme le dit Tim Peters : « Si vous pensez avoir besoin d’une métaclasse, vous avez probablement tort — mais si vous en avez réellement besoin, vous le saurez. »
__class_getitem__ et génériques#
Depuis Python 3.7, la syntaxe list[int] et dict[str, int] fonctionne grâce à la méthode spéciale __class_getitem__. Elle est appelée lorsqu’on indexe une classe avec des crochets.
class Pile:
"""Pile générique avec annotation de type."""
def __class_getitem__(cls, item):
# Retourne un alias de type pour les annotations
return f"Pile[{item.__name__ if hasattr(item, '__name__') else item}]"
def __init__(self):
self._data = []
def empiler(self, valeur):
self._data.append(valeur)
def depiler(self):
return self._data.pop()
# Utilisation dans les annotations
def traiter(pile: Pile[int]) -> None:
pass
print(Pile[int]) # Pile[int]
print(Pile[str]) # Pile[str]
Pile[int]
Pile[str]
Les classes génériques standard (list, dict, tuple, set) implémentent __class_getitem__ depuis Python 3.9, ce qui permet d’écrire directement list[int] dans les annotations sans importer List depuis typing. Pour des génériques personnalisés complets, on hérite de typing.Generic[T].
Résumé#
Dans ce chapitre, nous avons exploré les mécanismes par lesquels Python permet au code de s’inspecter et de se modifier lui-même :
L”introspection avec
getattr,setattr,hasattr,vars(),dir()et le moduleinspectpermet d’examiner n’importe quel objet à l’exécution, sans en connaître la structure à l’avance.__init_subclass__offre un point d’extension propre pour réagir à la création de sous-classes, sans la complexité des métaclasses — idéal pour les registres de plugins ou les frameworks.Les descripteurs (
__get__,__set__,__delete__) sont le mécanisme sous-jacent de@property,@staticmethodet des champs d’ORM. Maîtriser ce protocole permet de comprendre comment Python gère réellement l’accès aux attributs.Les métaclasses contrôlent la création de classes entières. Elles sont puissantes mais doivent rester un outil de dernier recours, réservé aux frameworks.
__class_getitem__permet la syntaxe génériqueMaClasse[T], utilisée par le système de types depuis Python 3.9.
Dans le chapitre suivant, nous abordons un tout autre paradigme : la programmation fonctionnelle en Python, avec functools, itertools, operator et les fonctions d’ordre supérieur.
Comment
@propertyest implémenté#La fonction intégrée
propertyest elle-même un descripteur. On peut en écrire une version simplifiée pour comprendre son fonctionnement :