Python staticmethod() Function

Spread the love

The staticmethod() function in Python is used to create a static method from a given function.


The staticmethod() function can be used in two ways: as a decorator or as a regular function call.

As a decorator:

class ClassName:
    def func(arg1, arg2, ...):
        # ...

As a function call:

class ClassName:
    def func(arg1, arg2, ...):
        # ...
    func = staticmethod(func)


The staticmethod() function takes a single parameter:

  • function: This is the function that you want to convert into a static method.

Return Value:

The staticmethod() function returns a static method for the given function.

Introduction to Python’s Methods

Python supports three types of methods within a class:

  1. Instance Methods: Require an instance of the class (accessed through self) and can modify the object and its attributes.
  2. Class Methods: Affect the class as a whole, taking a class parameter (cls) that points to the class and not the object instance.
  3. Static Methods: Do not take an implicit first argument and thus do not have access to the instance (self) or class (cls) but are still part of the class’s namespace.

Defining Static Methods

A static method is created using the @staticmethod decorator or by calling staticmethod() on a method. The decorator is the more pythonic and widely used approach.

Using the @staticmethod Decorator

class MathOperations:
    def add(x, y):
        return x + y

    def multiply(x, y):
        return x * y

# Call the static method add to compute the sum of two numbers
result_add = MathOperations.add(10, 15)
print("The sum is:", result_add)  # Outputs: The sum is: 25

# Call the static method multiply to compute the product of two numbers
result_multiply = MathOperations.multiply(10, 5)
print("The product is:", result_multiply)  # Outputs: The product is: 50

In this example, add and multiply do not modify a class or instance state, so they are perfect candidates for static methods.

Using staticmethod() Function

class MathOperations:
    def add(x, y):
        return x + y
    add = staticmethod(add)

    def multiply(x, y):
        return x * y
    multiply = staticmethod(multiply)

Here we achieve the same result as with the decorator, but it’s less readable and goes against the common convention.

When to Use Static Methods

Static methods shine when you have a method that logically belongs to the class but does not require the class or its instances to perform an operation.

Example 1: Utility Functions

class StringUtils:
    def is_palindrome(s):
        return s == s[::-1]

print(StringUtils.is_palindrome("radar"))  # True

Example 2: Independent Operations

class TemperatureConverter:
    def celsius_to_fahrenheit(celsius):
        return celsius * 9/5 + 32

    def fahrenheit_to_celsius(fahrenheit):
        return (fahrenheit - 32) * 5/9

print(TemperatureConverter.celsius_to_fahrenheit(0))  # 32.0
print(TemperatureConverter.fahrenheit_to_celsius(32))  # 0.0

Comparing with Other Method Types

Let’s delve into the different method types in Python and compare them. We’ll focus on instance methods, class methods, and static methods to understand their distinct behaviors and when to use each one.

Instance Methods

Instance methods are the most common method type in Python classes. They take self as the first parameter, which is a reference to the instance of the class through which the method is being invoked. This allows instance methods to access and modify the state of the instance and work with the data unique to that particular object.

Syntax and Usage of Instance Methods:

class MyClass:
    def __init__(self, value):
        self.value = value
    def instance_method(self):
        return f"Instance value: {self.value}"

To use this instance method, you must create an object of MyClass and then call the method on it:

obj = MyClass(10)
print(obj.instance_method())  # Output: Instance value: 10

Class Methods

Class methods affect the class as a whole. They are marked with the @classmethod decorator and take cls as the first parameter, which is a reference to the class itself, not an instance. Class methods can modify class state that applies across all instances of the class.

Syntax and Usage of Class Methods:

class MyClass:
    _class_value = 0
    def set_class_value(cls, new_value):
        cls._class_value = new_value
    def class_method(cls):
        return f"Class value: {cls._class_value}"

Class methods can be called on the class itself, without creating an instance:

print(MyClass.class_method())  # Output: Class value: 100

Static Methods

Static methods are marked with the @staticmethod decorator and do not take an implicit first argument; thus, they do not have access to the instance (self) or class (cls). They behave like plain functions but are included in the class’s namespace. Static methods are used for functionality that is related to the class but does not require access to the class or instance.

Syntax and Usage of Static Methods:

class MyClass:
    def static_method():
        return "This is a static method"

Static methods can be called on the class itself:

print(MyClass.static_method())  # Output: This is a static method


Now let’s compare all three types by looking at a class that utilizes each method type:

class MyClass:
    _class_value = "class value"

    def __init__(self, value):
        self.value = value

    def instance_method(self):
        return f"Instance method returns: {self.value}"

    def class_method(cls):
        return f"Class method returns: {cls._class_value}"

    def static_method():
        return "Static method does not access instance or class data"

Usage of the different methods:

# Instance method usage
obj = MyClass(10)
print(obj.instance_method())  # Outputs: Instance method returns: 10

