Modify Class Constant in Python

Question

In Python, I define a class:

class X():
    _CON = 0

    def __init__(self, var):
        self.y = var*self._CON 

Is it possible to change the constant _CON for an instance of X? For example, I attempt to do the following

X._CON = 3
x = X(2)
a = x.y 

I expect _CON to be changed from 0 to 3 and thus self.y = var*_CON = 2*3 = 6. What is the right way to do this short of creating a new class?

---

Edit:

I have found the answer. My second code works. However, it changes not _CON of the instance x of the class X but that of the class X itself. The following code changes _CON of the instance x not that of the class X.

x = X(2)
x._CON = 3
x.__init__(2)

Answer 1

_CON is a class level variable, not an instance level variable. If you change _CON in your class then the value of _CON will change for all instances of your class X. If the value of _CON will not be static then I'd include it as an instance level variable instead of defining it as a class variable.

Answer 2

Actually it is. When you assign to an instance attribute you mask the class attribute.

So if you do C()._CON you are referring the instance namespace while if you do C._CON you are referring the class namespace. You can assign to instance and class attribute is not touched.

c = C()
c._CON = random()

You can reach class namespace from instance by self.__class__._CON or type(self)._CON

Nothing of this was tested.

Pay attention that _CON is not globally defined at X.__init__ so you should be getting an NameError: global name _CON is not defined error at x = X(2) line.

And there is another problem, since you use _CON in __init__, changing it after instantiating it will have no effect on the y attribute because this value was already computed. In this case the better thing to do is to extend the X class and customize the _CON attribute.

class Y(X):
    _CON = 3
y = Y(2)

Answer 3

As I said in this comment, which I will expand on here, if OP wants to be able to change X._CON on the fly, even after instantiating x = X(var) and without writing a new class then one way might be to make y a property and var an instance attribute like this:

class X(object):
    _CON = 0

    def __init__(self, var):
        self.var = var

    @property
    def y(self):
        return self.var * X._CON

then ...

>>> x = X(2)
>>> x.y  # returns 0

>>> X._CON = 3
>>> x.y  # returns 6

N.B.: As others have indicated and I think the OP has already discovered, this example uses the class attribute X._CON and changes to a class attribute will affect all instances of that class. For example, executing the following after instantiating x = X(var) from above, the value of X._CON will still be 3; it will not be 0.

Please pay very careful attention to the difference between capital X the class and little x the instance in the examples below:

>>> x._CON = 23  # <-- doesn't affect x.y b/c x.y = x.var * X._CON
>>> x.y  # still returns 6 b/c X._CON = 3 still

>>> x10 = X(10)
>>> x10.y  # returns 30 b/c X._CON = 3

>>> x._CON  # returns 23
>>> x10._CON  # returns 3 since we changed X._CON to 3
>>> X._CON  # returns 3 <-- this is the **class** attribute

Therefore if you want the value of _CON to be particular to each instance then use self._CON instead of X._CON. Starting afresh ...

class X(object):
    _CON = 0

    def __init__(self, var):
        self.var = var

    @property
    def y(self):
        return self.var * self._CON  # <-- use **instance** attribute

then ...

>>> x = X(2)
>>> x.y  # returns 0

>>> x._CON = 3  # <-- use **instance** attribute
>>> x.y  # returns 6

>>> x10 = X(10)
>>> x10.y  # returns 0 b/c x10._CON = X._CON = 0

>>> x10._CON = 7  # <-- use **instance** attribute
>>> x10.y  # returns 70

>>> x._CON  # returns 3
>>> x10._CON  # returns 7
>>> X._CON  # returns 0

There are a few more variations, like what happens to the instance attributes x._CON and x10._CON in the 2nd example using self._CON if you change the class attribute X._CON either before or after setting the instance attributes x._CON or x10._CON. I'll leave those examples for the reader to explore.

Answer 4

Is it possible to get change the constant _CON for an instance of X.

Nope. If you want this, you must use an instance variable like self.con.

In your example, _CON is attached to the class X. To attach it to an instance, you must use self.

Answer 5

No, from a instance/object you can't update a class variable. Because it's by design, has to be constant for all the object. Though some tricks exists(create a class method to update the variable or as usual go with init method.)..

class MyClass:
    _CON = 1

    @classmethod
    def update(cls, value):
        cls._CON += value

    def __init__(self,value):
        self.value = value
        self.update(value)

a = MyClass(1)
print (MyClass._CON) #o/p: 2

And you must think 10 times before you you update anything that starts with a underscore(somebody is saying don't touch it...)