Cómo utilizar decoradores y el patrón Singleton en Python

Tutorial sobre para qué sirven y cómo utilizar en Python los decoradores además del patrón Singleton. Para este tutorial asumo que conoces python o lo has trabajado alguna vez. Todo el código usado lo tienes en el siguiente link:

Código completo en Github

---

Utilizar un decorador para entrada y salida de funciones

El siguiente decorador es una clase lo que hace es ejecutar la función en el __init__(), para luego hacer una salida por medio del método __call__().

class my_decorator(object):
     def __init__ self , f):
         print("Dentro de my_decorador.__init__()")
         f()

     def __call__ (self):
         print ("Dentro de my_decorador.__call__()")

 @my_decorator
 def my_function():
     print("Dentro de my_function()")

 print("Decorada my_function()")

my_function()

---

Llamar a la función dentro del decorador

Para ejecutar el código dentro de la función decoradora y jugar con él podemos pasarlo como un objeto función, dentro de los parámetros de iniciación del decorador.

class entry_exit(object):
     def __init__ (self, f):
         self.f = f

     def __call__ ( self ):
         print("Entrando en", self.f.__name__)
         self.f() # Llamamos a la función dentro
         print("Saliendo de", self.f,__name__)

@entry_exit
def func1():
     print("Dentro de func1()")

@entry_exit
def func2 ():
     print("Dentro de func2()")

func1()
func2()

En el código anterior hemos llamado a nuestras funciones a través del método call de la clase, pero realmente no necesitamos una clase para eso, podemos decorar con una función:

def entry_exit(f):
    def new_f():   # Mucho más fácil
        print("Entrando en" , f.__name__)
        f()
        print("Exited", f.__name__)
    return new_f

@entry_exit
def func1():
    print("inside func1()")

@entry_exit
def func2():
    print("inside func2()")

func1()
func2()

Si deseas aprender más sobre temas avanzados en Python, puedes acceder a libro online Python 3 Patterns, Recipes and Idioms - Bruce Heckel & Friends. De ahí he traducido la información para este tutorial.

---

Pasar argumentos dentro del decorador:

class decorator_without_arguments(object):
     def __init__(self, f):
         """
Si no especifivamos unos argumentos en el decorador,
la función es pasada al constructor como un objeto
         """
         print("Inside __init__()")
         self.f = f

     def __call__(self, *args):
         """
Cuando llamamos al método __call__ disponemos de
los argumentos que hemos pasado a la función.
         """
         print("Inside __call__()")
         self.f(*args)
         print("After self.f(*args)")

 @decorator_without_arguments
 def sayHello (a1, a2, a3, a4):
     print('sayHello arguments:', a1, a2, a3, a4)

 print ( "After decoration" )

 print ("Preparing to call sayHello()")
 sayHello("say", "hello", "argument", "list")
 print ("After first sayHello() call" )
 sayHello("a", "different", "set of", "arguments")
 print("After second sayHello() call")

La salida de este código sería:

Inside __init__()
After decoration
Preparing to call sayHello ()
Inside __call__()
sayHello arguments : say hello argument list
After self.f(*args)
After first sayHello () call
Inside __call__ ()
sayHello arguments : a different set of arguments
After self.f(*args)
After second sayHello() call

---

Decorador con argumentos

Si has llegado hasta aquí estárás para el siguiente código, que aunque a primera vista parezca difícil, es muy fácil.

class decorator_with_arguments(object):
    # Los argumentos entran como parámetros de la clase
     def __init__ (self, arg1, arg2, arg3):
         # Si hay argumentos en el decorador, la función a
         # ser decorada no es pasada al constructor
         print ( "Inside __init__()" )
         self.arg1 = arg1
         self.arg2 = arg2
         self.arg3 = arg3

     def __call__(self, f):
         # Cuando hay argumentos en el decorador,
         # la función __call__ recibe únicamente
         # el objeto de la función decorada
         print("Inside __call__()")
         def wrapped_f(*args):
             print("Inside wrapped_f()")
             print("Decorator arguments:",
                   self.arg1, self.arg2, self.arg3)
             f(*args)
             print("After f(*args)")
         return wrapped_f

 @decorator_with_arguments("hello", "world", 42)
 def sayHello(a1, a2, a3, a4):
     print ('sayHello arguments:' , a1, a2, a3, a4)

print("After decoration")

print("Preparing to call sayHello()")
sayHello("say", "hello", "argument", "list")
print("after first sayHello() call")
sayHello("a", "different", "set of", "arguments")
print("after second sayHello() call")

---

El patrón Singleton:

Lo que hacemos con este patrón es crear una clase con una variable que se guardara en una clase interna del objeto. Si el objeto no ha sido inicializado no se ha crea la clase interna.

class SoloUno:
    class __SoloUno: # El objeto interno,
        def __init__(self, arg): # con su argumento
            self.val = arg # se hace uno particular
        def __str__(self):
            return repr(self) + self.val
    instance = None # Se llama sólo si no está incializado
    def __init__(self, arg):  # el objeto interno
        if not SoloUno.instance:
            SoloUno.instance = SoloUno.__SoloUno(arg)
        else:  # Por eso el patrón de Singleton (sólo 1)
            SoloUno.instance.val = arg  # Sirve para hacer objetos
   def __getattr__(self, name):   # de tipos diferentes, por ejemplo
        return getattr(self.instance, name)

x = SoloUno('sausage')
print(x)
y = SoloUno('eggs')
print(y)
z = SoloUno('spam')
print(z) print(x)
print(y)
print('x')
print('y')
print('z')
output = '''
<__main__.__OnlyOne instance at 0076B7AC>sausage
<__main__.__OnlyOne instance at 0076B7AC>eggs
<__main__.__OnlyOne instance at 0076B7AC>spam
<__main__.__OnlyOne instance at 0076B7AC>spam
<__main__.__OnlyOne instance at 0076B7AC>spam
<__main__.SoloUno instance at 0076C54C>
<__main__.SoloUno instance at 0076DAAC>
<__main__.SoloUno instance at 0076AA3C>
'''

Uno de los propósitos más interesantes del patrón Singleton es poder crear objetos únicos con un set de atributos común a todos ellos, información que pueden intercambiar. El siguiente es 'Borg', un ejemplo de Alex Martelli:

class Borg:
    _estado_compartido = {} # Atributos que a los que
    def __init__(self):    # accederán los objetos
        self.__dict__ = self._estado_compartido

class Singleton(Borg):
    def __init__(self, arg):
        Borg.__init__(self)
        self.val = arg
    def __str__(self): 
        return self.val

x = Singleton('sausage')
print(x)
y = Singleton('eggs')
print(y)
z = Singleton('spam')
print(z)
print(x)
print(y)
print('x')
print('y')
print('z')
output = '''
sausage
eggs
spam
spam
spam
<__main__.Singleton instance at 0079EF2C>
<__main__.Singleton instance at 0079E10C>
<__main__.Singleton instance at 00798F9C>
''

Una versión más elegante y reducida del código anterior:

class SingleTon(object):
    __instance = None
    def __new__ (cls , val):
        if SingleTon.__instance is None :
            SingleTon.__instance = object.__new__(cls)
        SingleTon.__instance.val = val
        return SingleTon. __instance