Atributos da função Python - usos e abusos [fechado]

Muitos não estão cientes desse recurso, mas as funções (e métodos) do Python podem ter atributos . Ver:

>>> def foo(x):
...     pass
...     
>>> foo.score = 10
>>> dir(foo)
['__call__', '__class__', '__delattr__', '__dict__', '__doc__', '__get__', '__getattribute__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name', 'score']
>>> foo.score
10
>>> foo.score += 1
>>> foo.score
11

Quais são os possíveis usos e abusos desse recurso no Python? Um bom uso que eu conheço é o uso da doutrina PLY para associar uma regra de sintaxe a um método. Mas e os atributos personalizados? Existem boas razões para usá-los?

Normalmente, uso atributos de função como armazenamento para anotações. Suponha que eu queira escrever, no estilo de C # (indicando que um determinado método deve fazer parte da interface de serviço da web)

class Foo(WebService):
    @webmethod
    def bar(self, arg1, arg2):
         ...

então eu posso definir

def webmethod(func):
    func.is_webmethod = True
    return func

Em seguida, quando chega uma chamada de serviço da web, procuro o método, verifico se a função subjacente tem o atributo is_webmethod (o valor real é irrelevante) e recuso o serviço se o método estiver ausente ou não for chamado pela Web.

Eu os usei como variáveis ​​estáticas para uma função. Por exemplo, dado o seguinte código C:

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

Eu posso implementar a função da mesma forma em Python:

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

Isso definitivamente se enquadra no "abuso" do fim do espectro.

Você pode fazer objetos da maneira JavaScript ... Não faz sentido, mas funciona;)

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

Eu os uso com moderação, mas eles podem ser bastante convenientes:

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

Agora eu posso usar em logtodo o meu módulo e redirecionar a saída simplesmente configurando log.logfile. Existem muitas outras maneiras de conseguir isso, mas essa é leve e simples. E embora tenha cheirado engraçado na primeira vez que fiz isso, acredito que cheira melhor do que ter uma logfilevariável global .

Os atributos de função podem ser usados ​​para gravar fechamentos leves que agrupam código e dados associados:

#!/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

Eu criei este decorador auxiliar para definir facilmente os atributos das funções:

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

Um caso de uso é criar uma coleção de fábricas e consultar o tipo de dados que eles podem criar no nível meta de função.
Por exemplo (muito idiota):

@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

Às vezes, uso um atributo de uma função para armazenar em cache valores já calculados. Você também pode ter um decorador genérico que generalize essa abordagem. Esteja ciente de problemas de simultaneidade e efeitos colaterais de tais funções!

Eu sempre assumi que a única razão pela qual isso era possível era que havia um lugar lógico para colocar uma sequência de documentos ou outras coisas desse tipo. Eu sei que se eu o usasse para qualquer código de produção, confundiria a maioria dos que o liam.