Patrons de conception Python

Le patron de conception Proxy en Python

Dans cette leçon, vous allez utiliser le patron Proxy pour retarder la création d'un objet coûteux jusqu'à ce qu'on en ait vraiment besoin.

  • Avancé
  • 3 min de lecture
  • 1 exemple exécutable

Introduction

Le problème

Certains objets sont coûteux à créer, comme un gros rapport ou une connexion distante, et ne serviront peut-être même pas. D'autres doivent être protégés, par exemple par une vérification d'accès avant usage. Un proxy se place devant l'objet réel et décide s'il faut l'utiliser, et à quel moment.

Imaginez-le ainsi

Un proxy ressemble au titre d'un rapport dans une liste de documents. Le titre est léger et toujours là ; il représente le gros fichier. Le fichier lui-même n'est chargé que la première fois que vous l'ouvrez, puis il reste ouvert pour toutes les consultations suivantes.

D'une liste de documents au code
ReportProxy()📄 Le titre dans la liste : léger et toujours disponible
if self._report is None:🤔 Le fichier est-il déjà chargé ?
self._report = Report()📥 Charger le vrai rapport, une seule fois
self._report.display()📖 Afficher le contenu du vrai rapport
Le proxy propose la même méthode que l'objet réel et contrôle l'accès à celui-ci.
En une phrase

Le pattern Proxy place devant un objet réel un substitut de même interface, qui en contrôle l'accès.

Points clés

  1. ReportProxy offre la même méthode display() que Report.
  2. self._report commence à None, donc le rapport coûteux n'est pas encore créé.
  3. Le premier appel à display() affiche "Loading report" et crée le vrai Report.
  4. Les appels suivants réutilisent self._report sans le recharger.

Quand l’utiliser ?

  • Le chargement paresseux (lazy loading) d'objets coûteux, comme de gros fichiers ou des images.
  • Le contrôle d'accès, la journalisation ou le cache devant un objet.
  • Les substituts locaux de services distants.

Quand s'en passer

  • L'objet réel est peu coûteux à créer et toujours nécessaire : le proxy ne fait qu'ajouter une couche.
  • functools.cached_property de Python offre déjà le chargement paresseux pour un seul attribut.

Code d’exemple

Exécuter le code →
main.py
class Report:
    # Proxy: stand in for another object and control access to it.
    def display(self): return "Quarterly report"


class ReportProxy:
    def __init__(self): self._report = None

    def display(self):
        # Delay construction until the object is actually needed.
        if self._report is None:
            print("Loading report")
            self._report = Report()
        return self._report.display()


proxy = ReportProxy()
print(proxy.display())
Obtenir un bouton Run pour cet exemple

Résultat de l’exécution

Loading report
Quarterly report

Explication du code

ReportProxy ne crée pas l'objet Report lors de son initialisation. Ce n'est qu'au premier appel de display() que le proxy affiche Loading report, crée le Report et le garde pour les appels suivants. Ainsi, les objets gourmands en ressources ne sont créés que lorsqu'on en a réellement besoin.

Modifiez les valeurs et exécutez le programme avec le compilateur Python en ligne CodeUtility, sans installation locale.

Exercices d’approfondissement

Essayez de modifier le code en suivant les pistes ci-dessous. Changer le code et observer le résultat vous fera bien mieux comprendre la leçon que la simple lecture.

  1. Remplacez le domaine de l’exemple tout en conservant la structure du pattern.
  2. Comparez le pattern à une implémentation plus simple et expliquez les compromis.
  3. Écrivez des tests pour chaque participant avant d’ajouter une autre implémentation.
Exécuter dans le compilateur Python →

Erreurs fréquentes

Créer l'objet réel dans le constructeur

Le chargement paresseux perd alors tout son intérêt.

Problème
def __init__(self):
    self._report = Report()
Correction
def __init__(self):
    self._report = None

Leçon terminée ?

Marquez-la comme apprise pour suivre votre progression.