[译] Python 学习 —— __init__() 方法 2

注：原书做者 Steven F. Lott，原书名为 Mastering Object-oriented Python

经过工厂函数对 __init__() 加以利用

咱们能够经过工厂函数来构建一副完整的扑克牌。这会比枚举全部52张扑克牌要好得多。在Python中，咱们有以下两种常见的工厂方法：

• 定义一个函数，该函数会建立所需类的对象。

• 定义一个类，该类有建立对象的方法。这是一个完整的工厂设计模式，正如设计模式书所描述的那样。在诸如Java这样的语言中，工厂类层次结构是必须的，由于该语言不支持独立的函数。

在Python中，类不是必须的。只有当相关的工厂很是复杂的时候才会显现出优点。Python的优点就是当一个简单的函数能够作的更好时咱们决不强迫使用类层次结构。

虽然这是一本关于面向对象编程的书，但函数真是一个好东西。这是常见也是最地道的Python。

若是须要的话，咱们老是能够重写一个函数为适当的可调用对象，能够将一个可调用对象重构到咱们的工厂类层次结构中。咱们将在第五章《使用Callables和Contexts》中学习可调用对象。

通常，类定义的优势是经过继承实现代码重用。工厂类的函数就是包装一些目标类层次结构和复杂对象的构造。若是咱们有一个工厂类，当扩展目标类层次结构的时候，咱们能够添加子类到工厂类中。这给咱们提供了多态工厂类，不一样的工厂类定义具备相同的方法签名，能够交替使用。

这个类级别的多态对于静态编译语言如Java或C++很是有用。编译器能够解决类和方法生成代码的细节。

若是选择的工厂定义不能重用任何代码，则类层次结构在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")

这个函数经过rank数值和suit对象构建Card类。如今咱们能够更简单的构建牌了。咱们已经将构造过程封装到一个单一的工厂函数中处理，容许应用程序在不知道精确的类层次结构和多态设计是如何工做的状况下进行构建。

下面是如何经过这个工厂函数构建一副牌的示例：

deck = [card(rank, suit) for rank in range(1,14) for suit in (Club, Diamond, Heart, Spade)]

它枚举了全部的牌值和花色来建立完整的52张牌。

1. 错误的工厂设计和模糊的else子句

注意card()函数里面的if语句结构。咱们没有使用“一应俱全”的else子句来作任何处理；咱们只是抛出异常。使用“一应俱全”的else子句会引出相关的小争论。

一方面，从属于else子句的条件不能不言而喻，由于它可能隐藏着细微的设计错误。另外一方面，一些else子句确实是显而易见的。

重要的是要避免含糊的else子句。

考虑下面工厂函数定义的变体：

def card2(rank, suit):
    if rank == 1: 
        return AceCard('A', suit)
    elif 2 <= rank < 11: 
        return NumberCard(str(rank), suit)
    else:
        name = {11: 'J', 12: 'Q', 13: 'K'}[rank]
        return FaceCard(name, suit)

如下是当咱们尝试建立整副牌将会发生的事情：

deck2 = [card2(rank, suit) for rank in range(13) for suit in (Club, Diamond, Heart, Spade)]

它起做用了吗？若是if条件更复杂了呢？

一些程序员扫视的时候能够理解这个if语句。其余人将难以肯定是否全部状况都正确执行了。

对于Python高级编程，咱们不该该把它留给读者去演绎条件是否适用于else子句。对于菜鸟来讲条件应该是显而易见的，至少也应该是显式的。

什么时候使用“一应俱全”的else

尽可能的少使用，使用它只有当条件是显而易见的时候。当有疑问时，显式的使用并抛出异常。

避免含糊的else子句。

2. 简单一致的使用elif序列

咱们的工厂函数card()是两种常见工厂设计模式的混合物:

• if-elif序列

• 映射

为了简单起见，最好是专一于这些技术的一个而不是两个。

咱们老是能够用映射来代替elif条件。（是的，老是。但相反是不正确的；改变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")

咱们重写了card()工厂函数。映射已经转化为额外的elif子句。这个函数有个优势就是它比以前的版本更加一致。

3. 简单的使用映射和类对象

在一些示例中，咱们可使用映射来代替一连串的elif条件。极可能发现条件太复杂，这个时候或许只有使用一连串的elif条件来表达才是明智的选择。对于简单示例，不管如何，映射能够作的更好且可读性更强。

由于class是最好的对象，咱们能够很容易的映射rank参数到已经构造好的类中。

如下是仅使用映射的Card工厂：

def card4(rank, suit):
    class_ = {1: AceCard, 11: FaceCard, 12: FaceCard, 13: FaceCard}.get(rank, NumberCard)
    return class_(rank, suit)

