What is the Python equivalent of static variables inside a function?

Question

What is the idiomatic Python equivalent of this C/C++ code?

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

specifically, how does one implement the static member at the function level, as opposed to the class level? And does placing the function into a class change anything?

Answer 1

Use a generator function to generate an iterator.

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

Then use it like

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

If you want an upper limit:

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

If the iterator terminates (like the example above), you can also loop over it directly, like

for i in foo_gen(20):
    print i

Of course, in these simple cases it's better to use xrange :)

Here is the documentation on the yield statement.

Answer 2

A bit reversed, but this should work:

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

You can create a decorator:

def static_var(varname, value):
    def decorate(func):
        setattr(func, varname, value)
        return func
    return decorate

Then use the code like this:

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

It'll still require you to use the 'foo.' prefix, unfortunately.

Answer 3

In addition to the way Claudiu demonstrated, you can also do it like this. (Though it's probably a bad idea; it's not very clear.)

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

Default values are initialized only when the function is first evaluated, not each time it is executed, so you can use a list or any other mutable object to maintain static values.

Answer 4

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

Python customarily uses underscores to indicate private variables. The only reason in C to declare the static variable inside the function is to hide it outside the function, which is not really idiomatic Python.

Answer 5

You can add attributes to a function, and use it as a static variable.

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

# attribute must be initialized
myfunc.counter = 0

Alternatively, if you don't want to setup the variable outside the function, you have to resort to getattr to avoid an AttributeNotFound exception, which is kind of ugly :

def myfunc():
  myfunc.counter += getattr(myfunc,"counter",0) # 0 is the default value

Anyway static variables are rather rare, and you should find a better place for this variable, most likely inside a class.

Answer 6

Python doesn't have static variables but you can fake it by defineing a callable object and then use it as a function.

class Foo(object):
  def __init__(self):
    self.counter = 0

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

foo = Foo()

foo() #prints 1
foo() #prints 2
foo() #prints 3