Python-Funktionsattribute - verwendet und missbraucht [geschlossen]

Nicht viele kennen diese Funktion, aber Pythons Funktionen (und Methoden) können Attribute haben . Erblicken:

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

Was sind die möglichen Verwendungen und Missbräuche dieser Funktion in Python? Eine gute Verwendung, die mir bekannt ist , ist die Verwendung der Dokumentzeichenfolge durch PLY , um einer Methode eine Syntaxregel zuzuordnen. Aber was ist mit benutzerdefinierten Attributen? Gibt es gute Gründe, sie zu benutzen?

Normalerweise verwende ich Funktionsattribute als Speicher für Anmerkungen. Angenommen, ich möchte im Stil von C # schreiben (was darauf hinweist, dass eine bestimmte Methode Teil der Webdienstschnittstelle sein sollte).

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

dann kann ich definieren

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

Wenn dann ein Webservice-Aufruf eintrifft, schaue ich nach der Methode, überprüfe, ob die zugrunde liegende Funktion das Attribut is_webmethod hat (der tatsächliche Wert ist irrelevant), und lehne den Service ab, wenn die Methode fehlt oder nicht über das Web aufgerufen werden soll.

Ich habe sie als statische Variablen für eine Funktion verwendet. Beispiel: Geben Sie den folgenden C-Code ein:

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

Ich kann die Funktion in Python ähnlich implementieren:

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

Dies würde definitiv in das Ende des Spektrums "Missbrauch" fallen.

Sie können Objekte auf JavaScript-Weise erstellen ... Es macht keinen Sinn, aber es funktioniert;)

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

Ich benutze sie sparsam, aber sie können ziemlich praktisch sein:

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

Jetzt kann ich logmein Modul verwenden und die Ausgabe einfach durch Einstellen umleiten log.logfile. Es gibt viele, viele andere Möglichkeiten, dies zu erreichen, aber dieses ist leicht und schmutzig einfach. Und obwohl es beim ersten Mal komisch roch, habe ich geglaubt, dass es besser riecht als eine globale logfileVariable.

Funktionsattribute können verwendet werden, um leichte Verschlüsse zu schreiben, die Code und zugehörige Daten zusammenfassen:

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

Ich habe diesen Hilfsdekorator erstellt, um Funktionsattribute einfach festzulegen:

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

Ein Anwendungsfall besteht darin, eine Sammlung von Fabriken zu erstellen und den Datentyp abzufragen, den sie auf Funktionsmetaebene erstellen können.
Zum Beispiel (sehr dumm):

@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

Manchmal verwende ich ein Attribut einer Funktion zum Zwischenspeichern bereits berechneter Werte. Sie können auch einen generischen Dekorateur haben, der diesen Ansatz verallgemeinert. Beachten Sie Parallelitätsprobleme und Nebenwirkungen solcher Funktionen!

Ich war immer der Annahme, dass der einzige Grund, warum dies möglich war, darin bestand, dass es einen logischen Ort gab, an dem ein Doc-String oder ähnliches eingefügt werden konnte. Ich weiß, wenn ich es für einen Produktionscode verwenden würde, würde es die meisten, die es lesen, verwirren.