咱们已经映射rank对象到类中。而后，咱们给类传递rank值和suit值来建立最终的Card实例。

最好咱们使用defaultdict类。不管如何，对于微不足道的静态映射不会比这更简单了。看起来像下面代码片断那样：

defaultdict(lambda: NumberCard, {1: AceCard, 11: FaceCard, 12: FaceCard, 12: FaceCard})

注意：defaultdict类默认必须是无参数的函数。咱们已经使用了lambda建立必要的函数来封装常量。这个函数，不管如何，都有一些缺陷。对于咱们以前版本中缺乏1到A和13到K的转换。当咱们试图增长这些特性时，必定会出现问题的。

咱们须要修改映射来提供能够和字符串版本的rank对象同样的Card子类。对于这两部分的映射咱们还能够作什么？有四种常看法决方案：

• 能够作两个并行的映射。咱们不建议这样，可是会强调展现不可取的地方。

• 能够映射个二元组。这个一样也会有一些缺点。

• 能够映射到partial()函数。partial()函数是functools模块的一个特性。

• 能够考虑修改咱们的类定义，这种映射更容易。能够在下一节将__init__()置入子类定义中看到。

咱们来看看每个具体的例子。

3.1. 两个并行映射

如下是两个并行映射解决方案的关键代码：

class_ = {1: AceCard, 11: FaceCard, 12: FaceCard, 13: FaceCard}.get(rank, NumberCard)
rank_str = {1:'A', 11:'J', 12:'Q', 13:'K'}.get(rank, str(rank))
return class_(rank_str, suit)

这并不可取的。它涉及到重复映射键1、11、12和13序列。重复是糟糕的，由于在软件更新后并行结构依然保持这种方式。

不要使用并行结构

并行结构必须使用元组或一些其余合适的集合来替代。

3.2. 映射到元组的值

如下是二元组映射的关键代码：

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)

这是至关不错的，不须要过多的代码来分类打牌中的特殊状况。当咱们须要改变Card类层次结构来添加额外的Card子类时，咱们能够看到它是如何被修改或被扩展。

将rank值映射到一个类对象的确让人感受奇怪，且只有类初始化所需两个参数中的一个。将牌值映射到一个简单的类或没有提供一些混乱参数（但不是全部）的函数对象彷佛会更合理。

3.3. partial函数解决方案

相比映射到函数的二元组和参数之一，咱们能够建立一个partial()函数。这是一个已经提供一些（但不是全部）参数的函数。咱们将从functools库中使用partial()函数来建立一个带有rank参数的partial类。

如下是将rank映射到partial()函数，可用于对象建立：

from functools import partial

part_class = {
   1: partial(AceCard, 'A'),
   11: partial(FaceCard, 'J'),
   12: partial(FaceCard, 'Q'),
   13: partial(FaceCard, 'K'),
}.get(rank, partial(NumberCard, str(rank)))
return part_class(suit)

映射将rank对象与partial()函数联系在一块儿，并分配给part_class。这个partial()函数能够被应用到suit对象来建立最终的对象。partial()函数是一种常见的函数式编程技术。它在咱们有一个函数来替代对象方法这一特定的状况下使用。

不过整体而言，partial()函数对于大多数面向对象编程并无什么帮助。相比建立partial()函数，咱们能够简单地更新类的方法来接受不一样组合的参数。partial()函数相似于给对象建立一个流畅的接口。

3.4. 连贯的工厂类接口

在某些状况下，咱们设计的类在方法使用上定义好了顺序，按顺序求方法的值很像partial()函数。

在一个对象表示法中咱们可能会有x.a().b()。咱们能够把它当成x(a, b)。x.a()函数是等待b()的一类partial()函数。咱们能够认为它就像x(a)(b)那样。

这里的概念是，Python给咱们提供两种选择来管理状态。咱们既能够更新对象又能够建立有状态性的（在某种程度上）partial()函数。因为这种等价，咱们能够重写partial()函数到一个流畅的工厂对象中。使得rank对象的设置为一个流畅的方法来返回self。设置suit对象将真实的建立Card实例。

如下是一个流畅的Card工厂类，有两个方法函数，必须在特定顺序中使用：

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)

rank()方法更新构造函数的状态，suit()方法真实的建立了最终的Card对象。

这个工厂类能够像下面这样使用：

card8 = CardFactory()
deck8 = [card8.rank(r+1).suit(s) for r in range(13) for s in (Club, Diamond, Heart, Spade)]

首先，咱们建立一个工厂实例，而后咱们使用那个实例建立Card实例。这并无实质性改变__init__()在Card类层次结构中的运做方式。然而，它确实改变了咱们应用程序建立对象的方式。