Tutorial sobre o método estático Python: sintaxe e uti­li­za­ção

É possível aceder aos métodos estáticos uti­li­zando di­re­ta­mente o nome da classe, sem ne­ces­si­dade de criar uma instância da classe. A função static method do Python promove, portanto, uma separação clara entre a lógica da classe e os dados da instância.

Para que serve o método estático Python?

O método estático Python é uma função e um decorador utilizado para iden­ti­fi­car métodos que operam in­de­pen­den­te­mente das ins­tân­cias da classe. Os de­co­ra­do­res em Python são funções que modificam o com­por­ta­mento de outros métodos, adi­ci­o­nando fun­ci­o­na­li­da­des antes ou depois da sua execução, sem in­flu­en­ciar o próprio código da função. Ao contrário dos métodos de instância, as funções estáticas não requerem um parâmetro implícito como self para as ins­tân­cias.

Este método do Python oferece uma maneira es­pe­cí­fica de organizar funções dentro de classes que não precisam aceder a dados de instância. Como não estão vin­cu­la­das a uma instância, elas não podem modificar o estado de um objeto. São fer­ra­men­tas úteis dentro da classe, pois servem para realizar tarefas gerais ou fornecer fun­ci­o­na­li­da­des globais. Por exemplo, elas podem conter uti­li­tá­rios, rotinas de conversão ou funções gerais de ajuda que podem ser acessadas sem dados de instância.

Qual é a sintaxe do método estático Python?

Existem duas formas de criar métodos estáticos em Python: utilizar a função staticmethod() ou o decorador @staticmethod.

staticmethod()

Python staticmethod() é uma função in­cor­po­rada que converte um método de uma classe em estático. O valor de retorno da função sta­tic­method() é um método estático para a função que é passada como argumento. É escrito da seguinte forma:

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

Ao passar a função staticmethodFunc(), definida na classe Class, como argumento para staticmethod(), pode aceder ao seu próprio método di­re­ta­mente através do nome da classe.

@staticmethod

O decorador @staticmethod é um método mais curto e comum para marcar uma função como estática. O decorador é colocado acima do método na definição da classe. Esta é a sua sintaxe:

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

O decorador @staticmethod indica ao in­ter­pre­ta­dor que a função definida deve ser tratada como um método estático.

Exemplos de código para usar o método estático Python

Pode utilizar métodos estáticos para di­fe­ren­tes tarefas. Veja os exemplos apre­sen­ta­dos a seguir.

Converter unidades

O método estático Python é muito útil para converter unidades.

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.

Neste exemplo, a classe Converter tem dois métodos estáticos para converter entre horas e minutos. O método hoursToMinutes() converte horas em minutos, enquanto o minutesToHours() converte minutos em horas.

Os métodos estáticos são acedidos uti­li­zando o nome da classe, sem ne­ces­si­dade de criar uma instância da classe. O acesso é feito di­re­ta­mente através de Converter.hoursToMinutes() ou Converter.minutesToHours(), em que Converter é o nome da classe. O resultado é apre­sen­tado uti­li­zando uma f-string, que é um método de for­ma­ta­ção de cadeia ou Python string format que permite combinar ex­pres­sões dentro de uma cadeia de texto.

Funções de ajuda para realizar cálculos ma­te­má­ti­cos

O método estático Python também pode ser utilizado para definir funções de ajuda para cálculos se­cun­dá­rios da seguinte forma:

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 código de exemplo mostra a classe Calculator com métodos estáticos para calcular o quadrado e a raiz quadrada de um número. Através do decorador @staticmethod, square() (quadrado) e sqroot() (raiz quadrada) são marcados como métodos estáticos. Sem criar uma instância da classe, é possível aceder aos métodos através do nome da classe. Em seguida, o resultado de Calculator.square() e Calculator.sqroot() é con­ca­te­nado numa f-string.

Validar entradas

Outra uti­li­za­ção do método estático Python é a validação de entradas.

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

A classe Validator com­pre­ende dois métodos estáticos: isInteger() e isDecimal(). Estas funções verificam se uma entrada dada é um número inteiro ou decimal. O método estático do Python isInteger() recebe uma entrada e tenta convertê-la em um número inteiro (int(num)). Se conseguir, retorna True. Caso contrário, obtém-se False se for capturada uma exceção ValueError, o que ocorre quando a validação não é possível.

O método isDecimal() é utilizado para converter a entrada num número decimal (float(num)). Se for bem-sucedido, é devolvido True e, caso contrário, False. Em seguida, são uti­li­za­dos os métodos estáticos isInteger() e isDecimal() da classe Validator para verificar as entradas "123" e "3.14". Os re­sul­ta­dos são ver­da­dei­ros para ambas as funções.

Manipular strings

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

Neste exemplo, define-se uma classe StringManipulation com um método estático reverseText(). Este método recebe um texto como parâmetro e utiliza a sintaxe de slicing [::-1] para inverter o texto "Hello World!" e devolver o resultado. f4649815b521372b53abd1cf80ba98ab