Is this Python "static variable" hack ok to use?

Question

An oft-asked question is whether there is an equivalent to static variables inside functions in Python. There are many answers, such as creating wrapper classes, using nested functions, decorators, etc.

One of the most elegant solutions I found was this, which I have slightly modified:

def foo():
    # see if foo.counter already exists
    try: test = foo.counter
    # if not, initialize it to whatever
    except AttributeError: foo.counter = 0

    # do stuff with foo.counter
    .....
    .....

Example:

static.py

def foo(x):
    # see if foo.counter already exists
    try: test = foo.counter
    # if not, initialize it to whatever
    except AttributeError: foo.counter = 0

    foo.counter += x

    print(foo.counter)

for i in range(10):
    foo(i)

output

$ python static.py
0
1
3
6
10
15
21
28
36
45

Is there any reason I should avoid this method? How the heck does it work, anyway?

Answer 1

How does this work?

It works because the function's name is just another entry in the local scope, and the function is an object like everything else in Python, and can have arbitrary attributes set on it:

def foo():
    # The foo function object has already been fully constructed
    # by the time we get into our `try`
    try: test = foo.counter  # Only run when foo is invoked
    except AttributeError: foo.counter = 0

    foo.counter += 1

if hasattr(foo, 'counter'):
    print('Foo has a counter attribute')
else:
    # This prints out - we've parsed `foo` but not executed it yet
    print('Foo.counter does not exist yet')

# Now, we invoke foo
foo()

if hasattr(foo, 'counter'):
    # And from now on (until we remove the attribute)
    # this test will always succeed because we've added the counter
    # attribute to the function foo.
    print('Foo has a counter attribute')
else:
    print('Foo.counter does not exist yet')  # No longer true

Answer 2

In python, you would probably be much better served by using generator functions.

1. It enables multiple simultaneous scopes (each generator instance can have it's own instance of foo.counter).
2. The "static" variables are properly encapsulated within the scope of the function (foo.counter is actually in the outer scope (file-level scope)).

Here's an example of using two simultaneous generators, each with their own version of the counter variable (not possible with "static" variables).

def foo():
    counter = 0
    while True:
        # You can yield None here if you don't want any value.
        yield counter
        counter += 1

gen1 = foo()
gen2 = foo()
gen1.next()
# 0
gen1.next()
# 1
gen2.next()
# 0

You can provide some initial values to the generator and also send data back into the generators as well.

def foo(x=0)
    counter = x
    val = 1
    while True:
        sent = (yield counter)
        if sent is None:
            counter += val
            val = 1
        else:
            val = sent

gen1 = foo(3)
gen1.next()
# 3
gen1.send(3)
gen1.next()
# 6
gen1.next()
# 7

You can do much more than simply iterate a counter. Generators are a powerful tool in python and are much more flexible that simple "static" variables.

Answer 3

I feel like an object is exactly what you're looking for here. It's a bit of state attached to some actions (in this case one action) that use and manipulate that state. So why not:

class Foo(object):
    def __init__(self, start=0):
        self.counter = start
    def foo(self, x):
        self.counter += x
        print(self.counter)
foo = Foo()
for i in range(10):
    foo.foo(i)

As others have stated, if you really really want to avoid a class you can. A function is already an object and can have any attribute added to it, just like any ordinary object. But why would you really want that? I understand that writing a class for a single function feels a bit like overkill, but you have stated that your actual code has various operations that ensue. Without seeing the various operations and such, it does seem like you have a reasonable case for using a class here.

Answer 4

Why not this:

def foo(x):
    foo.counter += x
    print(foo.counter)

foo.counter = 0 # init on module import

And then:

for i in range(10):
    foo(i)

I get the same output with py2.7, py3.4.

Answer 5

You might run into some issues was the test will look outside the function scope for a foo.counter if it doesn't find one in the function. Eg the following returns 101 instead of 1

class Bar():
    counter = 100


class Hoo():
    def foo(x):
    # see if foo.counter already exists
        try: test = foo.counter
    # if not, initialize it to whatever
        except AttributeError: foo.counter = 0
        foo.counter += x
        print(foo.counter)
# make an object called foo that has an attribute counter    
foo = Bar()
# call the static foo function    
Hoo.foo(1)

Answer 6

The solution you have works fine, but if you're after the most elegant solution you may prefer this (adapted from one of the answers you linked to):

def foo(x):
    foo.counter = getattr(foo, 'counter', 0) + x
    print(foo.counter)

for i in range(10):
    foo(i)

It works essentially the same, but getattr returns a default value (of 0) that only applies if foo doesn't have the counter attribute.