Class methods and cls usage in Python - Mini Project: Build & Apply

Class methods and cls usage

📖 Scenario: Imagine you are creating a simple system to track how many books have been added to a library. Each book has a title and an author. You want to keep count of all books created using a class method.

🎯 Goal: You will build a Book class that keeps track of the total number of books created using a class method and the cls keyword.

📋 What You'll Learn

Create a class called Book with attributes title and author

Add a class variable count to track the number of books

Create a class method called increment_count that increases count by 1 using cls

Use the class method inside the constructor to update the count each time a new book is created

Print the total number of books using the class variable

💡 Why This Matters

🌍 Real World

Tracking counts of objects like books, users, or orders is common in software. Class methods help manage data shared across all objects.

💼 Career

Understanding class methods and class variables is important for writing clean, organized code in many programming jobs, especially in object-oriented programming.

1

Create the Book class with attributes

Create a class called Book with an __init__ method that takes self, title, and author as parameters. Inside __init__, set self.title to title and self.author to author.

Python

class Book:
    def __init__(self, title, author):
        # Your code here

Hint

Remember to use self to set instance variables inside __init__.

2

Add a class variable and class method

Add a class variable called count to Book and set it to 0. Then create a class method called increment_count using the @classmethod decorator. It should take cls as a parameter and increase cls.count by 1.

Python

class Book:
    count = 0
    def __init__(self, title, author):
        self.title = title
        self.author = author
    
    @classmethod
    def increment_count(cls):
        # Your code here

Hint

Use @classmethod above the method and cls.count += 1 inside it.

3

Call the class method inside the constructor

Inside the __init__ method, call the class method increment_count using Book.increment_count() to update the book count whenever a new book is created.

Python

class Book:
    count = 0
    def __init__(self, title, author):
        self.title = title
        self.author = author
        # Your code here
    
    @classmethod
    def increment_count(cls):
        cls.count += 1

Hint

Call the class method inside __init__ using the class name Book.increment_count().

4

Create books and print total count

Create three Book objects with any titles and authors you like. Then print the total number of books by printing Book.count.

Python

class Book:
    count = 0
    def __init__(self, title, author):
        self.title = title
        self.author = author
        Book.increment_count()
    
    @classmethod
    def increment_count(cls):
        cls.count += 1

# Your code here

Hint

Create three books and print Book.count to see the total.

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