# Class Method and Static Method Explained with Examples

%[https://www.youtube.com/watch?v=VsiJdLA5APQ&t=18s] 

## 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:**

```python
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": "ammad@hasabtech.com"}'
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:

```python
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**

```python
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

```python
# Using Class Method (Factory pattern to create object)
user_data = '{"username": "shameel", "email": "shameel@hasab.tech"}'
user1 = User.from_json(user_data) # create user1 directly!
user1.display_profile()
```

**Output:**

```plaintext
User: shameel, Email: shameel@hasab.tech, 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:**

```python
dummy=InefficientUser("dummy", "dummy@email.com")
print(f"is email valid? {dummy.is_valid_email('test@hasab.tech')}")
```

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

```python
@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

```python
#Using Static Method (No instance method)
email_ok = User.is_valid_email("shameel@hasab.tech")
print(f"Static Method Email Check: {email_ok}") 
```

**Output:**

```plaintext
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**](https://hasab.tech/) [**| Facebook**](https://www.facebook.com/hasabTech) [**| LinkedIn**](https://www.linkedin.com/company/hasabtech) [**| YouTube**](https://youtube.com/@hasabTech) [**| X (Twitter)**](https://x.com/hasabTech) [**| TikTok**](https://tiktok.com/@hasabTech)