Design pattern in Python

Il design pattern Proxy in Python

In questa lezione userai il pattern Proxy per rimandare la creazione di un oggetto costoso finché non serve davvero.

  • Avanzato
  • 3 min di lettura
  • 1 esempio eseguibile

Introduzione

Il problema

Alcuni oggetti sono costosi da creare, come un grande report o una connessione remota, e potrebbero anche non servire. Altri hanno bisogno di protezione, come un controllo di accesso prima dell'uso. Un proxy sta davanti all'oggetto vero e decide quando e se usarlo.

Immaginalo così

Un proxy è come il titolo di un report in un elenco di documenti. Il titolo è leggero ed è sempre lì, al posto del file pesante. Il file vero viene caricato solo la prima volta che lo apri, e poi resta aperto per tutte le volte successive.

Dall'elenco di documenti al codice
ReportProxy()📄 Il titolo nell'elenco: leggero e sempre disponibile
if self._report is None:🤔 Il file è già stato caricato?
self._report = Report()📥 Carica il report vero, una volta sola
self._report.display()📖 Mostra il contenuto del report vero
Il proxy offre lo stesso metodo e controlla l'accesso all'oggetto vero.
In una frase

Il pattern Proxy mette un oggetto sostituto con la stessa interfaccia davanti a un oggetto vero per controllarne l'accesso.

Punti chiave

  1. ReportProxy offre lo stesso metodo display() di Report.
  2. self._report parte da None, quindi il report costoso non viene ancora creato.
  3. La prima chiamata a display() stampa "Loading report" e crea il vero Report.
  4. Le chiamate successive riusano self._report senza caricarlo di nuovo.

Quando si usa?

  • Caricamento pigro di oggetti costosi, come file grandi o immagini.
  • Controllo di accesso, logging o cache davanti a un oggetto.
  • Sostituti locali di servizi remoti.

Quando non serve

  • L'oggetto vero è economico e serve sempre: il proxy aggiunge solo uno strato.
  • functools.cached_property di Python dà già il caricamento pigro per un singolo attributo.

Codice di esempio

Esegui codice →
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())
Crea un pulsante Run per questo esempio

Risultato dell'esecuzione

Loading report
Quarterly report

Spiegazione del codice

ReportProxy non crea l'oggetto Report quando viene inizializzato. Solo alla prima chiamata di display() il proxy stampa Loading report, crea il Report e lo conserva per le chiamate successive. Così gli oggetti che consumano molte risorse vengono creati solo quando servono davvero.

Modifica i valori ed esegui il programma nel compilatore Python online CodeUtility senza installare Python.

Esercizi di approfondimento

Prova a modificare il codice seguendo i suggerimenti qui sotto. Cambiare il codice e osservare il risultato ti aiuta a capire molto più che leggerlo soltanto.

  1. Sostituisci il dominio di esempio mantenendo la struttura del pattern.
  2. Confronta il pattern con un’implementazione più semplice e spiegane i compromessi.
  3. Scrivi test per ogni partecipante prima di aggiungere un’altra implementazione.
Esegui nel compilatore Python →

Errori comuni

Creare l'oggetto vero nel costruttore

Così si perde il vantaggio del caricamento pigro.

Problema
def __init__(self):
    self._report = Report()
Correzione
def __init__(self):
    self._report = None

Hai finito questa lezione?

Segnala come imparata per tenere traccia dei tuoi progressi.