Métodos de instância

O que é um método

Um método é simplesmente uma função escrita dentro da classe. A diferença para uma função solta é o self: como todo método de instância, ele recebe o objeto atual em primeiro lugar e, por meio dele, alcança os atributos daquele objeto. É assim que o comportamento gruda no dado. Em vez de uma função depositar(saldo, valor) longe da conta, você escreve um método depositar dentro da classe, e ele já sabe em qual saldo mexer: o self.saldo.

class Conta:
    def __init__(self, titular, saldo=0):
        self.titular = titular
        self.saldo = saldo

    def depositar(self, valor):
        self.saldo = self.saldo + valor

conta = Conta("Ana", 100)
conta.depositar(50)
print(conta.saldo)  # 150

O método depositar usa self.saldo para alterar o saldo do próprio objeto.

Ao chamar conta.depositar(50), o Python entrega a própria conta como self e o número 50 como valor. Dentro do método, self.saldo = self.saldo + valor lê o saldo atual do objeto, soma o depósito e grava de volta. Repare que você não passa o self na chamada; ele vem do objeto antes do ponto. Por isso a assinatura tem dois parâmetros, self e valor, mas a chamada informa só o valor.

O self liga o método ao objeto certo

Como o método age sempre sobre o self, o mesmo código serve a qualquer objeto. Chame conta_ana.depositar(50) e o depósito entra na conta da Ana; chame conta_bruno.depositar(10) e entra na do Bruno. É o objeto antes do ponto que decide qual saldo será alterado. Uma classe, muitos objetos, um método só, e cada chamada mexe apenas nos dados do objeto certo. Essa é a economia da orientação a objetos: escrever o comportamento uma vez e reaproveitar em todas as instâncias.

class Conta:
    def __init__(self, titular, saldo=0):
        self.titular = titular
        self.saldo = saldo

    def depositar(self, valor):
        self.saldo += valor

ana = Conta("Ana", 100)
bruno = Conta("Bruno", 100)

ana.depositar(500)
print(ana.saldo)    # 600
print(bruno.saldo)  # 100  (nao mudou)

O mesmo método depositar age em objetos diferentes, sem misturar os saldos.

Regras dentro do método

O grande ganho de guardar o comportamento dentro do objeto é poder pôr regras junto. Um saque não deveria deixar o saldo negativo, e o lugar natural para essa checagem é o próprio método sacar. Assim, qualquer parte do programa que sacar dessa conta passa pela mesma regra, sem chance de esquecer. Isso se chama encapsular: os dados e as regras que mexem neles ficam dentro do objeto, e o resto do código só pede ações claras, como depositar e sacar.

class Conta:
    def __init__(self, titular, saldo=0):
        self.titular = titular
        self.saldo = saldo

    def depositar(self, valor):
        self.saldo += valor

    def sacar(self, valor):
        if valor > self.saldo:
            print("Saldo insuficiente.")
            return False
        self.saldo -= valor
        return True

c = Conta("Ana", 100)
print(c.sacar(30))   # True
print(c.saldo)       # 70
print(c.sacar(200))  # Saldo insuficiente.  ->  False

O método sacar valida o saldo antes de descontar e avisa quando não dá.

O método sacar primeiro compara o valor pedido com o self.saldo. Se não houver saldo, ele avisa e devolve False sem mexer no dinheiro. Havendo saldo, desconta e devolve True. Devolver um booleano deixa quem chamou saber se o saque deu certo, para decidir o que fazer em seguida. Com depositar e sacar prontos, ninguém precisa alterar self.saldo direto pelo ponto: o objeto passa a cuidar do seu próprio dinheiro, com regras garantidas. Na prática final do módulo você reúne tudo isso em uma classe ContaBancaria completa.