classmethod can change the state of a class, what does this mean?

Question

Edit: I am not asking about what are classmethod and staticmethod or difference between them. Just asking the question to clarify what does state of class mean.

I just started python. While going through tutorials on @classmethod and @staticmethod I found a statement similar to below one in multiple websites.

Mentioned in geekforgeeks

A class method can access or modify class state while a static method can’t access or modify it.

Tutorialspoint

Class method can access and modify the class state. Static Method cannot access or modify the class state.

---

What does the class state mean? Does it mean that there is a way of modifying the values of all objects at go by using class method,because when a class state change it should affect all the objects created from that class? I could find only factory method creation with @classmethods and I don't think it is some class state change.

I am an advanced C++ programmer. Some related explanation would be good , if possible.

Edit: The question which marked this as duplicate of it doesn't mention the class states. I read both that questions and its duplicate before asking this.

One example I tried:

class MyClass:
 myvar = 100
 def __init__(self,age):
  self.myvar = age
 def instMethod(self):
  print("Inst method")

 @classmethod
 def classMethod(cls,age):
  cls.myvar = age

obj1 = MyClass(10)
obj2 = MyClass(20)
obj3 = MyClass(30)

print(obj1.myvar)
print(obj2.myvar)
print(obj3.myvar)

print("after class method")
MyClass.classMethod(45)

print(obj1.myvar)
print(obj2.myvar)
print(obj3.myvar)

output:

10

20

30

after class method

10

20

30

But my expectation was

10

20

30

after class method

45

45

45

Answer 1

Both of the explanations you have quoted are wrong. It is quite possible for a static method to modify the class's state:

class A:
    x = 1

    @staticmethod
    def change_static():
        A.x = 2

    @classmethod
    def change_class(cls):
        cls.x = 3

Proof:

>>> A.x
1
>>> A.change_static()
>>> A.x
2
>>> A.change_class()
>>> A.x
3

The correct statement is that a class method takes an argument for the class it is called on, named cls in this example. This allows the class method to access the class it is called on (which may in general be a subclass of A), much like an instance method takes an argument usually named self in order to access the instance it is called on.

A static method takes no such argument, but can still access the class by name.

---

For the second half of your question, you need to understand how accessing an attribute on an instance works:

• If the instance has its own attribute of that name, then you will get the value of the instance's own attribute.
• Otherwise, if the instance's class has its own attribute of that name, then you'll get that value instead.
• Otherwise, you'll get the attribute belonging to the nearest superclass that has one of that name.
• Otherwise, an AttributeError is raised.

Note that this applies only to getting the value of an attribute; if you set a.x = 23 then you will always be setting the attribute belonging to a itself, even if it didn't have such an attribute before. For example:

>>> a = A()
>>> a.x
3              # a has no x attribute, so this gets the value from the class
>>> A.x = 4
>>> a.x
4              # gets the updated value from the class
>>> a.x = 5
>>> A.x = 6
>>> a.x
5              # a has its own x attribute now, so this doesn't go to the class

In your code, the __init__ method sets the self.myvar attribute, so every instance has this attribute. Therefore, a lookup like obj1.myvar will never fall back to the class's attribute.

Answer 2

Class state would include things like class attributes:

class A:
    x = 3

    @classmethod
    def change_x(cls, new_x):
       cls.x = new_x

Then

>>> A.x
3
>>> A.change_x(9)
>>> A.x
9

The distinction between a class method and a static method is that a class method is automatically provided with an instance of the class that invokes it, as its first argument; a static method is not.

Answer 3

In C++ terms, a static method is not bound by the object nor the object instance. A static method will not be able to access instance bound nor object / class bound variables.

A class method is very similar to a static method, in the sense that you can call a class method the same way you would call a static method: by the class rather than the instance of that class.

The major difference is that, the class method is bound by the object / class, and thus can access class state variables.

Answer 4

Here's an example, where calling a class method alters the class attribute, so that it is different for a new instance of the class:

class Foo:
    i = 1

    @classmethod
    def increase(cls):
        cls.i += 1


instance1 = Foo()
print(instance1.i)
>>> 1

instance1.increase()
instance2 = Foo()
print(instance2.i)
>>> 2