[EMAIL PROTECTED] a écrit : > Hi. > > I've got a question on the differences and how to define static and > class variables.
What's a "static" variable ? A variable that doesn't move ?-) > Hence, my understanding is that static variables must be bound to the > class defining the variables You mean "class attributes". Thinking in terms of another language won't help understanding Python's objec model. > and shared by children of parent class > where the variable is defined. But, please have a look at this code in > which a guy told me that the variable a is static: Then don't listen what this guy says. >>>>class Foo: > > a = 1 > @classmethod > def increment(cls): > cls.a += 1 > print cls.a > > Here, I am defining variable a which, I believe is class variable, a class attribute > i.e., variable that is not bound to Foo itself. Yes it is. It's an attribute of the class object Foo. > Rather, a is bound to > the class which is accessing the variable. False. >>> dir(Foo) ['__doc__', '__module__', 'a', 'increment'] >>> Foo.__dict__ {'a': 1, '__module__': '__main__', '__doc__': None, 'increment': <classmethod object at 0x402d141c>} > The code that corroborates > this idea is as follows: > >>>>class Child1(Foo): > pass > >>>>Child1.increment() > 4 ??? > >>>>class Child2(Foo): > pass > >>>>Child2.increment() > 4 I don't have the same result here. But anyway: the increment method is rebinding 'a', so the first time it's called on a child class, it creates an attribute 'a' for this class. Just change your code this way and you'll see what happens: def increment(cls): print dir(cls) cls.a += 1 print dir(cls) FWIW, if you don't get this, then you may encounter another common gotcha: class Truc: a = 1 def gotcha(self): self.a += 1 print self.a print Truc.a t = Truc() print t.a t.gotcha() print Truc.a t2 = Truc() print t2.a t2.gotcha() print Truc.a t.gotcha() print t.a print t2.a print Truc.a Enjoy !-) Now back to your snippet : if you don't want this behaviour, wrap 'a' into a mutable container: class Foo: a = [1] @classmethod def increment(cls): cls.a[0] += 1 print cls.a[0] class Child(Foo): pass And if you want to hide that, use properties (warning: you need nex style classes here): class Foo(object): _a = [1] @classmethod def increment(cls): cls._a[0] += 1 print cls._a[0] @apply def a(): def fget(self): return type(self)._a[0] def fset(self, val): type(self)._a[0] = val return property(**locals()) class Child(Foo): pass > This means that Child1 and Child2 does not share variable a which > means that variable a is class variable rather than static variable. Nope. This only means that you don't understand the (somewhat peculiar) semantics of bindings, immutable objects and attribute lookup rules in Python. > Could you please comment on this? Is a static or class variable? It's a class attribute. > What's the most recent way of defining 'class' and 'static' variables? No 'static variable' in Python. And what you call a 'class variable' is nothing else than an ordinary of the class object -- http://mail.python.org/mailman/listinfo/python-list