In Python how can I access "static" class variables within class methods

Question

If I have the following python code:

class Foo(object):
    bar = 1
    def bah(self):

        print bar

f = Foo()
f.bah()

It complains

NameError: global name 'bar' is not defined

How can I access class/static variable 'bar' within method 'bah'?

Answer 1

instead of bar use self.bar or Foo.bar

edit:

as mentioned in comments below, if your intention is to treat it like a static variable, then use Foo.bar

Answer 2

As with all good examples, you've simplified what you're actually trying to do. This is good, but it is worth noting that python has a lot of flexibility when it comes to class versus instance variables. The same can be said of methods. For a good list of possibilities, I recommend starting here, especially sections 2 through 6.

One thing that takes a lot of work to remember when getting started is that python is not java. More than just a cliche. In java, an entire class is compiled, making the namespace resolution real simple: any variables declared outside a method (anywhere) are instance (or, if static, class) variables and are implicitly accessible within methods.

With python, the grand rule of thumb is that there are three namespaces that are searched, in order, for variables:

1. The function/method
2. The current module
3. Builtins

{begin pedagogy}

There are limited exceptions to this. The main one that occurs to me is that, when a class definition is being loaded, the class definition is its own implicit namespace. But this lasts only as long as the module is being loaded, and is entirely bypassed when within a method. Thus:

>>> class A(object):
  foo = 'foo'
  bar = foo


>>> A.foo
'foo'
>>> A.bar
'foo'

but:

>>> class B(object):
     foo = 'foo'
     def get_foo():
      return foo
     bar = get_foo()



Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    class B(object):
  File "<pyshell#11>", line 5, in B
    bar = get_foo()
  File "<pyshell#11>", line 4, in get_foo
    return foo
NameError: global name 'foo' is not defined

{end pedagogy}

In the end, the thing to remember is that you do have access to any of the variables you want to access, but probably not implicitly. If your goals are simple and straightforward, then going for Foo.bar or self.bar will probably be sufficient. If your example is getting more complicated, or you want to do fancy things like inheritance (you can inherit static/class methods!), or the idea of referring to the name of your class within the class itself seems wrong to you, check out the intro I linked.

Answer 3

Define class method:

class Foo(object):
    bar = 1
    @classmethod
    def bah(cls):    
        print cls.bar

Now if bah() has to be instance method (i.e. have access to self), you can do following:

class Foo(object):
    bar = 1
    def bah(self):    
        print self.__class__.bar