2

I'm from a C++ background and have often been using static vars to reduce the number of time variables have to be initialized (especially if the initialization takes very long). So from other posts on StackOverflow, people suggested using static class variables as follows:

class MyClass(object):

    StaticList1 = [...] # Very large list
    StaticList2 = [...] # Very large list

Now this is fine if there exists at least 1 instance of MyClass throughout the execution of the program and the lists are only created once. However, if at some stage of the execution there is no instance of MyClass, Python seems to remove the static lists (I assume because the reference counter drops to 0).

So my question, is there any easy way without using external modules to initialize StaticList1 and StaticList2 only once (the first time they are used) and never to remove them even if there is no instance of MyClass until the program exists (or you delete the lists manually)?

EDIT:

Maybe I oversimplified this issue. What I'm doing:

class MyClass(object):

    StaticList = None

    def __init__(self, info):
        if self.StaticList == None:
            print "Initializing ..."
            self.StaticList = []
            # Computationally expensive task to add elements to self.StaticList, depending on the value of parameter info

    def data(self):
        return self.StaticList

I import the module from another script and have a loop like this:

import myclass
for i in range(10000):
    m = myclass.MyClass(i)
    d = m.data()
    # Do something with d.

The initializing of the static list takes about 200 - 300 ms and is executed on every iteration of the loop, so the loop takes extremely long to finish.

Improve this question
4
  • 3
    You could take advantage of the fact that modules are singletons, so if you make these module level members they will always exist as long as the module is imported and will only exist once. Commented Apr 3, 2017 at 14:13
  • 1
    That doesnt sound right, I would not expect those lists to ever go anywhere. You are saying you are calling MyClass.StaticList1 ... and you are getting an error? What error are you getting? Commented Apr 3, 2017 at 14:13
  • * However, if at some stage of the execution there is no instance of MyClass, Python seems to remove the static lists* AFAIK, this is wrong. the class will exist independantly of the objects of that class, and all attributes defined at class level will continue to exist through the class. Can you show an example of your problem? Commented Apr 3, 2017 at 14:40
  • If every time a constructor/__init__ is called a static variable is cleared and recalculated. Then I don't see why it should be static in C++ nor Python it is just work that needs to be done on every iteration of the loop. Probably most the of work occures on the line # Computationally expensive task... and how you do that you don't show. Commented Apr 4, 2017 at 7:25

1 Answer 1

Reset to default
5

While your class does have a static field called StaticList, you are actually initializing and working with an instance field of the same name because of the self qualifier you are using. I think your code will work fine if you use MyClass.StaticList to initialize and access it instead.

In general, by Python's name lookup, you can access a class field via an instance as if it was an instance field (e.g., self.StaticList) on that instance as long as you haven't actually set an instance field of the same name on that instance. From that moment on, the instance field shadows the class field (i.e., self.StaticList will find your new value, while MyClass.StaticList will still refer to your class value).

As an example fresh from the interpreter:

>>> class A(object):
...  v=2      # static initialization
...
>>> A.v
2
>>> a=A()     # get an instance, and
>>> a.v       # get the static value via the instance:
2
>>> a.v = 7   # but now set 'v' on the instance, and ...
>>> a.v       # we will get the instance field's value:
7
>>> A.v       # the static value is still the old:
2
>>> b=A()     # and other instances of the class ...
>>> b.v       # will use the same old static value:
2

The instance variable a.v is initially equal to A.v, but by explicitly setting a.v=7, you are "dissociating" them in that instance.

While this means that, in principle, you could make use of a static class field MyClass.Values as well as an instance field xyz.Values of the same name, this is often discouraged for exactly this kind of confusion.

As a separate remark, you could consider annotating the data method as a @staticmethod (and remove the self argument in the move) and call it as MyClass.data() to make the fact clearer that you would be getting back the same list instance on every call.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

That sounds logical if it was not for this: I've been using self.StaticVar for a bunch of other classes, where the static var is initialized directly at the declaration instead of the constructor. If I then print out self.StaticVar somewhere in the class, the value of the var is printed. Hence, in that case it seems MyClass.StaticVar is the same as self.StaticVar
I have extended the logic of the answer to address this aspect. :)

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.