Что такое Python-эквивалент статических переменных внутри функции?

Каков идиоматический эквивалент Python этого кода C / C ++?

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

в частности, как реализовать статический член на уровне функций, а не на уровне классов? И что-то меняет размещение функции в классе?

Немного наоборот, но это должно работать:

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

Если вы хотите, чтобы код инициализации счетчика находился сверху, а не снизу, вы можете создать декоратор:

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

Затем используйте код как это:

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

К foo.сожалению, вам все равно потребуется использовать префикс.

^{(Кредит: @ony )}

Вы можете добавить атрибуты в функцию и использовать ее в качестве статической переменной.

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

# attribute must be initialized
myfunc.counter = 0

В качестве альтернативы, если вы не хотите устанавливать переменную вне функции, вы можете использовать, hasattr()чтобы избежать AttributeErrorисключения:

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

В любом случае статические переменные довольно редки, и вы должны найти лучшее место для этой переменной, скорее всего, внутри класса.

Можно также рассмотреть:

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

Обоснование:

• очень питонно («прошу прощения, а не разрешения»)
• использовать исключение (выбрасывается только один раз) вместо ifответвления (подумайте об исключении StopIteration )

Другие ответы продемонстрировали, как вы должны это сделать. Вот способ, которым вы не должны:

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

Значения по умолчанию инициализируются только при первой оценке функции, а не при каждом ее выполнении, поэтому вы можете использовать список или любой другой изменяемый объект для хранения статических значений.

Многие уже предложили протестировать hasattr, но есть более простой ответ:

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

Нет попытки / кроме, нет тестирования hasattr, просто getattr по умолчанию.

Вот полностью инкапсулированная версия, которая не требует внешнего вызова инициализации:

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

В Python функции являются объектами, и мы можем просто добавить или исправить патч переменные-члены к ним через специальный атрибут __dict__. Встроенныйvars() возвращает специальный атрибут __dict__.

РЕДАКТИРОВАТЬ: Обратите внимание, в отличие от альтернативного try:except AttributeErrorответа, при таком подходе переменная всегда будет готова для логики кода после инициализации. Я думаю, что try:except AttributeErrorальтернатива следующему будет менее СУХОЙ и / или иметь неловкий поток:

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

РЕДАКТИРОВАТЬ 2: Я рекомендую вышеупомянутый подход только тогда, когда функция будет вызываться из нескольких мест. Если вместо этого функция вызывается только в одном месте, лучше использовать 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 не имеет статических переменных, но вы можете подделать его, определив вызываемый объект класса, а затем используя его как функцию. Также посмотрите этот ответ .

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

Обратите внимание, что __call__делает экземпляр класса (объекта) вызываемым по его собственному имени. Вот почему вызов foo()выше вызывает метод класса __call__. Из документации :

Экземпляры произвольных классов могут быть вызваны путем определения __call__()метода в их классе.

Используйте функцию генератора для генерации итератора.

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

Тогда используйте это как

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

Если вы хотите верхний предел:

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

Если итератор завершается (как в примере выше), вы также можете зацикливаться на нем напрямую, например

for i in foo_gen(20):
    print i

Конечно, в этих простых случаях лучше использовать xrange :)

Вот документация о доходности .

Другие решения прикрепляют к функции атрибут counter, обычно с запутанной логикой для обработки инициализации. Это не подходит для нового кода.

В Python 3 правильным способом является использование nonlocalинструкции:

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

См. PEP 3104 для уточнения nonlocalзаявления.

Если счетчик предназначен для частного модуля, он должен быть назван _counterвместо.

Использование атрибута функции в качестве статической переменной имеет некоторые потенциальные недостатки:

• Каждый раз, когда вы хотите получить доступ к переменной, вы должны выписать полное имя функции.
• Внешний код может легко обращаться к переменной и связываться со значением.

Идиоматический питон для второй проблемы, вероятно, будет именовать переменную с начальным подчеркиванием, чтобы сигнализировать, что к ней нельзя обращаться, сохраняя ее доступной после факта.

Альтернативой может быть шаблон, использующий лексические замыкания, которые поддерживаются nonlocalключевым словом в python 3.

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

К сожалению, я не знаю способа инкапсулировать это решение в декоратор.

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)

Подобно приведенному выше коду Винсента, он будет использоваться в качестве декоратора функции, и к статическим переменным нужно обращаться с именем функции в качестве префикса. Преимущество этого кода (хотя по общему признанию любой может быть достаточно умен, чтобы понять это) состоит в том, что вы можете иметь несколько статических переменных и инициализировать их более обычным способом.

Чуть более читабельным, но более многословным (Zen of Python: явный лучше, чем неявный):

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

Смотрите здесь для объяснения того, как это работает.

