Python: die statische variable Dekorateur

Durch die Zeit, die der Dekorator ruft die Funktion Objekt f, es ist schon zusammengestellt-speziell, es ist schon zusammengestellt mit dem wissen, dass x lokal ist (weil es zugeordnet ist, mit der += Zuordnung), die normale Optimierung (in 2.* können Sie besiegen die-Optimierung, bei der eine Staffelung Preis Leistung, indem Sie f mit exec ''; in 2.* können Sie nicht besiegen-Optimierung). Im wesentlichen verwenden die syntax, die Sie sich sehnen, müssen Sie neu kompilieren f (durch die Wiederherstellung seiner Quellen, wenn Sie wissen, Sie werden zur Laufzeit verfügbar, oder viel schwieriger, durch bytecode-hacks) mit irgendwie-modifizierten Quellen -- sobald Sie sich entschieden haben, diesen Weg zu gehen, ist der einfachste Ansatz ist wohl zu ändern x in f.x ganzen Körper von f.

Persönlich, wenn ich finde mich kämpft so hart gegen die Sprache (oder andere Technologie), dass ich versuche, meinem Willen beugen zu verhängen, meine Wünsche, die ich bestätigen, dass ich entweder mit der falschen Sprache (oder einer anderen Technologie), wenn diese Wünsche sind absolut entscheidend, und dann die Lösung muß die Technologie ändern; oder, wenn diese Wünsche sind nicht entscheidend, Sie aufzugeben.

So oder so, ich gebe den Versuch auf, verzerren die Sprache zu weit Weg von den offensichtlichen design-Absichten: auch wenn ich mir einige hacky, fragile Unordnung, es würde kein Zweifel sein, wartbaren. In diesem Fall Python ' s Wunsch Absichten sind sehr klar: barenames, dass ein re-bound innerhalb von Funktionen sind einheimische, die Funktion, es sei denn, die ausdrücklich als globals -- Zeitraum. So, Ihr Versuch zu machen, barenames (, die wieder gebunden wird, innerhalb einer Funktion) etwas völlig anderes bedeuten als "einheimische" ist genau diese Art von kämpfen.

Bearbeiten: Wenn Sie bereit sind zu geben, bis auf das beharren auf die Verwendung barenames für Ihre "Statik", dann plötzlich " Sie kämpfen nicht gegen Python mehr, sondern Sie "gehen mit dem Korn," der Sprache (trotz der design-glitch von global [und nonlocal], aber das ist ein separates schimpfen;-). So zum Beispiel:

class _StaticStuff(object):
  _static_stack = []
  def push(self, d):
    self._static_stack.append(d)
  def pop(self):
    self._static_stack.pop()
  def __getattr__(self, n):
    return self._static_stack[-1][n]
  def __setattr__(self, n, v):
    self._static_stack[-1][n] = v
import __builtin__
__builtin__.static = _StaticStuff()

def with_static(**variables):
  def dowrap(f):
    def wrapper(*a, **k):
      static.push(variables)
      try: return f(*a, **k)
      finally: static.pop()
    return wrapper
  return dowrap

@with_static(x=0)
def f():
    static.x += 1
    print static.x

f()
f()

Diese funktioniert genau so, wie Sie es wünschen, drucken 1 und dann 2. (Ich bin mit __builtin__ machen es einfach zu bedienen ist with_static zu schmücken Funktionen, die das Leben in jedem Modul auch immer, natürlich). Könnten Sie haben verschiedene Implementierungen, aber der entscheidende Punkt einer gute Implementierung ist, dass "statische Variablen" werden qualifizierte Namen, nicht barenames -- machen Sie ausdrücklich, dass Sie keine lokalen Variablen, das Spiel mit der Maserung der Sprache, und so weiter. (Ähnlich built-in Container und qualifizierten Namen, die auf Ihnen basieren, sollte verwendet wurden, in der Python-design, anstelle der global und nonlocal design-Pannen, um anzugeben, andere Arten von Variablen, die nicht lokal sind, und sollten daher nicht verwendet werden barenames... ah gut, Sie selbst zu implementieren, eine globvar spezielle container auf den gleichen Linien von den oben static lieben, ohne selbst benötigen, Dekoration, obwohl, ich bin mir nicht so sicher, das ist durchaus machbar für die nonlocal Fall [vielleicht mit einige Dekoration und die kleinste Menge, von der schwarzen Magie...;=)]).

