Class methods and cls usage in Python - Step-by-Step Execution

Concept Flow - Class methods and cls usage

Define class with @classmethod

↓

Call class method on class or instance

↓

cls parameter receives the class

↓

Access or modify class variables via cls

↓

Return or print results

↓

End

Class methods receive the class itself as the first argument (cls), allowing access to class variables and methods without needing an instance.

Execution Sample

Python

class Dog:
    count = 0

    def __init__(self, name):
        self.name = name
        Dog.count += 1

    @classmethod
    def how_many(cls):
        return cls.count

print(Dog.how_many())
d1 = Dog('Max')
d2 = Dog('Bella')
print(Dog.how_many())

This code counts how many Dog instances are created using a class method that accesses a class variable.

Execution Table

Step	Action	cls value	Class variable count	Output
1	Call Dog.how_many()	Dog	0	0
2	Create d1 = Dog('Max')	Dog	1
3	Create d2 = Dog('Bella')	Dog	2
4	Call Dog.how_many()	Dog	2	2
5	End	-	-	-

💡 No more code to execute, program ends

Variable Tracker

Variable	Start	After 1	After 2	Final
Dog.count	0	1	2	2
d1.name	-	Max	Max	Max
d2.name	-	-	Bella	Bella

Key Moments - 3 Insights

Why does the class method use cls instead of self?

cls refers to the class itself, not an instance. This allows the method to access class variables like count, as shown in execution_table steps 1 and 4.

Can we call the class method on an instance like d1.how_many()?

Yes, but cls will still refer to the class Dog, not the instance. The method accesses class variables, so it works the same as calling Dog.how_many().

Why does Dog.count increase when creating instances?

In __init__, Dog.count is incremented each time a new Dog is created, updating the class variable tracked by the class method how_many().

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of Dog.count after creating d2?

A 1

B 2

C 0

D 3

💡 Hint

Check the 'Class variable count' column at step 3 in the execution_table.

At which step does Dog.how_many() return 0?

A Step 4

B Step 2

C Step 1

D Step 3

💡 Hint

Look at the 'Output' column in the execution_table for when how_many() is called.

If we add a third Dog instance, what will Dog.count be after creation?

A 3

B 2

C 1

D 4

💡 Hint

Refer to variable_tracker for Dog.count increments after each instance creation.

Concept Snapshot

Class methods use @classmethod decorator.
They receive cls as first parameter, the class itself.
Use cls to access or modify class variables.
Called on class or instance, cls always refers to class.
Useful for tracking data shared by all instances.

Full Transcript

This example shows how class methods work in Python. The class Dog has a class variable count that tracks how many dogs are created. The __init__ method increases count each time a new Dog instance is made. The class method how_many uses cls to access the class variable count and returns it. We call Dog.how_many() before and after creating instances to see the count change. cls always refers to the class Dog, not any instance. This lets class methods access shared data easily.

Practice

1. What does the cls keyword represent inside a class method in Python?

easy

A. A global variable

B. The class itself

C. A local variable

D. An instance of the class

Solution

1. Step 1: Understand the role of cls in class methods

   Inside a class method, cls refers to the class, not an instance.

2. Step 2: Differentiate cls from self

   self refers to an instance, while cls refers to the class itself.

3. Final Answer:

   The class itself -> Option B

4. Quick Check:

   cls = class [OK]

Hint: Remember: cls means class, self means instance [OK]

Common Mistakes:

• Confusing cls with self
• Thinking cls is a local variable
• Assuming cls is an instance

2. Which of the following is the correct way to define a class method in Python?

easy

A. def method(cls):

B. def method(self):

C. @staticmethod\ndef method():

D. @classmethod\ndef method(cls):

Solution

1. Step 1: Identify the decorator for class methods

   Class methods require the @classmethod decorator above the method.

2. Step 2: Check the method parameter

   Class methods take cls as the first parameter, not self.

3. Final Answer:

   @classmethod\ndef method(cls): -> Option D

4. Quick Check:

   Class method = @classmethod + cls parameter [OK]

Hint: Class methods always use @classmethod and cls parameter [OK]

Common Mistakes:

• Forgetting the @classmethod decorator
• Using self instead of cls
• Defining without any decorator

3. What will be the output of the following code?

class Dog:
    species = 'Canine'

    @classmethod
    def get_species(cls):
        return cls.species

print(Dog.get_species())

medium

A. 'Canine'

B. None

C. 'Dog'

D. Error

Solution

1. Step 1: Understand class attribute access via cls

   The class method get_species returns cls.species, which is 'Canine'.

2. Step 2: Check the print statement output

   Calling Dog.get_species() returns 'Canine', which is printed.

3. Final Answer:

   'Canine' -> Option A

4. Quick Check:

   cls.species = 'Canine' [OK]

Hint: Class methods access class variables via cls [OK]

Common Mistakes:

• Expecting instance name instead of class attribute
• Confusing output with class name string
• Thinking it returns None

4. Find the error in this code snippet:

class Cat:
    count = 0

    @classmethod
    def increment(cls):
        count += 1

Cat.increment()

medium

A. Using count without cls prefix inside method

B. Missing @staticmethod decorator

C. Method should have self parameter

D. Class attribute count is not defined

Solution

1. Step 1: Identify variable usage inside class method

   The method tries to increment count without cls., causing an error.

2. Step 2: Correct usage of class attribute inside class method

   It should be cls.count += 1 to modify the class attribute.

3. Final Answer:

   Using count without cls prefix inside method -> Option A

4. Quick Check:

   Use cls.count to access class variable [OK]

Hint: Always prefix class vars with cls inside class methods [OK]

Common Mistakes:

• Forgetting cls. before class variable
• Using self in class method
• Missing decorator

5. How can you use a class method to create an alternative constructor that creates an object from a string?
Example: Person.from_string('John-25') creates Person('John', 25).
Which code snippet correctly implements this?

hard

A. class Person:
def __init__(self, name, age):
self.name = name
self.age = age

@staticmethod
def from_string(data):
name, age = data.split('-')
return cls(name, int(age))

B. class Person:
def __init__(self, name, age):
self.name = name
self.age = age

def from_string(self, data):
name, age = self.split('-')
return Person(name, int(age))

C. class Person:
def __init__(self, name, age):
self.name = name
self.age = age

@classmethod
def from_string(cls, data):
name, age = data.split('-')
return cls(name, int(age))

D. class Person:
def __init__(self, name, age):
self.name = name
self.age = age

@classmethod
def from_string(self, data):
name, age = data.split('-')
return cls(name, int(age))

Solution

1. Step 1: Recognize the use of class method as alternative constructor

   The method should be decorated with @classmethod and take cls as first parameter.

2. Step 2: Parse string and return new instance

   Split the string, convert age to int, and return cls(name, int(age)) to create a new object.

3. Final Answer:

   @classmethod with cls parameter returning cls instance -> Option C

4. Quick Check:

   Alternative constructor = @classmethod + cls + return cls(...) [OK]

Hint: Use @classmethod and cls to build alternative constructors [OK]

Common Mistakes:

• Using @staticmethod instead of @classmethod
• Missing cls parameter or using self
• Not returning cls instance