(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

Is this pythonic? Well, it's definitely more pythonic than having global variables for a counter and the value of the most recent instance.

It's said in Python that there's only one right way to do anything. I can't think of a better way to implement this, so keep going. Despite the fact that many will criticize you for "non-pythonic" solutions to problems (like the needless object-orientation that Java coders like or the "do-it-yourself" attitude that many from C and C++ bring), in most cases your Java habits will not send you to Python hell.

And beyond that, who cares if it's "pythonic"? It works, and it's not a performance issue, is it?

Answer 2

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 3

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.

Answer 4

You don't have to use a class variable here; this is a perfectly valid case for using globals:

_counter = 0
_last_value = None
class Myclass(obj):
    def __init__(self, name):
        self.name = name

        global _counter, _last_value
        _counter += 1
        _last_value = name

I have a feeling some people will knee-jerk against globals out of habit, so a quick review may be in order of what's wrong--and not wrong--with globals.

Globals traditionally are variables which are visible and changeable, unscoped, from anywhere in the program. This is a problem with globals in languages like C. It's completely irrelevant to Python; these "globals" are scoped to the module. The class name "Myclass" is equally global; both names are scoped identically, in the module they're contained in. Most variables--in Python equally to C++--are logically part of instances of objects or locally scoped, but this is cleared shared state across all users of the class.

I don't have any strong inclination against using class variables for this (and using a factory is completely unnecessary), but globals are how I'd generally do it.

Answer 5

You can solve this problem by splitting the code into two separate classes.

The first class will be for the object you are trying to create:

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

And the second class will create the objects and keep track of them:

class MyClassFactory(object):
    Counter = 0
    LastValue = None

    @classmethod
    def Build(cls, name):
        inst = MyClass(name)
        cls.Counter += 1
        cls.LastValue = inst.Name
        return inst   

This way, you can create new instances of the class as needed, but the information about the created classes will still be correct.

>>> x = MyClassFactory.Build("Hello")
>>> MyClassFactory.Counter
1
>>> MyClassFactory.LastValue
'Hello'
>>> y = MyClassFactory.Build("Goodbye")
>>> MyClassFactory.Counter
2
>>> MyClassFactory.LastValue
'Goodbye'
>>> x.Name
'Hello'
>>> y.Name
'Goodbye'

Finally, this approach avoids the problem of instance variables hiding class variables, because MyClass instances have no knowledge of the factory that created them.

>>> x.Counter
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyClass' object has no attribute 'Counter'