Jaki jest odpowiednik zmiennych statycznych w Pythonie wewnątrz funkcji?

Jaki jest idiomatyczny odpowiednik Pythona w tym kodzie C / C ++?

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

w szczególności, w jaki sposób implementuje się element statyczny na poziomie funkcji, a nie na poziomie klasy? I czy umieszczenie funkcji w klasie coś zmienia?

Trochę odwrócone, ale to powinno działać:

def foo():
    foo.counter += 1
    print "Counter is %d" % foo.counter
foo.counter = 0

Jeśli chcesz, aby kod inicjalizacji licznika był na górze zamiast na dole, możesz utworzyć dekorator:

def static_vars(**kwargs):
    def decorate(func):
        for k in kwargs:
            setattr(func, k, kwargs[k])
        return func
    return decorate

Następnie użyj kodu w następujący sposób:

@static_vars(counter=0)
def foo():
    foo.counter += 1
    print "Counter is %d" % foo.counter

foo.Niestety nadal będzie wymagać użycia prefiksu.

^{( Źródło : @ony )}

Możesz dodać atrybuty do funkcji i użyć jej jako zmiennej statycznej.

def myfunc():
  myfunc.counter += 1
  print myfunc.counter

# attribute must be initialized
myfunc.counter = 0

Alternatywnie, jeśli nie chcesz ustawiać zmiennej poza funkcją, możesz użyć, hasattr()aby uniknąć AttributeErrorwyjątku:

def myfunc():
  if not hasattr(myfunc, "counter"):
     myfunc.counter = 0  # it doesn't exist yet, so initialize it
  myfunc.counter += 1

W każdym razie zmienne statyczne są raczej rzadkie i powinieneś znaleźć lepsze miejsce dla tej zmiennej, najprawdopodobniej wewnątrz klasy.

Można również rozważyć:

def foo():
    try:
        foo.counter += 1
    except AttributeError:
        foo.counter = 1

Rozumowanie:

• dużo pythonowych („prośba o wybaczenie, a nie pozwolenie”)
• użyj wyjątku (wyrzuconego tylko raz) zamiast ifrozgałęzienia (pomyśl wyjątek StopIteration )

Inne odpowiedzi pokazały, jak należy to zrobić. Oto sposób, w jaki nie powinieneś:

>>> def foo(counter=[0]):
...   counter[0] += 1
...   print("Counter is %i." % counter[0]);
... 
>>> foo()
Counter is 1.
>>> foo()
Counter is 2.
>>> 

Wartości domyślne są inicjowane tylko podczas pierwszej oceny funkcji, a nie za każdym razem, gdy jest wykonywana, dzięki czemu do przechowywania wartości statycznych można użyć listy lub dowolnego obiektu zmiennego.

Wiele osób już sugerowało przetestowanie „hasattr”, ale istnieje prostsza odpowiedź:

def func():
    func.counter = getattr(func, 'counter', 0) + 1

Bez prób / z wyjątkiem, bez testowania hasattr, po prostu getattr z domyślnym.

Oto w pełni zamknięta wersja, która nie wymaga zewnętrznego wywołania inicjalizacji:

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

W Pythonie funkcje są obiektami i możemy po prostu dodawać do nich zmienne składowe lub małpować je za pomocą specjalnego atrybutu __dict__. Wbudowany vars()zwraca specjalny atrybut__dict__ .

EDYCJA: Uwaga, w przeciwieństwie do alternatywy try:except AttributeError odpowiedzi, przy takim podejściu zmienna zawsze będzie gotowa na logikę kodu po inicjalizacji. Myślę, że try:except AttributeErroralternatywą dla poniższych będzie mniej SUSZENIA i / lub niezręczny przepływ:

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

EDYCJA 2: Polecam powyższe podejście tylko wtedy, gdy funkcja będzie wywoływana z wielu lokalizacji. Jeśli zamiast tego funkcja jest wywoływana tylko w jednym miejscu, lepiej użyć 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))
    ...

Python nie ma zmiennych statycznych, ale można go sfałszować, definiując obiekt klasy na żądanie, a następnie używając go jako funkcji. Zobacz także tę odpowiedź .

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

Zauważ, że __call__umożliwia wywołanie klasy (obiektu) według własnej nazwy. Dlatego wywołanie foo()powyższego wywołuje __call__metodę klasy . Z dokumentacji :

Wystąpienia dowolnych klas można wywołać, definiując __call__()metodę w ich klasie.

Użyj funkcji generatora, aby wygenerować iterator.

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

Następnie użyj go jak

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

Jeśli chcesz górny limit:

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

Jeśli iterator zakończy się (jak w powyższym przykładzie), możesz również zapętlić go bezpośrednio, np

for i in foo_gen(20):
    print i

Oczywiście w tych prostych przypadkach lepiej użyć xrange :)

