Digamos que desejamos fornecer uma abstração de uma "conta" em um banco. Aqui está uma abordagem, usando um function
objeto em Python:
def account():
"""Return a dispatch dictionary representing a bank account.
>>> a = account()
>>> a['deposit'](100)
100
>>> a['withdraw'](90)
10
>>> a['withdraw'](90)
'Insufficient funds'
>>> a['balance']
10
"""
def withdraw(amount):
if amount > dispatch['balance']:
return 'Insufficient funds'
dispatch['balance'] -= amount
return dispatch['balance']
def deposit(amount):
dispatch['balance'] += amount
return dispatch['balance']
dispatch = {'balance': 0,
'withdraw': withdraw,
'deposit': deposit}
return dispatch
Aqui está outra abordagem usando a abstração de tipo (por exemplo, class
palavra-chave em Python):
class Account(object):
"""A bank account has a balance and an account holder.
>>> a = Account('John')
>>> a.deposit(100)
100
>>> a.withdraw(90)
10
>>> a.withdraw(90)
'Insufficient funds'
>>> a.balance
10
"""
def __init__(self, account_holder):
self.balance = 0
self.holder = account_holder
def deposit(self, amount):
"""Add amount to balance."""
self.balance = self.balance + amount
return self.balance
def withdraw(self, amount):
"""Subtract amount from balance if funds are available."""
if amount > self.balance:
return 'Insufficient funds'
self.balance = self.balance - amount
return self.balance
Meu professor iniciou o tópico "Programação orientada a objetos" introduzindo a class
palavra - chave e mostrando-nos os seguintes pontos:
Programação orientada a objetos
Um método para organizar programas modulares:
- Barreiras de abstração
- Passagem de mensagem
- Agrupando informações e comportamento relacionado
Você acha que a primeira abordagem seria suficiente para satisfazer a definição acima? Se sim, por que precisamos da class
palavra-chave para fazer programação orientada a objetos?
foo.bar()
é geralmente idêntico e foo['bar']()
, em raras ocasiões, a última sintaxe é realmente útil.
object['method'](args)
, os objetos Python realmente fazem o equivalente a object['method'](object, args)
. Isso se torna relevante quando uma classe base chama métodos em uma classe filho, por exemplo, no Padrão de Estratégia.
class
faça uma otimização semelhante).