471,354 Members | 1,521 Online
Bytes | Software Development & Data Engineering Community
Post +

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 471,354 software developers and data experts.

Unexpected behavior when initializing class

Hello everybody,

I've banged my ahead around for a while trying to figure out why
multiple instances of a class share the same instance variable. I've
stripped down my code to the following, which reproduces my problem.

class Test(object):
def __init__(self, v=[]):
self.values = v

def addValue(self, v):
self.values += [v]
return

a = Test()
a.addValue(1)
print a.values # Should print [1]
b = Test()
print b.values # Should print empty list
b.addValue(2)
print a.values # Should print [1]

The output I get is:

[1]
[1]
[1, 2]

The output I am expecting is:

[1]
[]
[1]

Another strange thing is that if I initialize with a different value,
the new instance will not share the 'values' attribute with the other
two:

c = Test([9])
print c.values # Prints [9] as it should
print a.values # Still prints [1, 2]

There is something I clearly don't understand here. Can anybody
explain? Thanks!

Python 2.4.4 (#1, Oct 23 2006, 13:58:18)
[GCC 4.1.1 20061011 (Red Hat 4.1.1-30)] on linux2

Alfred J. Fazio,
af****@smoothstone.com
Nov 28 '07 #1
7 1029
"al**********@gmail.com" <al**********@gmail.comwrites:
Hello everybody,

I've banged my ahead around for a while trying to figure out why
multiple instances of a class share the same instance variable. I've
stripped down my code to the following, which reproduces my problem.

class Test(object):
def __init__(self, v=[]):
self.values = v
You have to understand that the default value for v - an empty list -
is made at compile time - and it's the *same* list every time it's
used i.e. if you don't pass in a value for v when you make new
instances of your class.

A common paradigm to get round this - assuming you want a different
empty list each time - is something like:

def __init__(self, v = None):
self.values = v if v else []

(or maybe test explicitly for None, but you get the idea.)
Nov 28 '07 #2
On Nov 28, 3:31 am, Paul Rudin <paul.nos...@rudin.co.ukwrote:
You have to understand that the default value for v - an empty list -
is made at compile time - and it's the *same* list every time it's
used i.e. if you don't pass in a value for v when you make new
instances of your class.
*smack*!! That's me smacking myself on the forehead. I now remember
reading a long time ago that this was an FAQ! Thanks for the reply,
Paul. :)

Alfred J. Fazio,
al**********@gmail.com
Nov 28 '07 #3
al**********@gmail.com wrote:
Hello everybody,

I've banged my ahead around for a while trying to figure out why
multiple instances of a class share the same instance variable. I've
stripped down my code to the following, which reproduces my problem.
This is a *feature* of Python that bytes *ever* newbie at least once. ;-)

See
http://www.python.org/doc/faq/genera...etween-objects
class Test(object):
def __init__(self, v=[]):
self.values = v

def addValue(self, v):
self.values += [v]
return

a = Test()
a.addValue(1)
print a.values # Should print [1]
b = Test()
print b.values # Should print empty list
b.addValue(2)
print a.values # Should print [1]

The output I get is:

[1]
[1]
[1, 2]

The output I am expecting is:

[1]
[]
[1]

Another strange thing is that if I initialize with a different value,
the new instance will not share the 'values' attribute with the other
two:

c = Test([9])
print c.values # Prints [9] as it should
print a.values # Still prints [1, 2]

There is something I clearly don't understand here. Can anybody
explain? Thanks!

Python 2.4.4 (#1, Oct 23 2006, 13:58:18)
[GCC 4.1.1 20061011 (Red Hat 4.1.1-30)] on linux2

Alfred J. Fazio,
af****@smoothstone.com
Nov 28 '07 #4
On Nov 28, 7:19 pm, "alfred.fa...@gmail.com" <alfred.fa...@gmail.com>
wrote:
Hello everybody,

I've banged my ahead around for a while trying to figure out why
multiple instances of a class share the same instance variable. I've
stripped down my code to the following, which reproduces my problem.

class Test(object):
def __init__(self, v=[]):
self.values = v

def addValue(self, v):
self.values += [v]
return

a = Test()
a.addValue(1)
print a.values # Should print [1]
b = Test()
print b.values # Should print empty list
b.addValue(2)
print a.values # Should print [1]

The output I get is:

[1]
[1]
[1, 2]

The output I am expecting is:

[1]
[]
[1]

Another strange thing is that if I initialize with a different value,
the new instance will not share the 'values' attribute with the other
two:

c = Test([9])
print c.values # Prints [9] as it should
print a.values # Still prints [1, 2]

There is something I clearly don't understand here. Can anybody
explain? Thanks!
http://www.python.org/doc/faq/genera...etween-objects

http://docs.python.org/tut/node6.htm...00000000000000
Nov 28 '07 #5
Paul Rudin <pa*********@rudin.co.ukwrote:
You have to understand that the default value for v - an empty list -
is made at compile time
Not at compile time: the default value is created at runtime when the def
statement is executed.

Nov 28 '07 #6
Mel
Paul Rudin wrote:
"al**********@gmail.com" <al**********@gmail.comwrites:
A common paradigm to get round this - assuming you want a different
empty list each time - is something like:

def __init__(self, v = None):
self.values = v if v else []

(or maybe test explicitly for None, but you get the idea.)
Do test explicitly for None. Otherwise, if you do

a = []
x = ThatClass (a)
it will so happen that x.values will be an empty list, but it won't be
the same list as a.

Mel.
Nov 28 '07 #7
On Nov 28, 3:04 pm, Mel <mwil...@the-wire.comwrote:
Paul Rudin wrote:
"alfred.fa...@gmail.com" <alfred.fa...@gmail.comwrites:
A common paradigm to get round this - assuming you want a different
empty list each time - is something like:
def __init__(self, v = None):
self.values = v if v else []
(or maybe test explicitly for None, but you get the idea.)

Do test explicitly for None. Otherwise, if you do

a = []
x = ThatClass (a)

it will so happen that x.values will be an empty list, but it won't be
the same list as a.

Mel.
Yes. Another much safer possibility is to make a copy of the initial
v:

def __init__(self, values=[]):
self.values = list(values)

As a nice side effect, the object can be initialised with any
iterable.

--
Arnaud

Nov 28 '07 #8

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

9 posts views Thread by Xiangliang Meng | last post: by
2 posts views Thread by Attila Feher | last post: by
16 posts views Thread by He Shiming | last post: by
4 posts views Thread by Generic Usenet Account | last post: by
6 posts views Thread by Samuel M. Smith | last post: by
11 posts views Thread by hogtiedtoawaterbuffalo | last post: by
2 posts views Thread by Dimitri Furman | last post: by
5 posts views Thread by anne.nospam01 | last post: by

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.