Si tu apprends Python depuis un moment, tu as sûrement croisé des fonctionnalités déroutantes : elles semblent inutilement complexes, ou réservées à un club secret de « Python avancé ». La bonne nouvelle, c’est que ce sont des outils très utiles, qui rendent ton code plus propre, plus efficace et parfois carrément élégant, une fois qu’on les comprend.
Dans cet article, je décortique 10 de ces fonctionnalités en termes simples : décorateurs, générateurs, gestionnaires de contexte, compréhensions, opérateur walrus, indications de type, métaclasses, @staticmethod et @classmethod, __slots__ et descripteurs. Chaque exemple est exécuté, avec sa vraie sortie.
Article mis à jour en novembre 2026 : j’ai exécuté tout le code avec Python 3.13 et ajouté les sorties, qui manquaient. J’ai amélioré l’exemple des décorateurs (*args, **kwargs et @wraps), mesuré la mémoire des générateurs et de __slots__, montré que with ferme la ressource même en cas d’erreur, et ajouté une alternative plus simple aux métaclasses (__init_subclass__). J’ai aussi réécrit l’exemple des descripteurs, qui doublait la valeur de façon peu claire, avec un descripteur réutilisable qui valide la donnée.
En bref : parmi ces 10 fonctionnalités Python, un décorateur ajoute un comportement à une fonction, un générateur produit les valeurs une par une avec yield, with nettoie automatiquement les ressources, une compréhension construit une collection en une ligne, le walrus := affecte une valeur au milieu d’une expression, les indications de type documentent le code sans être appliquées à l’exécution, une métaclasse contrôle la création des classes, @classmethod reçoit la classe (utile pour les constructeurs alternatifs), __slots__ économise de la mémoire et un descripteur réutilise la logique d’un attribut.
Tu peux exécuter tout le code de cet article dans ce notebook Google Colab : il n’utilise que la bibliothèque standard de Python, il n’y a rien à installer ni à télécharger.

