(Usage of Class Variables) Pythonic - or nasty habit learnt from java?

Question

Hello Pythoneers: the following code is only a mock up of what I'm trying to do, but it should illustrate my question.

I would like to know if this is dirty trick I picked up from Java programming, or a valid and Pythonic way of doing things: basically I'm creating a load of instances, but I need to track 'static' data of all the instances as they are created.

class Myclass:
        counter=0
        last_value=None
        def __init__(self,name):
                self.name=name
                Myclass.counter+=1
                Myclass.last_value=name

And some output of using this simple class , showing that everything is working as I expected:

>>> x=Myclass("hello")
>>> print x.name
hello
>>> print Myclass.last_value
hello
>>> y=Myclass("goodbye")
>>> print y.name
goodbye
>>> print x.name
hello
>>> print Myclass.last_value
goodbye

So is this a generally acceptable way of doing this kind of thing, or an anti-pattern ?

[For instance, I'm not too happy that I can apparently set the counter from both within the class(good) and outside of it(bad); also not keen on having to use full namespace 'Myclass' from within the class code itself - just looks bulky; and lastly I'm initially setting values to 'None' - probably I'm aping static-typed languages by doing this?]

I'm using Python 2.6.2 and the program is single-threaded.

Answer 1

Class variables are perfectly Pythonic in my opinion.

Just watch out for one thing. An instance variable can hide a class variable:

x.counter = 5  # creates an instance variable in the object x.
print x.counter  # instance variable, prints 5
print y.counter  # class variable, prints 2
print myclass.counter # class variable, prints 2

Answer 2

Do. Not. Have. Stateful. Class. Variables.

It's a nightmare to debug, since the class object now has special features.

Stateful classes conflate two (2) unrelated responsibilities: state of object creation and the created objects. Do not conflate responsibilities because it "seems" like they belong together. In this example, the counting of created objects is the responsibility of a Factory. The objects which are created have completely unrelated responsibilities (which can't easily be deduced from the question).

Also, please use Upper Case Class Names.

class MyClass( object ):
    def __init__(self, name):
            self.name=name

def myClassFactory( iterable ):
   for i, name in enumerate( iterable ):
       yield MyClass( name )

The sequence counter is now part of the factory, where the state and counts should be maintained. In a separate factory.

[For folks playing Code Golf, this is shorter. But that's not the point. The point is that the class is no longer stateful.]

It's not clear from question how Myclass instances get created. Lacking any clue, there isn't much more than can be said about how to use the factory. An iterable is the usual culprit. Perhaps something that iterates through a list or a file or some other iterable data structure.

Also -- for folks just of the boat from Java -- the factory object is just a function. Nothing more is needed.

---

Since the example on the question is perfectly unclear, it's hard to know why (1) two unique objects are created with (2) a counter. The two unique objects are already two unique objects and a counter isn't needed.

For example, the static variables in the Myclass are never referenced anywhere. That makes it very, very hard to understand the example.

x, y = myClassFactory( [ "hello", "goodbye" ] ) 

If the count or last value where actually used for something, then a perhaps meaningful example could be created.