Python Static Method

  • Python static method belongs to the Class.
  • They are used to create utility methods for the class.
  • The static method is called from the Class reference.
  • They can’t change the state of the object since they belong to the class.
  • In fact, a static method doesn’t have access to the class attributes.
  • The static method is like a function in a Python script but inside the class body.
  • We can call a static method from either the class reference or the object reference. If foo() is the static method in Class Utils, we can call it as as well as Utils().foo().

Why do we need Python static methods?

The static methods provide a way to divide the utility methods into separate sub-modules.

Let’s say we have a Python module for utility methods for string, list, and tuple.

We can create static methods in the separate classes for better understanding and ease of use.

class ListUtils:

    def reverse(l):

    def clear(l):

class StringUtils:

    def reverse(l):

    def upper(l):

class TupleUtils:

    def reverse(t):

    def shuffle(t):

If we have to reverse a List, we will call ListUtils.reverse() method. If we have to shuffle the tuple elements, we will call TupleUtils.shuffle() static method.

How to Create a Static Method in Python

Python provides two ways to create a static method.

  1. staticmethod() method
  2. @staticmethod function decorator

1. Using staticmethod() function

The staticmethod() is useful when you want to create a static method defined in the class. Note that the method shouldn’t have the self argument.

class StringUtils:

    def to_uppercase(s):
        return str(s).upper()

StringUtils.upper = staticmethod(StringUtils.to_uppercase)

print(StringUtils.upper('Python'))  # PYTHON

If we try to call the to_uppercase() method from StringUtils object, it will raise an error as “the method takes 1 positional argument but 2 were given”.

su = StringUtils()

except TypeError as te:

# Output
# to_uppercase() takes 1 positional argument but 2 were given

We can call the to_uppercase() method from the class reference though.

print(StringUtils.to_uppercase('Python'))  # PYTHON
Python Static Method
Python Static Method

2. Using @staticmethod annotation

This is the recommended way to create a static method. We just need to annotate the method with the @staticmethod decorator.

class MathUtils:

    def multiply(a, b):
        return a * b

print(MathUtils.multiply(10, 5))  # 50

This way of creating static method is very simple to use, readable, and maintainable.

Python Staticmethod Decorator Annotation
Python @staticmethod Decorator

Python Static Method vs Class Method

  • Python class method can access class variables but static method can’t access class variables.
  • A class method requires the first formal parameter to bind to the class. A static method can be present without any parameters.
  • We use @classmethod to create class methods. We use @staticmethod to create static methods.
class Test:
    x = 10

    def foo(cls):

    def bar():
        # Unresolved reference error for class variable x
        # print(x)

Python Static Method vs Instance Method

  • The instance method in the class can access instance variables as well as class variables. The static method can’t access class variables or instance variables.
  • We require the “self variable” as the formal parameter for the instance method. There is no such restriction with the static method.
  • We use @staticmethod decorator to create a static method. We don’t need any decorators to create instance function.
class Test:
    x = 10

    def func(self):

Benefits of Static Methods in Python

The static methods are beneficial to group utility methods inside a class boundary. Otherwise, it’s just like a normal function in a python script.