Python sta­tic­method: Método estático em Python

Métodos estáticos podem ser di­re­ta­mente chamados pelo nome da classe, sem que seja preciso criar uma instância de classe. Graças ao seu fun­ci­o­na­mento, o Python staticmethod colabora com a or­ga­ni­za­ção e a com­pre­en­são de códigos, por es­ta­be­le­cer uma separação clara entre a lógica da classe e os dados da instância.

Para que serve o Python sta­tic­method?

O método estático em Python staticmethod é o decorador usado para assinalar métodos que funcionam in­de­pen­den­te­mente de ins­tân­cias de classe. Na linguagem de pro­gra­ma­ção Python, de­co­ra­do­res são funções que modificam o com­por­ta­mento de outros métodos, acres­cen­tando a eles fun­ci­o­na­li­da­des com­ple­men­ta­res, seja antes ou depois da execução. Assim sendo, eles não in­flu­en­ciam o código da função em si. Ao contrário de métodos de instância, funções estáticas não requerem pa­râ­me­tros im­plí­ci­tos, como self para as ins­tân­cias.

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 fer­ra­men­tas úteis para classes, pois executam tarefas gerais ou dis­po­ni­bi­li­zam fun­ci­o­na­li­da­des globais. Por exemplo, eles podem conter programas uti­li­tá­rios, rotinas de conversão ou funções au­xi­li­a­res, que você poderá chamar sem ter de lidar com dados de instância.

Sintaxe do Python sta­tic­method

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 for­ne­cer­mos 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 di­re­ta­mente 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 in­ter­pre­ta­dor que a função definida deve ser in­ter­pre­tada como um método estático.

Exemplos de códigos com o Python sta­tic­method

Você pode utilizar métodos estáticos para executar vários tipos de tarefas. Acompanhe, a seguir, alguns exemplos de códigos que ela­bo­ra­mos, para que você consiga vi­su­a­li­zar melhor as apli­ca­ções do staticmethod.

Converter unidades com o Python sta­tic­method

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 con­ver­sõ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 pre­ci­sando criar uma instância de classe — o acesso é feito di­re­ta­mente por Converter.hoursToMinutes() ou por Converter.minutesToHours(). Já Converter é o nome da classe. Exibimos o resultado em uma f-string, método de for­ma­ta­ção de strings em Python que conecta ex­pres­sões entre si.

Funções au­xi­li­a­res para cálculos ma­te­má­ti­cos com o Python sta­tic­method

Fazendo uso do método estático em Python staticmethod, você também pode definir funções au­xi­li­a­res para a re­a­li­za­ção de cálculos adi­ci­o­nais, 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 uti­li­zar­mos o decorador @staticmethod, as­si­na­la­mos square() e sqroot() como métodos estáticos. Já que não temos de criar uma instância de classe, chamamos os métodos sim­ples­mente pelo nome da classe. Por fim, con­ca­te­na­mos os re­sul­ta­dos de Calculator.square() e Calculator.sqroot() em uma f-string.

Validação de entradas com Python sta­tic­method

O Python sta­tic­method 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 res­pon­sá­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, re­ce­be­re­mos 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, uti­li­zando os métodos estáticos isInteger() e isDecimal() da classe Validator, ve­ri­fi­ca­mos as entradas "123" e "3.14". Os re­sul­ta­dos obtidos serão ver­da­dei­ros para ambas as funções.

Ma­ni­pu­la­ção de strings com Python sta­tic­method

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 cor­res­pon­dente.