Oto dokumentacja dotycząca deklaracji dochodu .

Inne rozwiązania dołączają do funkcji atrybut licznika, zwykle ze skomplikowaną logiką do obsługi inicjalizacji. Jest to nieodpowiednie dla nowego kodu.

W Pythonie 3 właściwym sposobem jest użycie nonlocalinstrukcji:

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

Zobacz PEP 3104 do specyfikacji nonlocaloświadczeniu.

Jeśli licznik ma być prywatny dla modułu, należy go _counterzamiast tego nazwać .

Używanie atrybutu funkcji jako zmiennej statycznej ma pewne potencjalne wady:

• Za każdym razem, gdy chcesz uzyskać dostęp do zmiennej, musisz wpisać pełną nazwę funkcji.
• Kod zewnętrzny może łatwo uzyskać dostęp do zmiennej i zadzierać z wartością.

Idiomatyczny python dla drugiego problemu prawdopodobnie nazwałby zmienną wiodącym znakiem podkreślenia, aby zasygnalizować, że nie ma do niej dostępu, jednocześnie utrzymując ją dostępną po fakcie.

Alternatywą może być wzorzec wykorzystujący zamknięcia leksykalne, które są obsługiwane przez nonlocalsłowo kluczowe w python 3.

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

Niestety nie wiem, jak zawrzeć to rozwiązanie w dekoratorze.

def staticvariables(**variables):
    def decorate(function):
        for variable in variables:
            setattr(function, variable, variables[variable])
        return function
    return decorate

@staticvariables(counter=0, bar=1)
def foo():
    print(foo.counter)
    print(foo.bar)

Podobnie jak powyższy kod Vincenta, byłby on używany jako dekorator funkcji, a do zmiennych statycznych należy uzyskać dostęp z nazwą funkcji jako prefiksem. Zaletą tego kodu (choć trzeba przyznać, że każdy może być na tyle inteligentny, by to rozgryźć) jest to, że można mieć wiele zmiennych statycznych i inicjować je w bardziej konwencjonalny sposób.

Trochę bardziej czytelny, ale bardziej szczegółowy (Zen of Python: wyraźne jest lepsze niż niejawne):

>>> def func(_static={'counter': 0}):
...     _static['counter'] += 1
...     print _static['counter']
...
>>> func()
1
>>> func()
2
>>>

Zobacz tutaj wyjaśnienie, jak to działa.

_counter = 0
def foo ():
   globalny licznik
   _counter + = 1
   wypisz „counter is”, _counter

Python zwyczajowo używa podkreślników do wskazania zmiennych prywatnych. Jedynym powodem w C, aby zadeklarować zmienną statyczną wewnątrz funkcji, jest ukrycie jej poza funkcją, co nie jest tak naprawdę idiomatycznym Pythonem.

Po wypróbowaniu kilku podejść wykorzystuję ulepszoną wersję odpowiedzi @ warvariuc:

import types

def func(_static=types.SimpleNamespace(counter=0)):
    _static.counter += 1
    print(_static.counter)

Idiomatyczne sposobem jest użycie klasy , które mogą mieć atrybuty. Jeśli potrzebujesz, aby instancje nie były oddzielne, użyj singletonu.

Istnieje wiele sposobów na fałszowanie lub modyfikowanie „statycznych” zmiennych w Pythonie (jednym z dotychczas nie wspomnianych jest modyfikowalny argument domyślny), ale nie jest to Pythoniczny, idiomatyczny sposób. Po prostu użyj klasy.

Lub ewentualnie generator, jeśli twój wzorzec użytkowania pasuje.

Poddane temu pytaniu , czy mogę przedstawić inną alternatywę, która może być nieco przyjemniejsza w użyciu i będzie wyglądać tak samo dla metod i funkcji:

@static_var2('seed',0)
def funccounter(statics, add=1):
    statics.seed += add
    return statics.seed

print funccounter()       #1
print funccounter(add=2)  #3
print funccounter()       #4

class ACircle(object):
    @static_var2('seed',0)
    def counter(statics, self, add=1):
        statics.seed += add
        return statics.seed

c = ACircle()
print c.counter()      #1
print c.counter(add=2) #3
print c.counter()      #4
d = ACircle()
print d.counter()      #5
print d.counter(add=2) #7
print d.counter()      #8    

Jeśli podoba Ci się użycie, oto implementacja:

class StaticMan(object):
    def __init__(self):
        self.__dict__['_d'] = {}

    def __getattr__(self, name):
        return self.__dict__['_d'][name]
    def __getitem__(self, name):
        return self.__dict__['_d'][name]
    def __setattr__(self, name, val):
        self.__dict__['_d'][name] = val
    def __setitem__(self, name, val):
        self.__dict__['_d'][name] = val

