Patrones de diseño en Python

El patrón de diseño Proxy en Python

En esta lección vas a usar el patrón Proxy para retrasar la creación de un objeto costoso hasta que de verdad haga falta.

  • Avanzado
  • 3 min de lectura
  • 1 ejemplo ejecutable

Introducción

El problema

Algunos objetos son caros de crear, como un informe grande o una conexión remota, y puede que ni siquiera hagan falta. Otros necesitan protección, como una comprobación de acceso antes de usarlos. Un proxy se pone delante del objeto real y decide si hace falta usarlo y cuándo.

Imagínalo así

Un proxy es como el título de un informe en una lista de documentos. El título es ligero y siempre está ahí, en lugar del archivo pesado. El archivo de verdad solo se carga la primera vez que lo abres, y se queda abierto para todas las veces siguientes.

De una lista de documentos al código
ReportProxy()📄 El título en la lista: ligero y siempre disponible
if self._report is None:🤔 ¿Ya se cargó el archivo?
self._report = Report()📥 Carga el informe de verdad, una sola vez
self._report.display()📖 Muestra el contenido del informe de verdad
El proxy ofrece el mismo método y controla el acceso al objeto real.
En una frase

El patrón Proxy pone un objeto sustituto con la misma interfaz delante de un objeto real para controlar el acceso a él.

Puntos clave

  1. ReportProxy ofrece el mismo método display() que Report.
  2. self._report empieza como None, así que el informe caro todavía no se crea.
  3. La primera llamada a display() imprime "Loading report" y crea el Report real.
  4. Las llamadas siguientes reutilizan self._report sin cargarlo otra vez.

¿Cuándo se usa?

  • Carga perezosa (lazy loading) de objetos caros, como archivos o imágenes grandes.
  • Control de acceso, registro o caché delante de un objeto.
  • Sustitutos locales de servicios remotos.

Cuándo no hace falta

  • El objeto real es barato y siempre hace falta: el proxy solo añade una capa.
  • functools.cached_property de Python ya ofrece carga perezosa para un solo atributo.

Código de ejemplo

Ejecutar código →
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())
Obtén un botón Run para este ejemplo

Resultado de la ejecución

Loading report
Quarterly report

Explicación del código

ReportProxy no crea el objeto Report al inicializarse. Solo en la primera llamada a display() el proxy muestra Loading report, crea el Report y lo guarda para las llamadas siguientes. Así, los objetos que consumen muchos recursos solo se crean cuando de verdad se necesitan.

Cambia los valores y ejecuta el programa en el compilador Python online de CodeUtility sin instalar Python.

Ejercicios de práctica

Prueba a modificar el código siguiendo las ideas de abajo. Cambiar el código y ver el resultado te ayudará a entender la lección mucho mejor que solo leerla.

  1. Sustituye el dominio del ejemplo conservando la estructura del patrón.
  2. Compara el patrón con una implementación más sencilla y explica las ventajas y desventajas.
  3. Escribe pruebas para cada participante antes de añadir otra implementación.
Ejecutar en el compilador de Python →

Errores comunes

Crear el objeto real en el constructor

Eso elimina la ventaja de la carga perezosa.

Problema
def __init__(self):
    self._report = Report()
Solución
def __init__(self):
    self._report = None

¿Terminaste esta lección?

Márcala como aprendida para seguir tu progreso.