_counter = 0
def foo ():
   глобальный _counter
   _counter + = 1
   выведите 'counter is', _counter

Python обычно использует подчеркивания для обозначения приватных переменных. Единственная причина в C объявить статическую переменную внутри функции - это скрыть ее за пределами функции, что на самом деле не является идиоматическим Python.

Попробовав несколько подходов, я в итоге использую улучшенную версию ответа @ warvariuc:

import types

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

Идиоматический способ заключается в использовании класса , который может иметь атрибуты. Если вам нужно, чтобы экземпляры не были разделены, используйте синглтон.

Есть несколько способов, которыми вы могли бы подделать или изменить «статические» переменные в Python (один из них не упоминался до сих пор - иметь изменяемый аргумент по умолчанию), но это не Python, идиоматический способ сделать это. Просто используйте класс.

Или, возможно, генератор, если ваш шаблон использования подходит.

В ответ на этот вопрос я могу представить другую альтернативу, которая может быть более приятной для использования и будет выглядеть одинаково как для методов, так и для функций:

@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    

Если вам нравится использование, вот реализация:

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

Другой (не рекомендуется!) Поворот вызываемого объекта, например https://stackoverflow.com/a/279598/916373 , если вы не возражаете против использования подписи в стиле фанк-вызова, это сделать

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

Вместо создания функции, имеющей статическую локальную переменную, вы всегда можете создать так называемый «объект функции» и присвоить ей стандартную (нестатическую) переменную-член.

Поскольку вы привели пример, написанный на C ++, я сначала объясню, что такое «функциональный объект» в C ++. «Функциональный объект» - это просто любой класс с перегруженным operator(). Экземпляры класса будут вести себя как функции. Например, вы можете написать, int x = square(5);даже если squareэто объект (с перегруженным operator()), а не технически не «функция». Вы можете дать объекту-функции любую из функций, которые вы могли бы дать объекту класса.

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

В Python мы также можем перегрузить, operator()за исключением того, что метод вместо этого называется __call__:

Вот определение класса:

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

Вот пример используемого класса:

from foo import foo

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

Вывод на консоль выводится:

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

Если вы хотите, чтобы ваша функция принимала входные аргументы, вы также можете добавить их в __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

Глобальная декларация обеспечивает эту функциональность. В приведенном ниже примере (Python 3.5 или выше, чтобы использовать «f»), переменная counter определяется вне функции. Определение его как глобального в функции означает, что «глобальная» версия вне функции должна быть доступна для функции. Таким образом, каждый раз, когда функция запускается, она изменяет значение вне функции, сохраняя его вне функции.

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"

Статическая переменная внутри метода 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

Я лично предпочитаю следующее декораторам. Каждому свое.

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)

Этот ответ основан на ответе @claudiu.

Я обнаружил, что мой код становится менее понятным, когда мне всегда приходилось добавлять имя функции всякий раз, когда я собираюсь получить доступ к статической переменной.

А именно, в моем коде функции я бы предпочел написать:

print(statics.foo)

вместо

print(my_function_name.foo)

Итак, мое решение состоит в том, чтобы:

1. добавить statics атрибут в функцию
2. в области действия функции добавьте локальную переменную staticsв качестве псевдонимаmy_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))

замечание

Мой метод использует класс с именем Bunch, который является словарем, который поддерживает доступ стиля атрибута, как JavaScript (см. Оригинальную статью об этом, около 2000 г.)

Может быть установлен через pip install bunch

Это также может быть написано от руки так:

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

Опираясь на ответ Даниила (дополнения):

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)

Причина, по которой я хотел добавить эту часть, состоит в том, что статические переменные используются не только для приращения на какое-то значение, но и для проверки того, равно ли статическое значение var некоторому значению, как пример из реальной жизни.

Статическая переменная все еще защищена и используется только в рамках функции use_foo ()

В этом примере вызов функции foo () точно такой же (по отношению к соответствующему эквиваленту 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

если класс Foo определен ограниченно как класс синглтона, это было бы идеально. Это сделало бы это более питоническим.

Конечно, это старый вопрос, но я думаю, что мог бы предоставить некоторые обновления.

Кажется, что аргумент производительности устарел. Похоже, один и тот же набор тестов дает схожие результаты для siInt_try и isInt_re2. Конечно, результаты могут отличаться, но это один сеанс на моем компьютере с python 3.4.4 на ядре 4.3.01 с Xeon W3550. Я запускал его несколько раз, и результаты кажутся похожими. Я переместил глобальное регулярное выражение в статическую функцию, но разница в производительности незначительна.

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

С учетом проблемы с производительностью кажется, что try / catch будет генерировать код, наиболее подходящий для будущего и заглавных букв, поэтому, возможно, просто оберните его в функцию