10 fonctionnalités Python avancées, expliquées simplement

couverture fonctionnalites python

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.

Tableau des 10 fonctionnalités Python avancées : décorateurs, générateurs, walrus, métaclasses, slots et descripteurs

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])
Python
Python 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()
Python
Hello!
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__)
Python
Appel de additionner avec (2, 3)
Résultat : 5
additionner

Les 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)
Python
1
2
3
4
5

Ce 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é")
Python
1
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)))
Python
Liste       : 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)
Python
Bonjour depuis Python !
Fichier fermé : True

Ce 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 ...")
Python
Début : chargement
... traitement en cours ...
Fin : chargement

Le 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")
Python
Début : calcul
Fin : calcul
Erreur interceptée, mais la section a bien été fermée

C’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ératrice
Python
{'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}) !")
Python
Trop 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__)
Python
Hello 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écution
Python
Hello 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([]))
Python
12.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)
Python
True

Ce 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)
Python
TypeError : Attribut required_attribute manquant

Une 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)
Python
TypeError : 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())
Python
Je 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")
Python
Sans __slots__ : 12.8 Mo pour 100 000 objets
Avec __slots__ : 8.8 Mo pour 100 000 objets

Ce 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)
Python
AttributeError : 'AvecSlots' object has no attribute 'ville' and no __dict__ for setting new attributes

C’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)
Python
9.9 3

Ce 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)
Python
ValueError : quantite doit être positif, reçu -1

Tu 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__)
Python
12.56636
property

Questions 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 :

Publications similaires

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *