Instead of bar use self.bar or Foo.bar. Assigning to Foo.bar will create a static variable, and assigning to self.bar will create an instance variable.

There are two ways to access it

first: self.__class__.PAD_token

second: self.PAD_token

If you just need to access class variables, the first one is recommended

Class body in python is an executable context, not like Java that only contains declaration. What this ultimately means is that sequence of execution is important within a class definition.

To quote the documentation:

class definition is an executable statement.

...

The class’s suite is then executed in a new execution frame (see Naming and binding), using a newly created local namespace and the original global namespace. (Usually, the suite contains mostly function definitions.) When the class’s suite finishes execution, its execution frame is discarded but its local namespace is saved. [4] A class object is then created using the inheritance list for the base classes and the saved local namespace for the attribute dictionary. The class name is bound to this class object in the original local namespace.

Some more lengthier explanations.

If you want to call a function to define a class variable, you can do it with one of these ways:

1. use staticmethod:

   class MyClass:
       def _run_instance_method():
           return "ran instance method"
       run_instance_method = staticmethod(_run_instance_method)
   
       class_var_1 = "a"
       class_var_2 = _run_instance_method() # or run_instance_method.__func__()
   

2. or define it as a standalone function:

   def run_method():
       return "ran method"
   
   class MyClass:
       class_var_1 = "a"
       class_var_2 = run_method()
   
       # optional
       run_method = staticmethod(run_method)
   

3. or access the original function with __func__ and provide a dummy cls value:

   class MyClass:
       @classmethod
       def run_class_method(cls):
           return "ran class method"
   
       class_var_1 = "a"
       class_var_2 = run_class_method.__func__(object())
   

4. or set the class variables after class creation:

   class MyClass:
       @classmethod
       def run_class_method(cls):
           return "ran class method"
   
       class_var_1 = "a"
   
   MyClass.class_var_2 = MyClass.run_class_method()
   

class Example(object):
    def __init__(self, nr1, nr2):
        self.a = nr1
        self.b = nr2

    def Add(self):
        c = self.a + self.b
        return c

Suppose if we create a instance x=Example().

If we try to accces c using x.c . We would get following error

AttributeError: 'Example' object has no attribute 'c'.

This is because of the way Python resolves names with the .. When you write self.list the Python runtime tries to resolve the list name first by looking for it in the instance object, and if it is not found there, then in the class instance.

Let's look into it step by step

self.list.append(1)

1. Is there a list name into the object self?
   • Yes: Use it! Finish.
   • No: Go to 2.
2. Is there a list name into the class instance of object self?
   • Yes: Use it! Finish
   • No: Error!

But when you bind a name things are different:

self.list = []

1. Is there a list name into the object self?
   • Yes: Overwrite it!
   • No: Bind it!

So, that is always an instance variable.

Your first example creates a list into the class instance, as this is the active scope at the time (no self anywhere). But your second example creates a list explicitly in the scope of self.

More interesting would be the example:

class testClass():
    list = ['foo']
    def __init__(self):
        self.list = []
        self.list.append('thing')

x = testClass()
print x.list
print testClass.list
del x.list
print x.list

That will print:

['thing']
['foo']
['foo']

The moment you delete the instance name the class name is visible through the self reference.

Neither way is necessarily correct or incorrect, they are just two different kinds of class elements:

• Elements outside the __init__ method are static elements; they belong to the class.
• Elements inside the __init__ method are elements of the object (self); they don't belong to the class.

You'll see it more clearly with some code:

class MyClass:
    static_elem = 123

    def __init__(self):
        self.object_elem = 456

c1 = MyClass()
c2 = MyClass()

# Initial values of both elements
>>> print c1.static_elem, c1.object_elem 
123 456
>>> print c2.static_elem, c2.object_elem
123 456

# Nothing new so far ...

# Let's try changing the static element
MyClass.static_elem = 999

>>> print c1.static_elem, c1.object_elem
999 456
>>> print c2.static_elem, c2.object_elem
999 456

# Now, let's try changing the object element
c1.object_elem = 888

>>> print c1.static_elem, c1.object_elem
999 888
>>> print c2.static_elem, c2.object_elem
999 456

As you can see, when we changed the class element, it changed for both objects. But, when we changed the object element, the other object remained unchanged.