# Class method usage
print(MyClass.class_method())  # Outputs: Class method returns: class value

# Static method usage
print(MyClass.static_method())  # Outputs: Static method does not access instance or class data

Instance Method: It’s used when you need to access or modify the object’s state.

Class Method: It’s used when you need to access or modify the class state that applies to all instances.

Static Method: It’s used when the method does not access or modify the object’s or class’s state.

Understanding when and why to use each method type is crucial for writing Python code that is both effective and clear. Each type has its role and choosing the correct one depends on the specific requirements of the task at hand.

Advanced Use Cases of staticmethod( )

let’s explore some advanced use cases of staticmethod in Python and understand the scenarios in which it can be particularly useful.

Factory Methods

One common use case for static methods is the implementation of factory methods. Factory methods are used to create objects. They can encapsulate the logic needed to create an instance of a class, potentially with complex setup steps, without needing to subclass or alter the constructor (__init__) logic.

Here’s a basic example of a factory method as a static method:

import math

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def from_polar(rho, theta):
        # Compute x and y coordinates using polar coordinates
        x = rho * math.cos(theta)
        y = rho * math.sin(theta)
        return Point(x, y)

# Using the from_polar static method to create a Point object from polar coordinates
rho = 5
theta = math.pi / 4  # 45 degrees in radians
point = Point.from_polar(rho, theta)

print(f"Point in Cartesian Coordinates: ({point.x}, {point.y})")

By using Point.from_polar(rho, theta), we are able to create a Point object directly from polar coordinates without needing to manually do the conversion outside the class. The static method encapsulates the conversion logic and returns a new instance of Point.

Alternate Constructors

Static methods can also act as alternate constructors. Python allows only one __init__ method per class, but by using static methods, you can create multiple points of entry to create instances.

import datetime

class Date:
    def __init__(self, day=0, month=0, year=0): = day
        self.month = month
        self.year = year

    def from_string(date_as_string):
        day, month, year = map(int, date_as_string.split('-'))
        return Date(day, month, year)
    def today():
        today =
        return Date(, today.month, today.year)

# Using the from_string static method
date_from_string = Date.from_string('07-11-2023')
print(f"Date from string: {}-{date_from_string.month}-{date_from_string.year}")

# Using the today static method
current_date =
print(f"Today's date: {}-{current_date.month}-{current_date.year}")

In this example, the Date class has two static methods that act as alternate constructors: from_string creates a Date object from a string, while today creates a Date object with the current date.

Encapsulating Helper Functions

Static methods are a good way to encapsulate helper functions that are related to class functionality but don’t need to interact with class or instance-specific data. This use case can be seen in methods that perform calculations or operations that are logically related to the class but operate independently of any class state.

class Parser:
    def parse_json(json_string):
            return json.loads(json_string)
        except json.JSONDecodeError:
            return None

    def parse_xml(xml_string):
        # Assume we have a similar implementation for XML parsing

In this example, the Parser class provides static methods to parse JSON and XML strings. These operations are conceptually related to the idea of a Parser but do not require any Parser instance data to work.

Use with Inheritance

Static methods defined in a parent class can be inherited by a subclass. However, they do not support overriding in the same way that instance methods do. Still, they can be useful for providing utility methods that subclasses can use or override if needed.

class Base:
    def utility_method():
        print("Base utility method")

class Sub(Base):
    def utility_method():
        print("Sub override of utility method")

Base.utility_method()  # Output: Base utility method
Sub.utility_method()  # Output: Sub override of utility method

In this case, Sub has overridden utility_method with its own version. This is less common since static methods aren’t intended for dynamic behavior, but it is possible.

Design Patterns

Certain design patterns, such as Singleton or Factory, can use static methods for implementation. The Singleton pattern can ensure that only one instance of a class is created, often using a static method to manage the instance creation and access.

class Singleton:
    _instance = None

    def get_instance():
        if Singleton._instance is None:
            Singleton._instance = Singleton()
        return Singleton._instance

# Usage:
singleton1 = Singleton.get_instance()
singleton2 = Singleton.get_instance()

print(singleton1 is singleton2)  # Output: True

The print statement print(singleton1 is singleton2) will output True, confirming that singleton1 and singleton2 are indeed references to the same instance.

This pattern is typically used when exactly one object is needed to coordinate actions across the system, such as a configuration manager or a connection pool. It’s a way to provide a global point of access to a resource while ensuring that there are no multiple instances of the class.


The staticmethod() function in Python provides a mechanism to encapsulate functions within a class without requiring an instance of the class to invoke the method. This article has detailed the function’s declaration, usage, and best practices, supplementing the exposition with ample code examples. Static methods are not without their limitations, but when used appropriately, they can lead to more maintainable, organized, and clear codebases.

Leave a Reply