Bearbeiten: Kommentare weist darauf hin, dass der code wie angegeben funktioniert nicht, wenn Sie nur schmücken den eine Funktion zurückgibt, die einen Verschluss (statt zu schmücken, die Schließung selbst). Das ist richtig: natürlich müssen Sie schmücken die spezifische Funktion, die verwendet das static (und es kann nur eine definition von Funktion-static Variablen!), keine random-Funktion, die nicht in der Tat nutzen die static sondern eben gerade in einige lexikalische Verbindung mit dem hat. Zum Beispiel:

def f():
  @with_static(x=0)
  def g():
    static.x += 1
    print static.x
  return g

x = f()
x()
x()

dieser Werke, während Sie die Dekorator f statt g nicht (und gar nicht).

Wenn die tatsächlichen desiderate sind nicht über statische Variablen (sichtbar und nutzbar nur innerhalb einer Funktion), aber einige hybrid-Ding, brauchbar, in einer bestimmten eigenartigen Bündel von Funktionen, die angegeben werden muss sehr exakt (und ohne Zweifel sehr unterschiedlich ausgeführt, je nachdem, was die tatsächlichen Spezifikationen sind) - und im Idealfall das muss geschehen in einem neuen und trennen SO Fragen, da diese (die ist speziell über statische statt), und die eine Antwort auf diese konkrete Frage, schon reichlich groß genug.

Könnte man so etwas machen (aber das habe ich noch nicht getestet, ausgiebig; verwendet CPython 2.6):

import types

def static(**dict):
    def doWrap(func):
        scope = func.func_globals
        scope.update(dict)
        return types.FunctionType(func.func_code, scope)
    return doWrap

# if foo() prints 43, then it's wrong
x = 42

@static(x = 0)
def foo():
   global x
   x += 1
   print(x)

foo() # => 1
foo() # => 2

Es erfordert Deklaration von Variablen, Globale und Schatten top-level-globalen Variablen, aber sonst funktionieren sollte. Nicht sicher über die Leistung, obwohl.

Hier ist etwas, das vielleicht viel klarer. Es sich nicht um irgendwelche Dekorateure oder hacking.

class F( object ):
    def __init__( self ):
        self.x= 0
    def __call__( self ):
        self.x += 1
        print self.x

f= F()

Nun haben Sie Ihre Funktion f mit einer statischen variable.

f() #prints 1
f() #prints 2

Einem leichten zwicken ein weiterer anwser:

def static(**kwargs):
    def decorator(func):
        return type(func)(func.func_code, dict(func.func_globals, **kwargs))
    return decorator

message = "goodbye, world!"
@static(message="hello, world!")
def hello(): print message

hello()

Fand ich es eklig zum überschreiben eines builtin-name, der eine Funktion argument-name, also habe ich **dict in die mehr kanonische **kwargs. Ich auch rettete ein paar Zeilen und IMO aus der code sauberer durch den Bau einer neuen dict mit dict(the_original, **the_updates). Schließlich rettete ich ein paar Zeilen durch Aufruf der Konstruktor-Funktion über type(func) eher als ein import - ---type und class-Objekte sind factory-Methoden, also nutze Sie!

Ich auch entfernt eine global Erklärung. Dies funktioniert so lange, wie Sie nicht erneut binden der Variablen, d.h. das entfernen global macht in der Tat die Zeiger (aber nicht das Objekt) nur-lese -. Wenn Sie es auf diese Weise, vielleicht let ist ein besserer name als static für die Bindung so eingeführt.