一摞Python风格的纸牌
接下来我会用一个非常简单的例子来展示如何实现 __getitme__ 和
__len__ 这两个特殊方法，通过这个例子我们也能见识到特殊方法的强
大。
示例 1-1 里的代码建立了一个纸牌类
示例 1-1 一摞有序的纸牌
import collections
Card = collections.namedtuple('Card', ['rank', 'suit'])
class FrenchDeck:
ranks = [str(n) for n in range(2, 11)] + list('JQKA')
suits = 'spades diamonds clubs hearts'.split()
def __init__(self):
self._cards = [Card(rank, suit) for suit in self.suits
for rank in self.ranks]
def __len__(self):
return len(self._cards)
def __getitem__(self, position):
return self._cards[position]
首先，我们用 collections.namedtuple 构建了一个简单的类来表示
一张纸牌。自 Python 2.6 开始，namedtuple 就加入到 Python 里，用以
构建只有少数属性但是没有方法的对象，比如数据库条目。如下面这个
控制台会话所示，利用 namedtuple，我们可以很轻松地得到一个纸牌
对象：
>>> beer_card = Card('7', 'diamonds')
>>> beer_card
Card(rank='7', suit='diamonds')
当然，我们这个例子主要还是关注 FrenchDeck 这个类，它既短小又精
悍。首先，它跟任何标准 Python 集合类型一样，可以用 len() 函数来
查看一叠牌有多少张：
>>> deck = FrenchDeck()
>>> len(deck)
52
从一叠牌中抽取特定的一张纸牌，比如说第一张或最后一张，是很容易
的：deck[0] 或 deck[-1]。这都是由 __getitem__ 方法提供的：
>>> deck[0]
Card(rank='2', suit='spades')
>>> deck[-1]
Card(rank='A', suit='hearts')
我们需要单独写一个方法用来随机抽取一张纸牌吗？没必要，Python 已
经内置了从一个序列中随机选出一个元素的函数 random.choice，我
们直接把它用在这一摞纸牌实例上就好：
>>> from random import choice
>>> choice(deck)
Card(rank='3', suit='hearts')
>>> choice(deck)
Card(rank='K', suit='spades')
>>> choice(deck)
Card(rank='2', suit='clubs')
现在已经可以体会到通过实现特殊方法来利用 Python 数据模型的两个好
处。
作为你的类的用户，他们不必去记住标准操作的各式名称（“怎么
得到元素的总数？是 .size() 还是 .length() 还是别的什
么？”）。
可以更加方便地利用 Python 的标准库，比如 random.choice 函
数，从而不用重新发明轮子。
而且好戏还在后面。
因为 __getitem__ 方法把 [] 操作交给了 self._cards 列表，所以我
们的 deck 类自动支持切片（slicing）操作。下面列出了查看一摞牌最
上面 3 张和只看牌面是 A 的牌的操作。其中第二种操作的具体方法是，
先抽出索引是 12 的那张牌，然后每隔 13 张牌拿 1 张：
>>> deck[:3]
[Card(rank='2', suit='spades'), Card(rank='3', suit='spades'),
Card(rank='4', suit='spades')]
>>> deck[12::13]
[Card(rank='A', suit='spades'), Card(rank='A', suit='diamonds'),
Card(rank='A', suit='clubs'), Card(rank='A', suit='hearts')]
另外，仅仅实现了 __getitem__ 方法，这一摞牌就变成可迭代的了：
>>> for card in deck: # doctest: +ELLIPSIS
... print(card)
Card(rank='2', suit='spades')
Card(rank='3', suit='spades')
Card(rank='4', suit='spades')
...
反向迭代也没关系：
>>> for card in reversed(deck): # doctest: +ELLIPSIS
... print(card)
Card(rank='A', suit='hearts')
Card(rank='K', suit='hearts')
Card(rank='Q', suit='hearts')
doctest 中的省略
为了尽可能保证书中的 Python 控制台会话内容的正确性，这些内容
都是直接从 doctest 里摘录的。在测试中，如果可能的输出过长的
话，那么过长的内容就会被如上面例子的最后一行的省略号
（...）所替代。此时就需要 #doctest: +ELLIPSIS 这个指令来
保证 doctest 能够通过。要是你自己照着书中例子在控制台中敲代
码，可以略过这一指令。
迭代通常是隐式的，譬如说一个集合类型没有实现 __contains__ 方
法，那么 in 运算符就会按顺序做一次迭代搜索。于是，in 运算符可以
用在我们的 FrenchDeck 类上，因为它是可迭代的：
>>> Card('Q', 'hearts') in deck
True
>>> Card('7', 'beasts') in deck
False
那么排序呢？我们按照常规，用点数来判定扑克牌的大小，2 最小、A
最大；同时还要加上对花色的判定，黑桃最大、红桃次之、方块再次、
梅花最小。下面就是按照这个规则来给扑克牌排序的函数，梅花 2 的大
小是 0，黑桃 A 是 51：
suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0)
def spades_high(card):
rank_value = FrenchDeck.ranks.index(card.rank)
return rank_value * len(suit_values) + suit_values[card.suit]
有了 spades_high 函数，就能对这摞牌进行升序排序了：
>>> for card in sorted(deck, key=spades_high): # doctest: +ELLIPSIS
... print(card)
Card(rank='2', suit='clubs')
Card(rank='2', suit='diamonds')
Card(rank='2', suit='hearts')
... (46 cards ommitted)
Card(rank='A', suit='diamonds')
Card(rank='A', suit='hearts')
Card(rank='A', suit='spades')
虽然 FrenchDeck 隐式地继承了 object 类， 但功能却不是继承而来
的。我们通过数据模型和一些合成来实现这些功能。通过实现 __len__
和 __getitem__ 这两个特殊方法，FrenchDeck 就跟一个 Python 自有
的序列数据类型一样，可以体现出 Python 的核心语言特性（例如迭代和
切片）。同时这个类还可以用于标准库中诸如
random.choice、reversed 和 sorted 这些函数。另外，对合成的运
用使得 __len__ 和 __getitem__ 的具体实现可以代理给 self._cards
这个 Python 列表（即 list 对象）。
5
5
在 Python 2 中，对 object 的继承需要显式地写为 FrenchDeck(object)；而在 Python 3 中，
这个继承关系是默认的。
如何洗牌
按照目前的设计，FrenchDeck 是不能洗牌的，因为这摞牌是不可
变的（immutable）：卡牌和它们的位置都是固定的，除非我们破坏
这个类的封装性，直接对 _cards 进行操作。第 11 章会讲到，其
实只需要一行代码来实现 __setitem__ 方法，洗牌功能就不是问
题了。
