Digamos que queremos proporcionar una abstracción de una "cuenta" en un banco. Aquí hay un enfoque, usando un function
objeto en 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
Aquí hay otro enfoque que usa abstracción de tipo (es decir, class
palabra clave en 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
Mi maestro comenzó el tema "Programación orientada a objetos" introduciendo la class
palabra clave y mostrándonos estos puntos:
Programación orientada a objetos
Un método para organizar programas modulares:
- Barreras de abstracción
- Paso de mensajes
- Agrupando información y comportamiento relacionado
¿Crees que el primer enfoque sería suficiente para satisfacer la definición anterior? En caso afirmativo, ¿por qué necesitamos la class
palabra clave para hacer programación orientada a objetos?
foo.bar()
generalmente es idéntico y foo['bar']()
, en raras ocasiones, la última sintaxis es realmente útil.
object['method'](args)
, los objetos de Python realmente hacen el equivalente de object['method'](object, args)
. Esto se vuelve relevante cuando una clase base llama a métodos en una clase secundaria, por ejemplo, en el Patrón de estrategia.
class
hace una optimización similar).