Attributi della funzione Python - usa e abusa [chiuso]

Non molti sono a conoscenza di questa funzionalità, ma le funzioni (e i metodi) di Python possono avere attributi . Ecco:

>>> 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

Quali sono i possibili usi e abusi di questa funzione in Python? Un buon uso di cui sono a conoscenza è l'uso da parte di PLY del docstring per associare una regola di sintassi a un metodo. Ma per quanto riguarda gli attributi personalizzati? Ci sono buoni motivi per usarli?

In genere utilizzo gli attributi della funzione come memoria per le annotazioni. Supponiamo di voler scrivere, nello stile di C # (indicando che un determinato metodo dovrebbe far parte dell'interfaccia del servizio Web)

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

allora posso definire

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

Quindi, quando arriva una chiamata al servizio web, cerco il metodo, controllo se la funzione sottostante ha l'attributo is_webmethod (il valore effettivo è irrilevante) e rifiuto il servizio se il metodo è assente o non è destinato a essere chiamato sul web.

Li ho usati come variabili statiche per una funzione. Ad esempio, dato il seguente codice C:

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

Posso implementare la funzione in modo simile in Python:

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

Ciò finirebbe sicuramente con la fine degli "abusi" dello spettro.

Puoi fare oggetti nel modo JavaScript ... Non ha senso ma funziona;)

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

Li uso con parsimonia, ma possono essere piuttosto convenienti:

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

Ora posso usare logtutto il mio modulo e reindirizzare l'output semplicemente impostando log.logfile. Ci sono molti altri modi per farlo, ma questo è leggero e sporco. E mentre aveva un odore divertente la prima volta che l'ho fatto, sono arrivato a credere che abbia un odore migliore che avere una logfilevariabile globale .

Gli attributi di funzione possono essere utilizzati per scrivere chiusure leggere che racchiudono codice e dati associati:

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

Ho creato questo helper decorator per impostare facilmente gli attributi della funzione:

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 d'uso è creare una raccolta di fabbriche e interrogare il tipo di dati che possono creare a un livello meta funzione.
Ad esempio (molto stupido):

@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

A volte utilizzo un attributo di una funzione per memorizzare nella cache valori già calcolati. Puoi anche avere un decoratore generico che generalizza questo approccio. Fai attenzione ai problemi di concorrenza e agli effetti collaterali di tali funzioni!

Sono sempre stato del presupposto che l'unica ragione per cui ciò era possibile era quindi c'era un posto logico per mettere una stringa di documenti o altre cose del genere. So che se lo usassi per qualsiasi codice di produzione, confonderebbe la maggior parte di chi lo legge.