Static Methods in Python – @staticmethod, Syntax & Examples

Introduction

Python provides several types of methods within classes, including instance methods, class methods, and static methods. Among these, static methods are particularly useful when you want to define functionality related to a class but that does not require access to either the instance (self) or the class (cls).

A static method behaves like a regular function. It cannot access object-specific data.

What is a Static Method in Python?

A static method is a method that belongs to a class but does not require access to:

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

Static methods are defined using the @staticmethod decorator.

Example:

class MathUtils:
    @staticmethod
    def square(num):
        return num * num

Usage:

print(MathUtils.square(5))

Output:

Explanation:

The method works without creating an object.

Syntax

Basic syntax:

class ClassName:
    @staticmethod
    def method_name(parameters):
        # code

Example:

class Calculator:
    @staticmethod
    def add(a, b):
        return a + b

Usage:

print(Calculator.add(10, 20))

Output:

Creating a Static Method

Example:

class Student:
    @staticmethod
    def school_name():
        print("ABC School")
Student.school_name()

Output:

Notice:

• No object was created.
• The method is called directly using the class name.

Static Method vs Regular Function

Regular Function:

def square(num):
    return num * num

Static Method:

class MathUtils:
    @staticmethod
    def square(num):
        return num * num

Both work similarly, but the static method is grouped inside a class for better organization.

Calling Static Methods

Static methods can be called in two ways.

Using Class Name

class Calculator:
    @staticmethod
    def multiply(a, b):
        return a * b
print(
    Calculator.multiply(5, 4)
)

Output:

Using Object

class Calculator:
    @staticmethod
    def multiply(a, b):
        return a * b
obj = Calculator()
print(obj.multiply(5, 4))

Output:

Although possible, using the class name is generally preferred.

Static Methods Cannot Access Instance Variables

Example:

class Student:
    def __init__(self, name):
        self.name = name
    @staticmethod
    def display():
        print(self.name)

Output:

Explanation:

Static methods do not have access to self.

Static Methods Cannot Access Class Variables Directly

Example:

class Student:
    school = "ABC School"
    @staticmethod
    def show_school():
        print(school)

Output:

Correct approach:

class Student:
    school = "ABC School"
    @staticmethod
    def show_school():
        print(Student.school)
Student.show_school()

Output:

Static Methods vs Instance Methods

Example:

class Student:
    def __init__(self, name):
        self.name = name
    def display(self):
        print(self.name)

Instance methods require an object.

Static Methods vs Class Methods

Example: Static Method vs Class Method

class Student:
    school = "ABC School"
    @staticmethod
    def static_method():
        print("Static Method")
    @classmethod
    def class_method(cls):
        print(cls.school)

Usage:

Student.static_method()
Student.class_method()

Output:

Real-Life Examples:

1. Utility Class

class MathUtils:
    @staticmethod
    def square(num):
        return num * num
    @staticmethod
    def cube(num):
        return num ** 3

Usage:

print(MathUtils.square(4))
print(MathUtils.cube(3))

Output:

These methods do not depend on object data.

2. Validation System

class Validator:
    @staticmethod
    def is_email(email):
        return "@" in email

Usage:

print(
    Validator.is_email(
        "user@gmail.com"
    )
)

Output:

Explanation:

Validation logic is related to the class but does not require object creation.

3. Temperature Converter

class Temperature:
    @staticmethod
    def celsius_to_fahrenheit(c):
        return (c * 9/5) + 32
    @staticmethod
    def fahrenheit_to_celsius(f):
        return (f - 32) * 5/9

Usage:

print(
    Temperature.celsius_to_fahrenheit(30)
)

Output:

4. Employee Utility

class Employee:
    @staticmethod
    def calculate_bonus(
        salary,
        percentage
    ):
        return salary * percentage / 100

Usage:

bonus = Employee.calculate_bonus(
    50000,
    10
)
print(bonus)

Output:

Advantages of Static Methods

Disadvantages of Static Methods

Common Mistakes

1. Using self Inside Static Methods

Incorrect:

@staticmethod
def display():
    print(self.name)

Correct:

def display(self):
    print(self.name)

or use an instance method.

2. Forgetting @staticmethod

Incorrect:

class Math:
    def square(num):
        return num * num

Calling:

Math.square(5)

may produce unexpected behavior.

Correct:

@staticmethod

3. Accessing Class Variables Incorrectly

Incorrect:

print(school)

Correct:

print(Student.school)

4. Using Static Methods When Instance Methods Are Needed

If a method requires object data, use an instance method instead.

Incorrect:

@staticmethod
def display():
    print(self.name)

5. Overusing Static Methods

Not every method should be static.

Use them only when no object or class data is required.

Conclusion

Static methods in Python are a useful feature for organizing utility functions within a class without requiring access to instance or class data. They are defined using the @staticmethod decorator and can be called directly using the class name, making them efficient and easy to use.

Static methods are ideal for mathematical calculations, validation logic, conversion functions, and helper utilities.

Related Python Tutorials