def static_var2(name, val):
    def decorator(original):
        if not hasattr(original, ':staticman'):    
            def wrapped(*args, **kwargs):
                return original(getattr(wrapped, ':staticman'), *args, **kwargs)
            setattr(wrapped, ':staticman', StaticMan())
            f = wrapped
        else:
            f = original #already wrapped

        getattr(f, ':staticman')[name] = val
        return f
    return decorator

Kolejnym (niezalecanym!) Zwrotem na wywoływalnym obiekcie, takim jak https://stackoverflow.com/a/279598/916373 , jeśli nie masz nic przeciwko użyciu funky podpisu połączenia, byłoby zrobić

class foo(object):
    counter = 0;
    @staticmethod
    def __call__():
        foo.counter += 1
        print "counter is %i" % foo.counter

>>> foo()()
counter is 1
>>> foo()()
counter is 2

Zamiast tworzyć funkcję posiadającą statyczną zmienną lokalną, zawsze możesz utworzyć tak zwany „obiekt funkcji” i nadać jej standardową (niestatyczną) zmienną składową.

Ponieważ podałeś przykład napisany w C ++, najpierw wyjaśnię, czym jest „obiekt funkcji” w C ++. „Obiekt funkcji” to po prostu dowolna klasa z przeciążeniem operator(). Instancje klasy będą zachowywać się jak funkcje. Na przykład możesz pisać, int x = square(5);nawet jeśli squarejest obiektem (z przeciążeniem operator()) i technicznie nie jest „funkcją”. Możesz nadać obiektowi funkcyjnemu dowolną funkcję, którą możesz nadać obiektowi klasy.

# C++ function object
class Foo_class {
    private:
        int counter;     
    public:
        Foo_class() {
             counter = 0;
        }
        void operator() () {  
            counter++;
            printf("counter is %d\n", counter);
        }     
   };
   Foo_class foo;

W Pythonie możemy również przeciążać, operator()ale zamiast tego nazwa metody __call__:

Oto definicja klasy:

class Foo_class:
    def __init__(self): # __init__ is similair to a C++ class constructor
        self.counter = 0
        # self.counter is like a static member
        # variable of a function named "foo"
    def __call__(self): # overload operator()
        self.counter += 1
        print("counter is %d" % self.counter);
foo = Foo_class() # call the constructor

Oto przykład zastosowanej klasy:

from foo import foo

for i in range(0, 5):
    foo() # function call

Dane wyjściowe drukowane na konsoli to:

counter is 1
counter is 2
counter is 3
counter is 4
counter is 5

Jeśli chcesz, aby twoja funkcja pobierała argumenty wejściowe, możesz również dodać je do __call__:

# FILE: foo.py - - - - - - - - - - - - - - - - - - - - - - - - -

class Foo_class:
    def __init__(self):
        self.counter = 0
    def __call__(self, x, y, z): # overload operator()
        self.counter += 1
        print("counter is %d" % self.counter);
        print("x, y, z, are %d, %d, %d" % (x, y, z));
foo = Foo_class() # call the constructor

# FILE: main.py - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

from foo import foo

for i in range(0, 5):
    foo(7, 8, 9) # function call

# Console Output - - - - - - - - - - - - - - - - - - - - - - - - - - 

counter is 1
x, y, z, are 7, 8, 9
counter is 2
x, y, z, are 7, 8, 9
counter is 3
x, y, z, are 7, 8, 9
counter is 4
x, y, z, are 7, 8, 9
counter is 5
x, y, z, are 7, 8, 9

Soulution n + = 1

def foo():
  foo.__dict__.setdefault('count', 0)
  foo.count += 1
  return foo.count

Globalna deklaracja zapewnia tę funkcjonalność. W poniższym przykładzie (python 3.5 lub nowszy, aby użyć „f”) zmienna licznika jest zdefiniowana poza funkcją. Zdefiniowanie go jako globalnego w funkcji oznacza, że ​​wersja „globalna” poza funkcją powinna zostać udostępniona tej funkcji. Dlatego przy każdym uruchomieniu funkcja modyfikuje wartość poza funkcją, zachowując ją poza funkcją.

counter = 0

def foo():
    global counter
    counter += 1
    print("counter is {}".format(counter))

foo() #output: "counter is 1"
foo() #output: "counter is 2"
foo() #output: "counter is 3"

Zmienna statyczna w metodzie Python

class Count:
    def foo(self):
        try: 
            self.foo.__func__.counter += 1
        except AttributeError: 
            self.foo.__func__.counter = 1

        print self.foo.__func__.counter

m = Count()
m.foo()       # 1
m.foo()       # 2
m.foo()       # 3

Osobiście wolę te niż dekoratorów. Do każdego własnego.

