# How to use Python staticmethod()

Static methods can be invoked directly **via the class name** without needing to instantiate the class. This characteristic of Python’s `staticmethod` facilitates a distinct separation of class logic from instance data.

## What is Python’s `staticmethod` used for?

Python `staticmethod` is both a function and a decorator. It is used to designate methods that operate independently of class instances. Decorators in Python are functions that modify the behaviour of other methods by adding supplementary functionality before or after their execution, without altering the original function code. Unlike instance methods, static functions **don’t require an implicit parameter** such as `self`.

The use of `staticmethod` in Python offers a focused approach to structuring functions within classes that don’t require access to instance data. Since they aren’t bound to an instance, they cannot **modify the state of an object**. Within classes, they serve as valuable tools for executing common tasks or offering global functionality. For example, they can house utility programs, conversion routines and general helper functions that can be invoked without instance data.

## What is the syntax of Python’s `staticmethod`?

There are two ways to create static methods in Python. You can use the `staticmethod()` function or the `@staticmethod` decorator.

### `staticmethod()`

`staticmethod()` is a built-in Python function that makes a method of a class **static**. The return value of Python `staticmethod()` is a static method for the function that is passed as an argument. The syntax is:

```python
class Class:
    def staticmethodFunc(x,y):
        return x + y
Class.staticmethodFunc = staticmethod(Class.staticmethodFunc)
print('Sum = ', Class.staticmethodFunc(5,7)) # Output: Sum = 12
```

By passing the `staticmethodFunc()` function defined in the `Class` class **as an argument** to `staticmethod()`, we can now call the custom method directly via the class name.

### `@staticmethod`

The `@staticmethod` decorator is a shorter and more common method to mark a function as static. The decorator is placed above the method **in the class definition**. The syntax is:

```python
class Class:
    @staticmethod
    def staticmethodFunc(x, y):
        return x + y
print('Sum = ', Class.staticmethodFunc(5,7)) # Output: Sum = 12
```

The `@staticmethod` decorator signals to the **interpreter** that the defined function should be treated as a static method.

## Python `staticmethod` code examples

You can use static methods for a variety of tasks. Below are a few practical examples of how to use static methods.

### Converting units

Python `staticmethod` is very useful for converting units.

```python
class Converter:
    @staticmethod
    def hoursToMinutes(hours):
        return hours * 60
    @staticmethod
    def minutesToHours(minutes):
        return minutes / 60
hours = 3
converted_minutes = Converter.hoursToMinutes(hours)
print(f"{hours} hours are {converted_minutes} minutes.") # Output: 3 hours are 180 minutes.
minutes = 180
converted_hours = Converter.minutesToHours(minutes)
print(f"{minutes} minutes are {converted_hours} hours.") # Output: 180 minutes are 3 hours.
```

In this example, the class `Converter` has two static methods to convert between hours and minutes. The method `hoursToMinutes()` converts hours into minutes, while `minutesToHours()` converts minutes into hours.

We can call the static methods via the class name without having to create an instance of the class. They are accessed via `Converter.hoursToMinutes()` or `Converter.minutesToHours()`, where `Converter` is the class name. We output the result in an **f-string**, a Python string format that links expressions.

### Auxiliary functions for math calculations

You can also use Python’s staticmethod() to define auxiliary functions for secondary calculations.

```python
class Calculator:
    @staticmethod
    def square(x):
        return x * x
    @staticmethod
    def sqroot(x):
        return x ** 0.5
num = 9
square = Calculator.square(num)
print(f"The square of {num} is {square}.") # Output: The square of 9 is 81.
root = Calculator.sqroot(num)
print(f"The square root of {num} is {root}.") # Output: The square root of 9 is 3.
```

The code example demonstrates the `Calculator` class with static methods for calculating the square and square root of a number. We use the `@staticmethod` decorator to mark `square()` and `sqroot()` as static methods. Without creating an instance of the class, we call the methods via the class name. We concatenate the results of `Calculator.square()` and `Calculator.sqroot()` in an f-string.

### Validation of entries

Another use of Python’s staticmethod is the validation of inputs.

```python
class Validator:
    @staticmethod
    def isInteger(num):
        try:
            int(num)
            return True
        except ValueError:
            return False
    @staticmethod
    def isDecimal(num):
        try:
            float(num)
            return True
        except ValueError:
            return False
input = "123"
is_integer = Validator.isInteger(input)
print(f"Is '{input}' an integer? {is_integer}") # Output: Is '123' an integer? True
input = "3.14"
is_dec = Validator.isDecimal(input)
print(f"Is '{input}' a decimal number? {is_dec}") # Output: Is '3.14' a decimal number? True
```

The `Validator` class comprises the two static methods: `isInteger()` and `isDecimal()`. These functions check whether a given input is an integer or a decimal number. The Python staticmethod `isInteger()` takes an input and tries to convert it into an integer `(int(num))`. If successful, `True` is returned. Otherwise, we get `False` if an **Exception `ValueError` is caught**, which happens when validation isn’t possible.

We use the `isDecimal()` method to convert the input into a decimal number `(float(num))`. If successful, `True` is returned, otherwise `False`. We then use the `isInteger()` and `isDecimal()` static methods of the `Validator` class to check the inputs `"123"` and `"3.14"`. The results are true for both functions.

### Manipulation of strings

In the example below, we define the class `StringManipulation` with the static method `reverseText()`. This takes a text as a parameter and uses the slicing syntax `[::-1]` to reverse the text `"Hello World!"` and return the result.

```python
class StringManipulation:
    @staticmethod
    def reverseText(text):
        return text[::-1]
input_text = "Hello World!"
result = StringManipulation.reverseText(input_text)
print(f"Reversed text of '{input_text}': {result}") # Output: Reversed text of 'Hello World!': !dlroW olleH
```


This is a markdown version of: [https://www.ionos.com/en-ie/digitalguide/websites/web-development/python-staticmethod/](https://www.ionos.com/en-ie/digitalguide/websites/web-development/python-staticmethod/) for AI/LLM consumption.