Atributos de función de Python-usos y abusos [cerrado]

Las he usado como variables estáticas para una función. Por ejemplo, dado el siguiente código C:

int fn(int i)
{
    static f = 1;
    f += i;
    return f;
}

Puedo implementar la función de manera similar en Python:

def fn(i):
    fn.f += i
    return fn.f
fn.f = 1

Esto definitivamente caería en el extremo de los "abusos" del espectro.

Puede hacer objetos de la manera JavaScript... No tiene sentido, pero funciona ;)

>>> def FakeObject():
...   def test():
...     print "foo"
...   FakeObject.test = test
...   return FakeObject
>>> x = FakeObject()
>>> x.test()
foo

Los uso con moderación, pero pueden ser bastante convenientes:

def log(msg):
   log.logfile.write(msg)

Ahora puedo usar log a lo largo de mi módulo, y redirigir la salida simplemente configurando log.logfile. Hay muchas y muchas otras formas de lograr eso, pero esta es liviana y muy simple. Y aunque olía raro la primera vez que lo hice, he llegado a creer que huele mejor que tener una variable global logfile.

Los atributos de función se pueden usar para escribir cierres ligeros que envuelven código y datos asociados juntos:

#!/usr/bin/env python

SW_DELTA = 0
SW_MARK  = 1
SW_BASE  = 2

def stopwatch():
   import time

   def _sw( action = SW_DELTA ):

      if action == SW_DELTA:
         return time.time() - _sw._time

      elif action == SW_MARK:
         _sw._time = time.time()
         return _sw._time

      elif action == SW_BASE:
         return _sw._time

      else:
         raise NotImplementedError

   _sw._time = time.time() # time of creation

   return _sw

# test code
sw=stopwatch()
sw2=stopwatch()
import os
os.system("sleep 1")
print sw() # defaults to "SW_DELTA"
sw( SW_MARK )
os.system("sleep 2")
print sw()
print sw2()

1.00934004784

2.00644397736

3.01593494415

A veces uso un atributo de una función para almacenar en caché valores ya calculados. También puede tener un decorador genérico que generalice este enfoque. Tenga en cuenta los problemas de concurrencia y los efectos secundarios de tales funciones!

Siempre asumí que la única razón por la que esto era posible era que había un lugar lógico para poner una cadena de documentos u otras cosas similares. Sé que si lo usara para cualquier código de producción confundiría a la mayoría de los que lo leen.

He creado este decorador auxiliar para establecer fácilmente atributos de función:

def with_attrs(**func_attrs):
    """Set attributes in the decorated function, at definition time.
    Only accepts keyword arguments.
    E.g.:
        @with_attrs(counter=0, something='boing')
        def count_it():
            count_it.counter += 1
        print count_it.counter
        print count_it.something
        # Out:
        # >>> 0
        # >>> 'boing'
    """
    def attr_decorator(fn):
        @wraps(fn)
        def wrapper(*args, **kwargs):
            return fn(*args, **kwargs)

        for attr, value in func_attrs.iteritems():
            setattr(wrapper, attr, value)

        return wrapper

    return attr_decorator

Un caso de uso es crear una colección de fábricas y consultar el tipo de datos que pueden crear a un nivel meta de función.
Por ejemplo (uno muy tonto):

@with_attrs(datatype=list)
def factory1():
    return [1, 2, 3]

@with_attrs(datatype=SomeClass)
def factory2():
    return SomeClass()

factories = [factory1, factory2]

def create(datatype):
    for f in factories:
        if f.datatype == datatype:
            return f()
    return None