Pythonic Way to Initialize (Complex) Static Data Members

Question

I have a class with a complex data member that I want to keep \"static\". I want to initialize it once, using a function. How Pythonic is something like this:

de         


        

Answer 1

The statement data_member = generate_data() will be executed only once, when class coo: ... is executed. In majority of cases class statements occur at module level and are executed when module is imported. So data_member = generate_data() will be executed only once when you import module with class coo for the first time.

All instances of coo class will share data_member and can access it by writing coo.data_member. Any changes made to coo.data_member will be immediately visible by any coo instance. An instance can have its own data_member attribute. This attribute can be set by typing self.data_member = ... and will be visible only to that instance. The "static" data_member can still be accessed by typing coo.data_member.

Answer 2

You're right on all counts. data_member will be created once, and will be available to all instances of coo. If any instance modifies it, that modification will be visible to all other instances.

Here's an example that demonstrates all this, with its output shown at the end:

def generate_data():
    print "Generating"
    return [1,2,3]

class coo:
    data_member = generate_data()
    def modify(self):
        self.data_member.append(4)

    def display(self):
        print self.data_member

x = coo()
y = coo()
y.modify()
x.display()

# Output:
# Generating
# [1, 2, 3, 4]

Answer 3

As others have answered you're right -- I'll add one more thing to be aware of: If an instance modifies the object coo.data_member itself, for example

self.data_member.append('foo')

then the modification is seen by the rest of the instances. However if you do

self.data_member = new_object

then a new instance member is created which overrides the class member and is only visible to that instance, not the others. The difference is not always easy to spot, for example self.data_member += 'foo' vs. self.data_member = self.data_member + 'foo'.

To avoid this you probably should always refer to the object as coo.data_member (not through self).