Categories
class python

How to avoid having class data shared among instances?

173

What I want is this behavior:

class a:
    list = []

x = a()
y = a()

x.list.append(1)
y.list.append(2)
x.list.append(3)
y.list.append(4)

print(x.list) # prints [1, 3]
print(y.list) # prints [2, 4]

Of course, what really happens when I print is:

print(x.list) # prints [1, 2, 3, 4]
print(y.list) # prints [1, 2, 3, 4]

Clearly they are sharing the data in class a. How do I get separate instances to achieve the behavior I desire?

1

  • 21

    Please, do not use list as an attribute name. list is a buil-in function to construct a new list. You should write name classes with capital letter.

    May 4, 2015 at 10:53

175

You want this:

class a:
    def __init__(self):
        self.list = []

Declaring the variables inside the class declaration makes them “class” members and not instance members. Declaring them inside the __init__ method makes sure that a new instance of the members is created alongside every new instance of the object, which is the behavior you’re looking for.

5

  • 6

    An added clarification: if you were to reassign the list property in one of the instances, it would not affect the others. So if you did something like x.list = [], you could then change it and not affect any others. The problem you face is that x.list and y.list are the same list, so when you call append on one, it affects the other.

    Nov 5, 2009 at 14:04

  • 2

    But why does this happens only for list? When i declared an integer or string outside the init, it was not shared among the objects? Can anyone share any doc link to this concept?

    – Amal Ts

    May 20, 2015 at 6:03

  • 2

    @AmalTs It looks like you don’t understand how assignment in python works. See this video or this SO post. The behaviour you see is caused by the fact that you are mutating lists but rebinding references to ints and strings.

    Jan 25, 2016 at 18:13


  • 4

    @AmalTs Note: it’s considered a bad practice to use class attributes as “lazy” default values for instance attributes. Even if the attributes are of an immutable type it’s better to assign them inside __init__.

    Jan 25, 2016 at 18:21


  • 1

    I “wow” more every day I program in Python.

    – KulaGGin

    Apr 30, 2021 at 12:37

27

The accepted answer works but a little more explanation does not hurt.

Class attributes do not become instance attributes when an instance is created. They become instance attributes when a value is assigned to them.

In the original code no value is assigned to list attribute after instantiation; so it remains a class attribute. Defining list inside __init__ works because __init__ is called after instantiation. Alternatively, this code would also produce the desired output:

>>> class a:
    list = []

>>> y = a()
>>> x = a()
>>> x.list = []
>>> y.list = []
>>> x.list.append(1)
>>> y.list.append(2)
>>> x.list.append(3)
>>> y.list.append(4)
>>> print(x.list)
[1, 3]
>>> print(y.list)
[2, 4]

However, the confusing scenario in the question will never happen to immutable objects such as numbers and strings, because their value cannot be changed without assignment. For example a code similar to the original with string attribute type works without any problem:

>>> class a:
    string = ''


>>> x = a()
>>> y = a()
>>> x.string += 'x'
>>> y.string += 'y'
>>> x.string
'x'
>>> y.string
'y'

So to summarize: class attributes become instance attributes if and only if a value is assigned to them after instantiation, being in the __init__ method or not. This is a good thing because this way you can have static attributes if you never assign a value to an attribute after instantiation.

1

  • I know this is an old answer, but… disagree with [This is a good thing because...] because it is inconsistent, is un-intuitive and an anti-pattern. Either it is a static attribute (attribute of the class ) or an instance attribute.

    – deponovo

    Nov 23, 2021 at 13:14

16

Although the accepted anwer is spot on, I would like to add a bit description.

Let’s do a small exercise

first of all define a class as follows:

class A:
    temp = 'Skyharbor'

    def __init__(self, x):
        self.x = x

    def change(self, y):
        self.temp = y

So what do we have here?

  • We have a very simple class which has an attribute temp which is a string
  • An __init__ method which sets self.x
  • A change method sets self.temp

Pretty straight forward so far yeah? Now let’s start playing around with this class. Let’s initialize this class first:

a = A('Tesseract')

Now do the following:

>>> print(a.temp)
Skyharbor
>>> print(A.temp)
Skyharbor

Well, a.temp worked as expected but how the hell did A.temp work? Well it worked because temp is a class attribute. Everything in python is an object. Here A is also an object of class type. Thus the attribute temp is an attribute held by the A class and if you change the value of temp through A (and not through an instance of a), the changed value is going to be reflected in all the instance of A class.
Let’s go ahead and do that:

>>> A.temp = 'Monuments'
>>> print(A.temp)
Monuments
>>> print(a.temp)
Monuments

Interesting isn’t it? And note that id(a.temp) and id(A.temp) are still the same.

Any Python object is automatically given a __dict__ attribute, which contains its list of attributes. Let’s investigate what this dictionary contains for our example objects:

>>> print(A.__dict__)
{
    'change': <function change at 0x7f5e26fee6e0>,
    '__module__': '__main__',
    '__init__': <function __init__ at 0x7f5e26fee668>,
    'temp': 'Monuments',
    '__doc__': None
}
>>> print(a.__dict__)
{x: 'Tesseract'}

Note that temp attribute is listed among A class’s attributes while x is listed for the instance.

So how come that we get a defined value of a.temp if it is not even listed for the instance a. Well that’s the magic of __getattribute__() method. In Python the dotted syntax automatically invokes this method so when we write a.temp, Python executes a.__getattribute__('temp'). That method performs the attribute lookup action, i.e. finds the value of the attribute by looking in different places.

The standard implementation of __getattribute__() searches first the internal dictionary (dict) of an object, then the type of the object itself. In this case a.__getattribute__('temp') executes first a.__dict__['temp'] and then a.__class__.__dict__['temp']

Okay now let’s use our change method:

>>> a.change('Intervals')
>>> print(a.temp)
Intervals
>>> print(A.temp)
Monuments

Well now that we have used self, print(a.temp) gives us a different value from print(A.temp).

Now if we compare id(a.temp) and id(A.temp), they will be different.