Class methods and cls usage in Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a class method in Python?

A class method is a method that is bound to the class and not the instance. It receives the class itself as the first argument, usually named <code>cls</code>, allowing it to access or modify class state.

beginner

How do you define a class method in Python?

You define a class method by decorating a method with <code>@classmethod</code> and including <code>cls</code> as the first parameter in the method definition.

intermediate

Why use <code>cls</code> instead of <code>self</code> in a class method?

<code>cls</code> refers to the class itself, allowing the method to access or modify class variables and create new instances. <code>self</code> refers to an instance of the class, used in instance methods.

intermediate

Can a class method create an instance of the class? How?

Yes, a class method can create an instance by calling <code>cls()</code> with appropriate arguments. This is useful for alternative constructors.

beginner

Example: What does this code output?<br><pre>class Dog:
    species = 'Canis'

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

print(Dog.get_species())</pre>

The output is <code>Canis</code>. The class method <code>get_species</code> accesses the class variable <code>species</code> using <code>cls.species</code>.

What is the first argument of a class method in Python?

A self

B cls

C class

D this

Class methods receive the class itself as the first argument, which is conventionally named cls.

Which decorator is used to define a class method?

A @classmethod

B @staticmethod

C @instance

D @property

The @classmethod decorator marks a method as a class method.

What can a class method access even without an instance?

A Instance variables

B Global variables

C Class variables

D Local variables

Class methods can access class variables via cls, even without an instance.

Which of these is a typical use of a class method?

A To create alternative constructors

B To modify instance attributes

C To handle user input

D To define private methods

Class methods are often used as alternative constructors to create instances in different ways.

What will this code print?

class Cat:
    count = 0

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

Cat.increment()
print(Cat.count)

A 0

B Error

C None

D 1

The class method increments the class variable count by 1, so the output is 1.

Explain what a class method is and how the cls parameter is used.

Think about how class methods relate to the class itself, not instances.

Describe a situation where using a class method is better than an instance method.

Consider when you want to create or manage objects without needing an existing object.

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