Python staticmethod: Método estático em Python

Métodos estáticos podem ser diretamente chamados pelo nome da classe, sem que seja preciso criar uma instância de classe. Graças ao seu funcionamento, o Python staticmethod colabora com a organização e a compreensão de códigos, por estabelecer uma separação clara entre a lógica da classe e os dados da instância.

Para que serve o Python staticmethod?

O método estático em Python staticmethod é o decorador usado para assinalar métodos que funcionam independentemente de instâncias de classe. Na linguagem de programação Python, decoradores são funções que modificam o comportamento de outros métodos, acrescentando a eles funcionalidades complementares, seja antes ou depois da execução. Assim sendo, eles não influenciam o código da função em si. Ao contrário de métodos de instância, funções estáticas não requerem parâmetros implícitos, como self para as instâncias.

O Python staticmethod é uma opção eficiente para organizar, dentro de classes, funções que não precisam acessar dados de instância. Já que esse tipo de função não é vinculado a uma instância, ele não é capaz de modificar o estado de um objeto. Métodos estáticos em Python são ferramentas úteis para classes, pois executam tarefas gerais ou disponibilizam funcionalidades globais. Por exemplo, eles podem conter programas utilitários, rotinas de conversão ou funções auxiliares, que você poderá chamar sem ter de lidar com dados de instância.

Sintaxe do Python staticmethod

Em Python, existem duas formas de se criar métodos estáticos. Você pode utilizar tanto a função staticmethod() quanto o decorador @staticmethod.

staticmethod()

staticmethod() é uma função Python integrada, que torna estático um método de classe**. O valor de retorno do Python staticmethod() é sempre um método estático para a função fornecida como argumento. Esta é a sua sintaxe geral:

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

Se fornecermos a função staticmethodFunc(), definida na classe Class, como argumento para a função staticmethod(), nos tornamos capazes de chamar o nosso próprio método diretamente pelo nome da classe.

@staticmethod

O decorador @staticmethod é um método mais conciso, além de ser mais usado para assinalar uma função como estática. Este decorador deve ser inserido acima do método, na definição da classe. Sua sintaxe é a seguinte:

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

O decorador @staticmethod sinaliza ao interpretador que a função definida deve ser interpretada como um método estático.

Exemplos de códigos com o Python staticmethod

Você pode utilizar métodos estáticos para executar vários tipos de tarefas. Acompanhe, a seguir, alguns exemplos de códigos que elaboramos, para que você consiga visualizar melhor as aplicações do staticmethod.

Converter unidades com o Python staticmethod

O Python staticmethod é bastante útil para a conversão de unidades. Observe:

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.

Nesse exemplo, a classe Converter ganha dois métodos estáticos para fazer conversões entre horas e minutos. O método hoursToMinutes() converte horas em minutos, enquanto minutesToHours() converte minutos em horas.

Chamamos os métodos estáticos pelo nome da classe, não precisando criar uma instância de classe — o acesso é feito diretamente por Converter.hoursToMinutes() ou por Converter.minutesToHours(). Já Converter é o nome da classe. Exibimos o resultado em uma f-string, método de formatação de strings em Python que conecta expressões entre si.

Funções auxiliares para cálculos matemáticos com o Python staticmethod

Fazendo uso do método estático em Python staticmethod, você também pode definir funções auxiliares para a realização de cálculos adicionais, como mostra o código abaixo:

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.

O exemplo acima apresenta a classe Calculator com métodos estáticos para calcular o quadrado e a raiz quadrada de um número. Ao utilizarmos o decorador @staticmethod, assinalamos square() e sqroot() como métodos estáticos. Já que não temos de criar uma instância de classe, chamamos os métodos simplesmente pelo nome da classe. Por fim, concatenamos os resultados de Calculator.square() e Calculator.sqroot() em uma f-string.

Validação de entradas com Python staticmethod

O Python staticmethod também pode ser aplicado em situações de validação de entradas (inputs).

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

Observe que a classe Validator contém dois métodos estáticos: isInteger() e isDecimal(). Essas funções são responsáveis por verificar se uma entrada é um número inteiro ou um número decimal. O método estático isInteger() recebe uma entrada e tenta convertê-la em um número inteiro (int(num)). Se essa conversão funcionar, o método retornará o valor True, mas se não funcionar, receberemos o valor False, que indicará uma exceção ValueError. Ela ocorre quando uma validação não é possível.

Aplicamos o método isDecimal() para converter a entrada em um número decimal (float(num)). Em caso de sucesso, o valor de retorno será True. Caso contrário, ele será False. Em seguida, utilizando os métodos estáticos isInteger() e isDecimal() da classe Validator, verificamos as entradas "123" e "3.14". Os resultados obtidos serão verdadeiros para ambas as funções.

Manipulação de strings com Python staticmethod

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

No exemplo acima, definimos a classe StringManipulation com um método estático: reverseText(). Esse método recebe um texto como parâmetro e aplica a sintaxe de slicing [::-1] para inverter o texto "Hello World!" e retornar o resultado correspondente.