python抽样不同花色纸牌_Python 十几行代码实现你对一副扑克牌的所有幻想

1 importcollections2 from random importchoice, shuffle3

4 #构建了一个简单的 Card 类来表示一张纸牌，rank牌值，suit花色

5 Card = collections.namedtuple('Card', ['rank', 'suit'])6

7 classFrenchDeck:8 '''定义扑克牌类'''

9 #所有牌值 ranks

10 ranks = [str(n) for n in range(2, 11)] + list('JQKA')11

12 #所有花色 suits

13 suits = 'spadeshearts diamonds clubs'.split()14

15 def __init__(self):16 #初始化 FrenchDeck 类，创建 52 张牌 self._cards

17 self._cards = [Card(rank, suit) for suit in self.suits for rank inself.ranks]18

19 def __len__(self):20 #len(FrenchDeck实例)时，返回牌数

21 returnlen(self._cards)22

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

25 returnself._cards[position]26

27

28 #创建一副牌 deck

29 deck =FrenchDeck()30

31 #查看这副牌有多少张

32 print(len(deck))33

34 #取出第一张牌

35 print(deck[0])36

37 #取出最后一张牌

38 print(deck[-1])39

40 #随机抽取一张牌

41 print(choice(deck))42

43 #洗牌的实现(猴子补丁)：

44 def set_card(deck,position,card): #定义一个函数，它的参数为 deck、position 和 card

45 deck._cards[position] =card46 FrenchDeck.__setitem__ = set_card #把函数赋值给 FrenchDeck 类的 __setitem__ 属性(动态协议)

47 shuffle(deck) #洗牌

48 #查看洗牌效果

49 for d indeck:50 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 函数不关心参数的类型，只要那个对象实现了部 分可变序列协议即可。即便对象一开始没有所需的方法也没关系，后来再提供也行。