Was ist die Python-Entsprechung von statischen Variablen innerhalb einer Funktion?

Question

Was ist die idiomatische Python-Entsprechung für diesen C/C++-Code?

void foo()
{
    static int counter = 0;
    counter++;
    printf("counter is %d\n", counter);
}

Wie implementiert man das statische Mitglied auf der Funktionsebene, im Gegensatz zur Klassenebene? Und ändert sich etwas, wenn man die Funktion in eine Klasse einordnet?

Answer 1

In Python gibt es keine statischen Variablen, aber man kann sie vortäuschen, indem man ein aufrufbares Klassenobjekt definiert und es dann als Funktion verwendet. Siehe auch diese Antwort .

class Foo(object):
  # Class variable, shared by all instances of this class
  counter = 0

  def __call__(self):
    Foo.counter += 1
    print Foo.counter

# Create an object instance of class "Foo," called "foo"
foo = Foo()

# Make calls to the "__call__" method, via the object's name itself
foo() #prints 1
foo() #prints 2
foo() #prints 3

Beachten Sie, dass __call__ macht eine Instanz einer Klasse (eines Objekts) durch ihren eigenen Namen aufrufbar. Deshalb ist der Aufruf von foo() oben ruft die Klasse __call__ Methode. Aus der Dokumentation :

Instanzen beliebiger Klassen können aufrufbar gemacht werden, indem man eine __call__() Methode in ihrer Klasse.

Answer 2

Hier ist eine vollständig gekapselte Version, die keinen externen Initialisierungsaufruf erfordert:

def fn():
    fn.counter=vars(fn).setdefault('counter',-1)
    fn.counter+=1
    print (fn.counter)

In Python sind Funktionen Objekte, und wir können ihnen einfach Mitgliedsvariablen hinzufügen oder sie mit dem speziellen Attribut __dict__ . Die eingebaute vars() gibt das besondere Attribut __dict__ .

EDIT: Hinweis: Im Gegensatz zur Alternative try:except AttributeError Antwort: Bei diesem Ansatz steht die Variable nach der Initialisierung immer für die Codelogik bereit. Ich denke, die try:except AttributeError Alternativen zu den folgenden sind weniger DRY und/oder haben einen ungünstigen Fluss:

def Fibonacci(n):
   if n<2: return n
   Fibonacci.memo=vars(Fibonacci).setdefault('memo',{}) # use static variable to hold a results cache
   return Fibonacci.memo.setdefault(n,Fibonacci(n-1)+Fibonacci(n-2)) # lookup result in cache, if not available then calculate and store it

EDIT2: Ich empfehle den obigen Ansatz nur, wenn die Funktion von mehreren Stellen aus aufgerufen wird. Wenn die Funktion stattdessen nur an einer Stelle aufgerufen wird, ist es besser, die nonlocal :

def TheOnlyPlaceStaticFunctionIsCalled():
    memo={}
    def Fibonacci(n):
       nonlocal memo  # required in Python3. Python2 can see memo
       if n<2: return n
       return memo.setdefault(n,Fibonacci(n-1)+Fibonacci(n-2))
    ...
    print (Fibonacci(200))
    ...

Answer 3

Verwenden Sie eine Generatorfunktion, um einen Iterator zu erzeugen.

def foo_gen():
    n = 0
    while True:
        n+=1
        yield n

Dann verwenden Sie es wie

foo = foo_gen().next
for i in range(0,10):
    print foo()

Wenn Sie eine Obergrenze wollen:

def foo_gen(limit=100000):
    n = 0
    while n < limit:
       n+=1
       yield n

Wenn der Iterator abbricht (wie im obigen Beispiel), können Sie auch direkt eine Schleife darüber laufen lassen, wie

for i in foo_gen(20):
    print i

In diesen einfachen Fällen ist es natürlich besser, xrange zu verwenden :)

Hier finden Sie die Dokumentation zum Ertragsanweisung .

Answer 4

Andere Lösungen fügen der Funktion ein Zählerattribut hinzu, in der Regel mit einer komplizierten Logik zur Handhabung der Initialisierung. Dies ist für neuen Code unangemessen.

In Python 3 ist der richtige Weg die Verwendung einer nonlocal Erklärung:

counter = 0
def foo():
    nonlocal counter
    counter += 1
    print(f'counter is {counter}')

Siehe PEP 3104 für die Angabe der nonlocal Erklärung.

Wenn der Zähler für das Modul privat sein soll, sollte er den Namen _counter stattdessen.

Answer 5

Die Verwendung eines Attributs einer Funktion als statische Variable hat einige potenzielle Nachteile:

• Jedes Mal, wenn Sie auf die Variable zugreifen wollen, müssen Sie den vollständigen Namen der Funktion ausschreiben.
• Externer Code kann leicht auf die Variable zugreifen und den Wert verändern.

Idiomatisches Python für das zweite Problem wäre wahrscheinlich, die Variable mit einem führenden Unterstrich zu benennen, um zu signalisieren, dass auf sie nicht zugegriffen werden soll, während sie nach der Tat zugänglich bleibt.

Verwendung von Verschlüssen

Eine Alternative wäre ein Muster, das lexikalische Abschlüsse verwendet, die mit dem nonlocal Schlüsselwort in Python 3.

def make_counter():
    i = 0
    def counter():
        nonlocal i
        i = i + 1
        return i
    return counter
counter = make_counter()

Leider kenne ich keine Möglichkeit, diese Lösung in einem Dekorator zu kapseln.

Verwendung eines internen Zustandsparameters

Eine weitere Option könnte ein undokumentierter Parameter sein, der als Container für veränderbare Werte dient.

def counter(*, _i=[0]):
    _i[0] += 1
    return _i[0]

Das funktioniert, weil die Standardargumente bei der Definition der Funktion ausgewertet werden und nicht erst beim Aufruf der Funktion.

Sauberer wäre es, wenn man statt der Liste einen Containertyp hätte, z. B.

def counter(*, _i = Mutable(0)):
    _i.value += 1
    return _i.value

aber mir ist kein eingebauter Typ bekannt, der den Zweck eindeutig angibt.