Voici la version de Python utilisée :
import sys
import tracemalloc
from functools import wraps
from contextlib import contextmanager
print("Python", sys.version.split()[0])PythonPython 3.13.16#1 Qu’est-ce qu’un décorateur Python et à quoi sert-il ?
Pourquoi c’est déroutant : les décorateurs semblent magiques. Tu ajoutes un @quelque_chose au-dessus d’une fonction, et soudain elle se comporte différemment.
Pourquoi c’est génial : un décorateur modifie ou étend le comportement d’une fonction sans toucher à son code. Pense à un moyen d’ajouter des fonctionnalités supplémentaires.
Exemple :
def greet_decorator(func):
def wrapper():
print("Hello!")
func()
print("Goodbye!")
return wrapper
@greet_decorator
def say_name():
print("My name is Python.")
say_name()PythonHello!
My name is Python.
Goodbye!Ce qu’il se passe : quand tu appelles say_name(), c’est en réalité la fonction wrapper du décorateur qui s’exécute : elle affiche « Hello! », appelle say_name, puis affiche « Goodbye! ».
Ce décorateur ne fonctionne que pour une fonction sans argument. Voici une version plus réaliste : elle accepte n’importe quels arguments grâce à *args, **kwargs, et @wraps conserve le nom de la fonction d’origine. Sans @wraps, la fonction décorée s’appellerait wrapper :
def log_call(func):
@wraps(func) # garde le nom et la docstring de la fonction d'origine
def wrapper(*args, **kwargs): # accepte n'importe quels arguments
print(f"Appel de {func.__name__} avec {args}")
resultat = func(*args, **kwargs)
print(f"Résultat : {resultat}")
return resultat
return wrapper
@log_call
def additionner(a, b):
return a + b
additionner(2, 3)
print(additionner.__name__)PythonAppel de additionner avec (2, 3)
Résultat : 5
additionnerLes décorateurs sont parfaits pour le logging, l’authentification ou la mesure du temps d’exécution. Pour aller plus loin, lis mon article sur les décorateurs Python.
#2 À quoi servent les générateurs et le mot-clé yield ?
Pourquoi c’est déroutant : au lieu de return, un générateur utilise yield, et il ne s’exécute pas d’un coup. Quel est l’intérêt ?
Pourquoi c’est génial : un générateur produit les éléments un par un, seulement quand on en a besoin. C’est idéal pour de gros volumes de données ou des séquences infinies, sans saturer la mémoire.
Exemple :
def count_up_to(n):
count = 1
while count <= n:
yield count
count += 1
for number in count_up_to(5):
print(number)Python1
2
3
4
5Ce qu’il se passe : au lieu de créer toute la liste de nombres, count_up_to les génère à la volée. C’est comme un robinet qui te donne les valeurs une à une. Tu peux le voir avec next() : chaque appel reprend là où le précédent s’est arrêté, jusqu’à ce que le générateur soit épuisé :
gen = count_up_to(2)
print(next(gen))
print(next(gen))
try:
next(gen)
except StopIteration:
print("StopIteration : le générateur est épuisé")Python1
2
StopIteration : le générateur est épuiséL’intérêt pour la mémoire est énorme. Pour un million de valeurs, la liste occupe environ 8,4 Mo (valeur de ma machine, elle varie selon la version de Python), alors que le générateur n’occupe que 192 octets, et reste capable de calculer la somme :
liste = [x for x in range(1_000_000)]
generateur = (x for x in range(1_000_000))
print("Liste :", sys.getsizeof(liste), "octets")
print("Générateur :", sys.getsizeof(generateur), "octets")
print("Somme :", sum(x for x in range(1_000_000)))PythonListe : 8448728 octets
Générateur : 192 octets
Somme : 499999500000#3 Pourquoi utiliser with et les gestionnaires de contexte ?
Pourquoi c’est déroutant : l’instruction with ressemble à une façon compliquée d’ouvrir un fichier. Pourquoi ne pas utiliser open() tout simplement ?
Pourquoi c’est génial : un gestionnaire de contexte gère la préparation et le nettoyage automatiquement, ce qui évite les fuites de ressources, comme un fichier jamais fermé.
Exemple :
with open("example.txt", "w", encoding="utf-8") as f:
f.write("Bonjour depuis Python !")
with open("example.txt", "r", encoding="utf-8") as file:
content = file.read()
print(content)
print("Fichier fermé :", file.closed)PythonBonjour depuis Python !
Fichier fermé : TrueCe qu’il se passe : le fichier est ouvert, lu, puis fermé automatiquement à la sortie du bloc with. Plus besoin d’appeler file.close(). Le test file.closed le confirme.
Tu peux créer tes propres gestionnaires de contexte avec contextlib.contextmanager (ou en définissant __enter__ et __exit__ dans une classe) :
@contextmanager
def section(nom):
print(f"Début : {nom}")
try:
yield
finally:
print(f"Fin : {nom}")
with section("chargement"):
print("... traitement en cours ...")PythonDébut : chargement
... traitement en cours ...
Fin : chargementLe nettoyage s’exécute même quand une erreur se produit dans le bloc, grâce au finally :
try:
with section("calcul"):
1 / 0
except ZeroDivisionError:
print("Erreur interceptée, mais la section a bien été fermée")PythonDébut : calcul
Fin : calcul
Erreur interceptée, mais la section a bien été ferméeC’est très pratique pour gérer des connexions à des bases de données ou des ressources réseau.
#4 Comment fonctionnent les compréhensions en Python ?
Pourquoi c’est déroutant : les compréhensions de liste, et leurs cousines (dictionnaire, ensemble, générateur), ressemblent à des raccourcis difficiles à lire.
Pourquoi c’est génial : elles construisent une collection de façon concise, en remplaçant souvent plusieurs lignes de code par une seule.
Exemple :
squares = [x**2 for x in range(10) if x % 2 == 0]
print(squares)Python[0, 4, 16, 36, 64]Ce qu’il se passe : cette ligne construit la liste des carrés des nombres pairs entre 0 et 9. Une fois que tu as pris le coup de main, tu te demandes comment tu as pu t’en passer. La même idée existe pour les dictionnaires, les ensembles et les expressions génératrices :
mots = ["python", "data", "code", "python"]
print({m: len(m) for m in mots}) # compréhension de dictionnaire
print({len(m) for m in mots}) # compréhension d'ensemble
print(sum(len(m) for m in mots)) # expression génératricePython{'python': 6, 'data': 4, 'code': 4}
{4, 6}
20#5 À quoi sert l’opérateur walrus := ?
Pourquoi c’est déroutant : il ressemble à un smiley dans ton code. Que fait-il au juste ?
Pourquoi c’est génial : l’opérateur walrus affecte une valeur à une variable au sein même d’une expression, ce qui rend le code plus court et souvent plus lisible.
Exemple :
numbers = [10, 20, 30, 40]
if (n := len(numbers)) > 3:
print(f"Trop de nombres : ({n}) !")PythonTrop de nombres : (4) !Ce qu’il se passe : le résultat de len(numbers) est affecté à n et utilisé dans la condition. Pas besoin de le calculer deux fois. Il est aussi très utile dans une compréhension, pour ne calculer une valeur qu’une seule fois :
valeurs = [3, 8, 12, 25]
# on calcule x**2 une seule fois, puis on le réutilise dans la liste
print([carre for x in valeurs if (carre := x**2) > 50])Python[64, 144, 625]#6 Les indications de type servent-elles à quelque chose en Python ?
Pourquoi c’est déroutant : Python est un langage à typage dynamique. Alors pourquoi ajouter des types ?
Pourquoi c’est génial : les indications de type améliorent la lisibilité et permettent à des outils comme les éditeurs, les linters ou mypy de détecter des erreurs avant l’exécution. Elles ne sont pas appliquées par Python lui-même.
Exemple :
def greet(name: str) -> str:
return f"Hello {name}!"
print(greet("Python"))
print(greet.__annotations__)PythonHello Python!
{'name': <class 'str'>, 'return': <class 'str'>}Ce qu’il se passe : les types indiquent que name doit être une chaîne (str) et que la fonction renvoie aussi une str. Python les stocke dans __annotations__, mais ne les vérifie pas : appeler la fonction avec un entier fonctionne quand même.
print(greet(42)) # Python n'applique pas les types à l'exécutionPythonHello 42!Avec les versions récentes de Python (3.10 et plus), la syntaxe est plus légère : list[float] au lieu de List[float], et float | None pour une valeur optionnelle :
def moyenne(notes: list[float]) -> float | None:
return sum(notes) / len(notes) if notes else None
print(moyenne([12, 15.5, 9]))
print(moyenne([]))Python12.166666666666666
None#7 Que sont les métaclasses en Python ?
Pourquoi c’est déroutant : une métaclasse est « la classe d’une classe ». Le concept semble abstrait et inutile.
Pourquoi c’est génial : une métaclasse contrôle la façon dont les classes sont créées, pour imposer des règles ou injecter un comportement.
Exemple :
class Meta(type):
def __new__(cls, name, bases, dct):
if 'required_attribute' not in dct:
raise TypeError("Attribut required_attribute manquant")
return super().__new__(cls, name, bases, dct)
class MyClass(metaclass=Meta):
required_attribute = True
print(MyClass.required_attribute)PythonTrueCe qu’il se passe : la métaclasse vérifie que l’attribut required_attribute existe au moment de la création de MyClass. Si ce n’est pas le cas, elle lève une erreur : c’est un contrôle qualité pour tes classes.
try:
class Incomplete(metaclass=Meta):
pass
except TypeError as e:
print("TypeError :", e)PythonTypeError : Attribut required_attribute manquantUne remarque importante : tu n’as presque jamais besoin d’une métaclasse. Pour imposer une règle aux classes filles, __init_subclass__ est plus simple et donne le même résultat :
class Base:
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
if not hasattr(cls, "required_attribute"):
raise TypeError("Attribut required_attribute manquant")
class Valide(Base):
required_attribute = True
try:
class Invalide(Base):
pass
except TypeError as e:
print("TypeError :", e)PythonTypeError : Attribut required_attribute manquant#8 Quelle est la différence entre @staticmethod et @classmethod ?
Pourquoi c’est déroutant : pourquoi en a-t-on besoin, alors que les méthodes habituelles fonctionnent très bien ?
Pourquoi c’est génial : @staticmethod définit une méthode qui n’a besoin ni de l’instance ni de la classe, et @classmethod reçoit la classe (cls) plutôt que l’instance.
Exemple :
class MyClass:
@staticmethod
def static_method():
return "Je n'ai pas besoin d'une instance !"
@classmethod
def class_method(cls):
return f"Je travaille avec {cls.__name__} !"
print(MyClass.static_method())
print(MyClass.class_method())PythonJe n'ai pas besoin d'une instance !
Je travaille avec MyClass !Ce qu’il se passe : static_method ne se préoccupe ni de la classe ni de l’instance, alors que class_method peut accéder à la classe à laquelle elle appartient. Un cas d’usage concret : le constructeur alternatif (@classmethod) et la fonction utilitaire (@staticmethod). Comme margherita utilise cls, appelée depuis une classe fille, elle crée bien une instance de la classe fille :
class Pizza:
INGREDIENTS_CONNUS = {"tomate", "mozzarella", "jambon", "champignons"}
def __init__(self, ingredients):
self.ingredients = ingredients
@classmethod
def margherita(cls): # constructeur alternatif
return cls(["tomate", "mozzarella"])
@staticmethod
def est_valide(ingredient): # utilitaire : n'utilise ni self ni cls
return ingredient in Pizza.INGREDIENTS_CONNUS
class PizzaFamiliale(Pizza):
pass
p = PizzaFamiliale.margherita()
print(p.ingredients)
print(type(p).__name__)
print(Pizza.est_valide("ananas"))Python['tomate', 'mozzarella']
PizzaFamiliale
False#9 Comment __slots__ économise-t-il de la mémoire ?
Pourquoi c’est déroutant : __slots__ semble restreindre la flexibilité, ce qui va à l’encontre de la nature dynamique de Python.
Pourquoi c’est génial : en définissant __slots__, tu dis à Python que les instances n’auront que ces attributs. Elles n’ont plus besoin d’un dictionnaire par objet, ce qui économise de la mémoire quand on crée beaucoup d’objets.
Exemple : je compare deux classes identiques, avec et sans __slots__, pour 100 000 objets :
class SansSlots:
def __init__(self, name, age):
self.name = name
self.age = age
class AvecSlots:
__slots__ = ["name", "age"]
def __init__(self, name, age):
self.name = name
self.age = age
def memoire(cls, n=100_000):
tracemalloc.start()
objets = [cls("Alice", i) for i in range(n)]
courant, _ = tracemalloc.get_traced_memory()
tracemalloc.stop()
return courant / 1e6
print(f"Sans __slots__ : {memoire(SansSlots):.1f} Mo pour 100 000 objets")
print(f"Avec __slots__ : {memoire(AvecSlots):.1f} Mo pour 100 000 objets")PythonSans __slots__ : 12.8 Mo pour 100 000 objets
Avec __slots__ : 8.8 Mo pour 100 000 objetsCe qu’il se passe : sur ma machine, la version avec __slots__ utilise près d’un tiers de mémoire en moins (8,8 Mo contre 12,8 Mo). Le prix à payer : on ne peut plus ajouter d’attributs en dehors de la liste.
a = AvecSlots("Alice", 30)
try:
a.ville = "Zurich"
except AttributeError as e:
print("AttributeError :", e)PythonAttributeError : 'AvecSlots' object has no attribute 'ville' and no __dict__ for setting new attributesC’est donc parfait quand tu manipules des millions de petits objets, et inutile pour quelques instances.
#10 Que sont les descripteurs en Python ?
Pourquoi c’est déroutant : ils reposent sur des méthodes comme __get__, __set__ et __set_name__, qui semblent obscures.
Pourquoi c’est génial : un descripteur te permet de réutiliser la logique de gestion d’un attribut (validation, conversion, journalisation) pour plusieurs attributs ou plusieurs classes.
Exemple : un descripteur Positif qui refuse les valeurs négatives ou nulles, utilisé pour deux attributs sans dupliquer le code :
class Positif:
def __set_name__(self, owner, name):
self.nom = "_" + name
def __get__(self, instance, owner=None):
if instance is None:
return self
return getattr(instance, self.nom)
def __set__(self, instance, value):
if value <= 0:
raise ValueError(f"{self.nom[1:]} doit être positif, reçu {value}")
setattr(instance, self.nom, value)
class Produit:
prix = Positif() # la même logique est réutilisée
quantite = Positif() # pour deux attributs
def __init__(self, prix, quantite):
self.prix = prix
self.quantite = quantite
p = Produit(9.9, 3)
print(p.prix, p.quantite)Python9.9 3Ce qu’il se passe : à chaque affectation (self.prix = prix), Python appelle Positif.__set__, qui valide la valeur. __set_name__ récupère le nom de l’attribut automatiquement. Une valeur invalide est refusée :
try:
p.quantite = -1
except ValueError as e:
print("ValueError :", e)PythonValueError : quantite doit être positif, reçu -1Tu utilises déjà des descripteurs sans le savoir : @property en est un. Le dernier résultat montre que Cercle.aire est de type property :
class Cercle:
def __init__(self, rayon):
self.rayon = rayon
@property # property est un descripteur
def aire(self):
return 3.14159 * self.rayon ** 2
print(Cercle(2).aire)
print(type(Cercle.aire).__name__)Python12.56636
propertyQuestions fréquentes
Faut-il connaître les métaclasses pour programmer en Python ?
Non. Elles sont rarement nécessaires. Pour imposer une règle aux classes filles, la méthode __init_subclass__ ou un décorateur de classe est plus simple et donne le même résultat.
Quelle est la différence entre un générateur et une liste ?
Une liste stocke tous ses éléments en mémoire. Un générateur produit les éléments un par un, à la demande, avec yield. Dans mon test, un million de valeurs occupent 8 448 728 octets dans une liste et 192 octets dans un générateur.
Les indications de type sont-elles obligatoires en Python ?
Non. Python ne les vérifie pas à l’exécution : greet(42) fonctionne même si name est annoté str. Elles servent aux éditeurs et à des outils comme mypy, qui détectent les erreurs avant l’exécution.
Quand utiliser @classmethod plutôt que @staticmethod ?
Utilise @classmethod quand la méthode a besoin de la classe, par exemple pour un constructeur alternatif qui doit aussi fonctionner dans les classes filles. Utilise @staticmethod pour une fonction utilitaire qui n’a besoin ni de la classe ni de l’instance.
__slots__ vaut-il le coup ?
Seulement si tu crées un très grand nombre d’objets. Dans mon test sur 100 000 objets, la version avec __slots__ utilise près d’un tiers de mémoire en moins (8,8 Mo contre 12,8 Mo), mais on ne peut plus ajouter d’attributs en dehors de la liste.
À quoi sert l’opérateur walrus := ?
Il affecte une valeur à une variable au sein d’une expression. Il évite de calculer deux fois la même valeur, par exemple dans une condition if ou dans une compréhension de liste.
Pour t’entraîner, parcours aussi mes 25 extraits de code Python de référence pour ton travail quotidien.
Conclusion : faut-il tout maîtriser ?
Voilà pour ces 10 fonctionnalités. Tu n’as pas besoin de toutes les utiliser au quotidien : les décorateurs, les générateurs, with, les compréhensions et les indications de type sont les plus utiles au début. Les métaclasses et les descripteurs sont plutôt pour les auteurs de bibliothèques. L’essentiel est de les reconnaître quand tu lis du code, et de savoir quand elles simplifient vraiment ton travail.
Pour retrouver l’essentiel d’un coup d’œil, consulte aussi nos astuces et concepts Python pour améliorer ton code.
Pour progresser en Python, le mieux est de pratiquer. Sur DataXp, tu apprends Python et la data science avec des exercices pratiques à faire directement en ligne.
Pour aller plus loin, voici d’autres articles qui pourraient te plaire :













