Dúvida com o @staticmethod | Python: entendendo a Orientação a Objetos

No meu código eu fiz da forma como o Nico ensinou e funcionou normalmente, mas resolvi fazer diferente e criar um método genérico sem precisar utilizar o @staticmethod para saber qual erro ele retornaria. O problema é que quando realizei foi retornado normalmente o método que criei. Minha dúvida é: O @staticmethod é uma forma de convenção do código e não algo que influencia diretamente na sua funcionalidade?

Meu código completo com o método que eu criei:

class Conta:

    def __init__(self, numero, titular, saldo, limite = 1000.0):
        print("Objeto sendo criado...{}" .format(self))
        self.__numero = numero
        self.__titular = titular
        self.__saldo = saldo
        self.__limite = limite

    #Métodos
    def extrato(self):
        print("O saldo de R$ {:.2f} do titular {}" .format(self.__saldo, self.__titular))
    def deposita(self, valor):
        self.__saldo += valor
    def saca(self, valor):
        if self.__pode_sacar(valor):
            self.__saldo -= valor
            print("Saque Efetuado")
        else:
            print(f"O valor {valor} passou do limite!")
    def transfere(self, valor, destino):
        self.saca(valor)
        destino.deposita(valor)

    # Métodos Privados
    def __pode_sacar(self, valor):
        valor_disponivel_a_sacar = valor <= (self.__saldo + self.__limite)
        return valor_disponivel_a_sacar
    #Propriedades
    @property
    def saldo(self):
        return self.__saldo
    @property
    def titular(self):
        return self.__titular
    @property
    def limite(self):
        return self.__limite
    @limite.setter
    def limite(self, limite):
        self.__limite = limite
    #Métodos Estáticos
    @staticmethod
    def codigo_banco():
        return "001"
    @staticmethod
    def codigos_bancos():
        codigo_dos_bancos = {"BB":"001", "Caixa":"104", "Bradesco":"237"}
        return codigo_dos_bancos

    def soma():
        soma = 2 + 1
        return soma

Retorno do método

>>> from conta import Conta
>>> Conta.soma()
3

Oiiii Vinicius, como você está? Espero que esteja bem ^-^

Peço desculpas pela demora em obter um retorno.

O decorador staticmethod influencia diretamente na funcionalidade quando precisamos utilizá-lo vinculado a um objeto ou então, quando estamos fazendo herança de classes. Reduzi o código apresentado por você para que possamos usá-lo como exemplo, ficou da seguinte forma:

class Conta:

    def __init__(self):
        print("Objeto sendo criado...{}" .format(self))

    @staticmethod
    def codigos_bancos():
        codigo_dos_bancos = {"BB":"001", "Caixa":"104", "Bradesco":"237"}
        return codigo_dos_bancos

    def soma():
        soma = 2 + 1
        return soma

Tendo como base isso, vamos recapitular....

O staticmethod tem como principal funcionalidade a possibilidade de chamarmos um método sem precisarmos criar uma instância da classe e nisso, criar um método tanto com decorador estático ou sem, funcionará da mesma forma, veja:

Conta.codigos_bancos() # com decorador
Conta.soma() # sem decorador

Ao criarmos um método sem colocarmos o decorador staticmethod ele funcionará como uma função normal, porém, com a diferença que a mesma estará dentro de uma classe. A mágica de utilizarmos o método estático é que implicitamente ele vincula o argumento self naquele método, então, caso seja necessário chamarmos o método estático através de um objeto será possível, porém, com um método sem o decorador não. Em código teremos o seguinte:

# chamando um método COM decorador staticmethod
objeto_conta = Conta()
objeto_conta.codigos_bancos()

# chamando um método SEM decorador staticmethod
objeto_conta = Conta()
objeto_conta.soma()

No segundo caso, quando chamamos o método sem o decorador estático, obteremos um erro dizendo que é necessário passarmos um argumento self.

Outra diferença é que quando utilizamos o método estático explicitamente, conseguiremos herdá-lo em uma classe filha. No entanto, caso façamos apenas uma função simples sem o uso do decorador, ao invés de herdarmos o método, iremos criar um novo.

Resumo:

Ao utilizar o método estático, implicitamente o argumento self é passado, o que faz com que possamos chamar o método por meio de um objeto
Ao utilizar um método estático podemos sobrescrevê-lo em situações de herança
Utilizar um método estático deixa explícito para o programador que o método não depende de um objeto, facilitando assim a legibilidade de código
Métodos sem o decorador staticmethod se comportam como funções comuns, porém, dentro de um escopo de uma classe

Qualquer dúvida estou por aqui, a gente vai se falando.

Grande abraço!