Python 十几行代码实现你对一副扑克牌的所有幻想

import collections
from random import choice, shuffle

# 构建了一个简单的 Card 类来表示一张纸牌，rank牌值，suit花色
Card = collections.namedtuple('Card', ['rank', 'suit'])

class FrenchDeck:
    '''定义扑克牌类'''
    # 所有牌值 ranks
    ranks = [str(n) for n in range(2, 11)] + list('JQKA')

    # 所有花色 suits
    suits = 'spades hearts diamonds clubs'.split()

    def __init__(self):
        # 初始化 FrenchDeck 类，创建 52 张牌 self._cards
        self._cards = [Card(rank, suit) for suit in self.suits for rank in self.ranks]

    def __len__(self):
        #  len(FrenchDeck实例)时，返回牌数
        return len(self._cards)

    def __getitem__(self, position):
        # 实现实例下标取牌，如：FrenchDeck实例[0] 表示取第一张牌
        return self._cards[position]


# 创建一副牌 deck
deck = FrenchDeck()

# 查看这副牌有多少张
print(len(deck))

# 取出第一张牌
print(deck[0])

# 取出最后一张牌
print(deck[-1])

# 随机抽取一张牌
print(choice(deck))

# 洗牌的实现（猴子补丁）：
def set_card(deck,position,card):    # 定义一个函数，它的参数为 deck、position 和 card
    deck._cards[position] = card
FrenchDeck.__setitem__ = set_card    # 把函数赋值给 FrenchDeck 类的 __setitem__ 属性（动态协议）
shuffle(deck)                        # 洗牌
# 查看洗牌效果
for d in deck:
    print(d)

这段代码使用到了三个特殊方法： 

　　__getitme__

　　__len__ 

　　__getitem__

使用了 Python 的标准模块 ：

　　colleciton
　　random （用到两个方法：choice shuffle)

实现了扑克牌实例的诸多功能：

　　不必去记住标准操作的各式名称（“怎么 得到元素的总数？是 .size() 还是 .length() 还是别的什 么？”）

　　可以更加方便地利用 Python 的标准库，比如 random.choice ，random.shuffle 函 数，从而不用重新发明轮子

　　因为 __getitem__ 方法把 [] 操作交给了 self._cards 列表，所以我 们的 deck 类自动支持切片（slicing）操作

　　仅仅实现了 __getitem__ 方法，一摞牌就变成可迭代的了

　　还利用了猴子补丁和动态协议来实现洗牌可能

FrenchDeck 这个类，它既短小又精悍，它跟任何标准 Python 集合类型一样，可以用 len() 函数来 查看一叠牌有多少张。

>>> 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')

　

因为 __getitem__ 方法把 [] 操作交给了 self._cards 列表，所以我 们的 deck 类自动支持切片（slicing）操作，：

>>> deck[:3]    # 查看一摞牌最上面 3 张
[Card(rank='2', suit='spades'), Card(rank='3', suit='spades'),
Card(rank='4', suit='spades')]
>>> deck[12::13]    # 先抽出索引是 12 的那张牌，然后每隔 13 张牌拿 1 张
[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: 
... print(card)
Card(rank='2', suit='spades')
Card(rank='3', suit='spades')
Card(rank='4', suit='spades')
...

　　

in 运算符可以 用在我们的 FrenchDeck 类上：

>>> Card('Q', 'hearts') in deck
True
>>> Card('7', 'beasts') in deck
False

　　

排序：

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]

>>> for card in sorted(deck, key=spades_high): 
... 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')

　　

洗牌：

>>> def set_card(deck, position, card):   # 定义一个函数，它的参数为 deck、position 和 card  
... deck._cards[position] = card
...
>>> FrenchDeck.__setitem__ = set_card   # 把那个函数赋值给 FrenchDeck 类的 __setitem__ 属性
>>> shuffle(deck)   # 现在可以打乱 deck 了，因为 FrenchDeck 实现了可变序列协议所需
的方法

　　

以上例子除了说明猴子补丁之外， 还强调了协议是动态的：random.shuffle 函数不关心参数的类型，只要那个对象实现了部 分可变序列协议即可。即便对象一开始没有所需的方法也没关系，后来再提供也行。