What is the difference between declaring data attributes inside or outside __init__

Question

Possible Duplicate: Python: Difference between class and instance attributes I'm trying to get my head around OOP in Python and I'm a bit confused when it comes to declare variables within a class. Should I declare them inside of the `__init__` procedure or outside it? What's the difference? The following code works just fine: ``` # Declaring variables within __init__ class MyClass: def __init__(self): country = "" city = "" def information(self): print "Hi! I'm from %s, (%s)"%(self.city,self.country) me = MyClass() me.country = "Spain" me.city = "Barcelona" me.information() ``` But declaring the variables outside of the `__init__` procedure also works: ``` # Declaring variables outside of __init__ class MyClass: country = "" city = "" def information(self): print "Hi! I'm from %s, (%s)"%(self.city,self.country) me = MyClass() me.country = "Spain" me.city = "Barcelona" me.information() ```

Accepted Answer

In your first example you are defining instance attributes. In the second, class attributes.

Class attributes are shared between all instances of that class, where as instance attributes are "owned" by that particular instance.

Difference by example

To understand the differences let's use an example.

We'll define a class with instance attributes:

```
class MyClassOne:
    def __init__(self):
        self.country = "Spain"
        self.city = "Barcelona"
        self.things = []
```

And one with class attributes:

```
class MyClassTwo:
    country = "Spain"
    city = "Barcelona"
    things = []
```

And a function that prints out information about one of these objects:

```
def information(obj):
    print "I'm from {0}, ({1}). I own: {2}".format(
                obj.city, obj.country, ','.join(obj.things))
```

Let's create 2 `MyClassOne` objects and change one to be Milan, and give Milan "something":

```
foo1 = MyClassOne()
bar1 = MyClassOne()

foo1.city = "Milan"
foo1.country = "Italy"
foo1.things.append("Something")
```

When we call `information()` on the `foo1` and `bar1` we get the values you'd expect:

```
>>> information(foo1)
I'm from Milan, (Italy). I own: Something

>>> information(bar1)
I'm from Barcelona, (Spain). I own: 
```

However, if we were to do exactly the same thing, but using instances of `MyClassTwo` you'll see that the class attributes are shared between instances.

```
foo2 = MyClassTwo()
bar2 = MyClassTwo()

foo2.city = "Milan"
foo2.country = "Italy"
foo2.things.append("Something")
```

And then call `information()`...

```
>>> information(foo2)
I'm from Milan, (Italy). I own: Something
>>> information(bar2)
I'm from Barcelona, (Spain). I own: Something
```

So as you can see - `things` is being shared between the instances. `things` is a reference to a list that each instance has access to. So if you append to things from any instance that same list will be seen by all other instances.

The reason you don't see this behaviour in the string variables is because you are actually assigning a new variable to an instance. In this case that reference is "owned" by the instance and not shared at the class level. To illustrate let's assign a new list to things for `bar2`:

```
bar2.things = []
```

This results in:

```
>>> information(foo2)
I'm from Milan, (Italy). I own: Something
>>> information(bar2)
I'm from Barcelona, (Spain). I own: 
```

What is the difference between declaring data attributes inside or outside init

Solution

Problem

Related problems