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

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

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

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

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

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

^{(Credit: @ony)}

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

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

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

_counter = 0
def foo():
   global _counter
   _counter += 1
   print 'counter is', _counter

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

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

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

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

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__. Из документации:

Instances of arbitrary classes can be made callable by defining a __call__() method in their class.

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

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

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

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

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)

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

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

EDIT2: я рекомендую вышеуказанный подход только тогда, когда функция будет вызываться из нескольких мест. Если вместо этого функция вызывается только в одном месте, лучше использовать 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))
    ...

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

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

Рассуждение:

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

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

@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

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

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

Нет try / except, нет hasattr для тестирования, просто getattr со значением по умолчанию.

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

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

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

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

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

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

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

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

Другой (не рекомендуется!) Поворот вызываемого объекта, такого как 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

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

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

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

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

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

>>> def func(_static = {'counter': 0}):
...     _static['counter'] += 1
...     print _static['counter']
...
>>> func()
1
>>> func()
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

Этот ответ основан на ответе @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

Soulution n + = 1

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

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

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

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

См. PEP 3104 для спецификации оператора nonlocal.

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

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

import types

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

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

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)

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

Статическая переменная по-прежнему защищена и используется только в рамках функции 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 определен строго как одноэлементный класс, это было бы идеально. Это сделало бы его более питоническим.

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

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"

Я пишу простую функцию для использования статических переменных:

def Static():
    ### get the func object by which Static() is called.
    from inspect import currentframe, getframeinfo
    caller = currentframe().f_back
    func_name = getframeinfo(caller)[2]
    # print(func_name)
    caller = caller.f_back
    func = caller.f_locals.get(
        func_name, caller.f_globals.get(
            func_name
        )
    )
    
    class StaticVars:
        def has(self, varName):
            return hasattr(self, varName)
        def declare(self, varName, value):
            if not self.has(varName):
                setattr(self, varName, value)

    if hasattr(func, "staticVars"):
        return func.staticVars
    else:
        # add an attribute to func
        func.staticVars = StaticVars()
        return func.staticVars

Как использовать:

def myfunc(arg):
    if Static().has('test1'):
        Static().test += 1
    else:
        Static().test = 1
    print(Static().test)

    # declare() only takes effect in the first time for each static variable.
    Static().declare('test2', 1)
    print(Static().test2)
    Static().test2 += 1