Class Method and Static Method Explained with Examples

Introduction

When learning Object-Oriented Programming (OOP) in Python, you will often work with three types of methods:

• Instance Methods
• Class Methods
• Static Methods

Understanding when and why to use each one will help you write cleaner, more organized, and reusable code.

In this article, we will learn Class Methods and Static Methods with practical examples.

Why Do We Need a Class Method?

Suppose user data comes from a JSON string or a database. Without a class method, we must process the data outside the class every time before creating an object.

For example:

import json

class InefficientUser:
    def __init__(self, username, email):
        self.username = username
        self.email = email

    # This is an INSTANCE method — you have to create a user FIRST to call it,
    # even though you really want to validate the email BEFORE creating one.
    def is_valid_email(self, email):
        return "@" in email

user_json = '{"username": "ammad", "email": "[e-mail]"}'
data = json.loads(user_json)
user = InefficientUser(data["username"], data["email"])
print(f"Created user externally: {user.username}")

In the code above, we manually convert the JSON string into a dictionary every time:

data = json.loads(user_json)
user = InefficientUser(data["username"], data["email"])

If we need to create multiple objects, we will have to repeat the same code again and again. This makes the code less efficient and harder to maintain.

What is a Class Method?

A Class Method is a method that belongs to the class rather than a specific object.

It is created using the @classmethod decorator and receives cls as its first parameter.

Class methods are commonly used as factory methods or alternative constructors, allowing objects to be created in different ways.

Class Method Example

import json

class User:
    system_name = "hasabTech OOP Portal"

    def __init__(self, username, email):
        self.username = username
        self.email = email

    # 1. Instance method — takes self, has access to instance AND class data
    def display_profile(self):
        print(f"User: {self.username}, Email: {self.email}, System: {User.system_name}")

    # 2. Class method — takes cls, has access to class-level data, used as a factory
    @classmethod
    def from_json(cls, json_string):
        """Alternative constructor: create a User object directly from a JSON string."""
        data = json.loads(json_string)
        # cls is the class itself (User). Calling cls(...) creates the instance.
        return cls(username=data["username"], email=data["email"])

Understanding the Code

• system_name is a class variable.
• username and email are instance variables.
• display_profile() is an instance method.
• from_json()is a class method.
• cls refers to the class itself.
• cls(...)creates and returns a new object

Using the Class Method

# Using Class Method (Factory pattern to create object)
user_data = '{"username": "shameel", "email": "[e-mail]"}'
user1 = User.from_json(user_data) # create user1 directly!
user1.display_profile()

Output:

User: shameel, Email: [e-mail], System: hasabTech OOP Portal

Here, the JSON data is processed inside the class, making object creation much cleaner.

Why Do We Need a Static Method?

In programming, we often use utility functions (also called helper functions).

Examples include:

• Checking whether an email is valid
• Checking password length
• Verifying password complexity
• Formatting text
• Validating input data

These tasks usually do not need access to object data or class data.

If we only had instance methods, we would need to create an object before calling such functions.
Example:

dummy=InefficientUser("dummy", "[e-mail]")
print(f"is email valid? {dummy.is_valid_email('[e-mail]')}")

Creating an object just to validate an email is unnecessary.

What is a Static Method?

A Static Method is a method that belongs to the class namespace but does not have access to:

• Instance variables (self)
• Class variables (cls)

It works like a normal function placed inside a class because it is logically related to that class.

Static methods are created using the @staticmethod decorator.

Static Method Example

@staticmethod
def is_valid_email(email):
    """Utility Method: Check email validity without needing class or instance"""
    return "@" in email and email.endswith(".tech")

Understanding the Code

Notice that:

• There is no self.
• There is no cls.
• The method only uses the data passed to it.
• It acts like a utility/helper function

Calling a Static Method

#Using Static Method (No instance method)
email_ok = User.is_valid_email("[e-mail]")
print(f"Static Method Email Check: {email_ok}") 

Output:

Email Valid: True

The method is called directly from the class without creating an object.

Summary

In Python:

• Instance methods work with object-specific data and use self.
• Class methods work with class-level data and use cls.
• Static methods do not depend on either the class or the object and behave like utility functions.
• Class methods are commonly used as factory methods or alternative constructors.
• Static methods are useful for validation and helper functions that are logically related to the class.

Understanding these three method types will help you write cleaner, more professional, and maintainable Python code.

Conclusion

Class methods and static methods are important parts of Python OOP. A class method helps create objects in different ways, while a static method helps organise utility functions inside a class.

Use a Class Method when you need to create or manage objects at the class level.

Use a Static Method when you need a helper function that does not require access to instance or class data.

Watch the Complete Video Tutorial

Want to see these concepts in action?

Watch the complete YouTube tutorial where I explain Class Methods, and Static Methods with practical coding examples.

Stay connected with hasabTech for more information:
Website | Facebook | LinkedIn | YouTube | X (Twitter) | TikTok