摘自Mastering Object-oriented Python
隐式的基类——object
Python是面向对象程序设计语言，有一个类似root的基础类object类。任何自定义的类，都会隐式继承object。
class X:
pass
print(X.__class__)
# <class 'type'>
print(X.__class__.__base__)
# <class 'object'>
基类中的初始化方法
- 延迟赋值
这是指先创建类模板，然后在实例中定义属性并赋值。在Python中，延迟赋值的合法的，但是会存在潜在问题，因此要尽量避免这样的用法。
在基类中实现__init__()方法
每当创建一个对象，Python会先创建一个空对象，然后调用该对象的__init__()函数。
一个常见的多态设计
class Card:
def __init__(self,rank,suit):
self.suit = suit
self.rank = rank
self.hard, self.soft = self._points()
class NumberCard(Card):
def _points(self):
return int(self.rank), int(self.rank)
class AceCard(Card):
def _points(self):
return 1, 11
class FaceCard(Card):
def _points(self):
return 10, 10
使用__init__()方法创建常量清单
可以把创建好的花色对象做缓存，构建一个常量池，使得在调用时对象可被重用，那么性能将得到显著的提升。
class Suit:
def __init__(self, name, symbol):
self.name = name
self.symbol = symbol
Club, Diamond, Heart, Spade = Suit('Club','♠'), Suit('Diamond','♦'), Suit('Heart','♥'), Suit('Spade','♣')
Cards = [AceCard('A', Spade), NumberCard('2',Spade), NumberCard('3',Spade)]
使用工厂函数调用__init__()
可以使用工厂函数来完成所有的Card对象的创建。在Python中实现工厂有两种途径
- 定义一个函数，返回不同类的对象
- 定义一个类，包括了创建对象的方法
一个用来生成Card子类对象的工厂函数例子
def card(rank, suit):
if rank == 1: return AceCard('A',suit)
elif 2 <= rank < 11: return NumberCard(str(rank),suit)
elif 11 <= rank < 14:
name = {11: 'J', 12: 'Q', 13: 'K'}[rank]
return FaceCard(name, suit)
else:
raise Exception('Rank out of range.')
deck = [card(rank,suit) for rank in range(1,14)
for suit in (Club, Diamond, Heart, Spade)]
这里需要注意的是if语句的结构，else语句没有做一些其他步骤，而只是单纯地抛出了一个异常。像这样的catch-all else语句的使用方式是有争议的。
使用elif简化设计来获得一致性
工厂方法card()中包括了两个很常见的结构
- if-elif序列
- 映射
这是一个没有使用映射Card工厂类的例子
def card3(rank, suit):
if rank == 1: return AceCard('A',suit)
elif 2 <= rank < 11: return NumberCard(str(rank),suit)
elif rank == 11: return FaceCard('J', suit)
elif rank == 12: return FaceCard('Q', suit)
elif rank == 13: return FaceCard('K', suit)
else:
raise Exception('Rank out of range.')
相比上一个版本，这个函数在实现上获得了更好的一致性。
使用映射和类来简化设计
下面这个例子用映射来实现，把rank映射为对象，然后又把rank值和suit值作为参数传入Card构造函数来创建Card实例。
def card4(rank, suit):
class_ = {1: AceCard, 11: FaceCard, 12: FaceCard, 13: FaceCard}.get(rank, NumberCard)
return class_(rank, suit)
实现两部分映射
并行映射
不推荐使用映射到一个牌面值的元组
def card5(rank, suit):
class_, rank_str = {1: (AceCard,'A'),
11: (FaceCard,'J'),
12: (FaceCard,'Q'),
13: (FaceCard,'K')}.get(rank,(NumberCard,str(rank)))
return class_(rank_str, suit)
- partial函数设计
partial()函数在面向对象编程中不是很常用。
- 工厂模式的流畅API设计
class CardFactory:
def rank(self, rank):
self.class_, self.rank_str = {1: (AceCard,'A'),
11: (FaceCard,'J'),
12: (FaceCard,'Q'),
13: (FaceCard,'K')}.get(rank,(NumberCard,str(rank)))
return self
def suit(self, suit):
return self.class_(self.rank_str, suit)
card8 = CardFactory()
deck8 = [card8.rank(r+1).suit(s) for r in range(13)
for s in (Club, Diamond, Heart, Spade)]
这种方法并没有利用__init__()在Card类层次结构中的作用，改变的是调用者创建对象的方式。
在每个子类中实现__init__()方法
class Card:
def __init__(self, rank, suit, hard, soft):
self.suit = suit
self.rank = rank
self.hard = hard
self.soft = soft
class NumberCard(Card):
def __init__(self, rank, suit):
super().__init__(str(rank), suit, rank, rank)
class AceCard(Card):
def __init__(self, rank, suit):
super().__init__('A', suit, 1, 11)
class FaceCard(Card):
def __init__(self, rank, suit):
super().__init__({11: 'J', 12: 'Q', 13: 'K'}[rank], suit, 10, 10)
使用__init__()方法和工厂函数之间存在一些权衡。通常直接调用比“程序员友好”的__init__()函数并把复杂性分发给工厂函数更好。
简单的组合对象
一个组合对象也可以称作容器。
设计集合类，通常有如下3种策略：
- 封装
- 扩展
- 创建
封装集合类
定义Deck类，内部实际调用的是list对象。Deck类的pop()方法只是对list对象响应函数的调用。
class Deck:
def __init__(self):
self._cards = [card8.rank(r+1).suit(s) for r in range(13)
for s in (Club, Diamond, Heart, Spade)]
random.shuffle(self._cards)
def pop(self):
return self._cards.pop()
扩展集合类
pop()函数只需继承自list集合就可以很好地工作，其他函数也一样。
class Deck2(list):
def __init__(self):
super().__init__(card8.rank(r+1).suit(s) for r in range(13) for s in (Club, Diamond, Heart, Spade))
random.shuffle(self)
完成组合对象的初始化
__init__()初始化方法应当返回一个完整的对象，这是理想的情况。
不带__init__()方法的无状态对象
对于策略模式的对象来说这是常见的设计。一个策略对象以插件的形式符合在主对象上来完成一种算法或逻辑，例如GameStrategy类。
（未完待续）