def staticize(name, factory):
    """Makes a pseudo-static variable in calling function.

    If name `name` exists in calling function, return it. 
    Otherwise, saves return value of `factory()` in 
    name `name` of calling function and return it.

    :param name: name to use to store static object 
    in calling function
    :type name: String
    :param factory: used to initialize name `name` 
    in calling function
    :type factory: function
    :rtype: `type(factory())`

    >>> def steveholt(z):
    ...     a = staticize('a', list)
    ...     a.append(z)
    >>> steveholt.a
    Traceback (most recent call last):
    ...
    AttributeError: 'function' object has no attribute 'a'
    >>> steveholt(1)
    >>> steveholt.a
    [1]
    >>> steveholt('a')
    >>> steveholt.a
    [1, 'a']
    >>> steveholt.a = []
    >>> steveholt.a
    []
    >>> steveholt('zzz')
    >>> steveholt.a
    ['zzz']

    """
    from inspect import stack
    # get scope enclosing calling function
    calling_fn_scope = stack()[2][0]
    # get calling function
    calling_fn_name = stack()[1][3]
    calling_fn = calling_fn_scope.f_locals[calling_fn_name]
    if not hasattr(calling_fn, name):
        setattr(calling_fn, name, factory())
    return getattr(calling_fn, name)

Ta odpowiedź opiera się na odpowiedzi @claudiu.

Odkryłem, że mój kod jest coraz mniej wyraźny, gdy zawsze muszę wstawić nazwę funkcji, ilekroć zamierzam uzyskać dostęp do zmiennej statycznej.

Mianowicie w moim kodzie funkcji wolałbym pisać:

print(statics.foo)

zamiast

print(my_function_name.foo)

Więc moim rozwiązaniem jest:

1. dodaj staticsatrybut do funkcji
2. w zakresie funkcji dodaj zmienną lokalną staticsjako alias domy_function.statics

from bunch import *

def static_vars(**kwargs):
    def decorate(func):
        statics = Bunch(**kwargs)
        setattr(func, "statics", statics)
        return func
    return decorate

@static_vars(name = "Martin")
def my_function():
    statics = my_function.statics
    print("Hello, {0}".format(statics.name))

Uwaga

Moja metoda używa klasy o nazwie Bunch, która jest słownikiem obsługującym dostęp w stylu atrybutów, a la JavaScript (zobacz oryginalny artykuł na ten temat, około 2000 r.)

Można go zainstalować za pośrednictwem pip install bunch

Można go również napisać ręcznie:

class Bunch(dict):
    def __init__(self, **kw):
        dict.__init__(self,kw)
        self.__dict__ = self

Opierając się na odpowiedzi Daniela (uzupełnienia):

class Foo(object): 
    counter = 0  

def __call__(self, inc_value=0):
    Foo.counter += inc_value
    return Foo.counter

foo = Foo()

def use_foo(x,y):
    if(x==5):
        foo(2)
    elif(y==7):
        foo(3)
    if(foo() == 10):
        print("yello")


use_foo(5,1)
use_foo(5,1)
use_foo(1,7)
use_foo(1,7)
use_foo(1,1)

Powodem, dla którego chciałem dodać tę część, jest to, że zmienne statyczne są używane nie tylko do zwiększania o jakąś wartość, ale także sprawdzają, czy var statyczny jest równy jakiejś wartości, jako przykład z życia.

Zmienna statyczna jest nadal chroniona i używana tylko w zakresie funkcji use_foo ()

W tym przykładzie wywołanie funkcji foo () działa dokładnie tak, jak (w odniesieniu do odpowiedniego odpowiednika c ++):

stat_c +=9; // in c++
foo(9)  #python equiv

if(stat_c==10){ //do something}  // c++

if(foo() == 10):      # python equiv
  #add code here      # python equiv       

Output :
yello
yello

jeśli klasa Foo jest zdefiniowana jako klasa singleton, byłoby to idealne. To by uczyniło go bardziej pytonicznym.

Jasne, że to stare pytanie, ale myślę, że mogę trochę zaktualizować.

Wygląda na to, że argument dotyczący wydajności jest przestarzały. Ten sam zestaw testów wydaje się dawać podobne wyniki dla siInt_try i isInt_re2. Oczywiście wyniki są różne, ale jest to jedna sesja na moim komputerze z Pythonem 3.4.4 na jądrze 4.3.01 z Xeon W3550. Uruchomiłem go kilka razy, a wyniki wydają się podobne. Przeniosłem globalny regex na funkcję static, ale różnica w wydajności jest znikoma.

isInt_try: 0.3690
isInt_str: 0.3981
isInt_re: 0.5870
isInt_re2: 0.3632

Z problemem wydajnościowym wydaje się, że try / catch stworzy kod najbardziej odporny na przyszłe i narożniki, więc może po prostu zawiń go w funkcję