1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

import random   #导入随机数函数

def puke():

    """

    生成一副52张的扑克牌（除去大小王）

    :return:

    """

    list1 = ['黑桃', '红桃', '方块', '梅花']

    list2 = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

    list3 = []

    for i in list1:

        for j in list2:

            dict1 = {i: j}

            list3.append(dict1)

    return list3

def func(num):

    """

    判断随机生成的三张扑克类型，对不同类型的牌 底分进行相应的翻倍

    其中num参数返回的是对玩家牌型计算后的分数。

    （最小单张是：2，

    11，12，13，14  分别代表：J，Q，K，A）

    :param num:

    :return:

    """

    user_list1 = []     #用于存储牌的花色

    user_list2 = []     #用于存储牌的数字

    global list4     #声明调用外部全局变量

    for i in list4:

        user_list1.append(list(i.keys()))

        for j in i:

            user_list1.append(list(i.values()))

    user_list2.append(user_list1[1])        #将遍历后的数字添加进user_list2中

    user_list2.append(user_list1[3])

    user_list2.append(user_list1[5])

    user_list2 = [int(x) for item in user_list2 for x in item]      #合并列表

    user_list2.sort()       #列表排序

    if user_list2[0] == user_list1[1] == user_list1[2]:     #判断三张数字是否相同

        num = user_list1[1][0] * 100000 + zhadan

    elif user_list1[0] == user_list1[2] == user_list1[4] and user_list2[2] - user_list2[1] == user_list2[1] - \

            user_list2[0] == 1:     #判断三张花色是否相同且连号

        num = user_list2[1] * 10000 + shunjin

    elif user_list2[2] - user_list2[1] == user_list2[1] - user_list2[0] == 1:       #判断是否连号

        num = user_list2[1] * 1000 + shunzi

    elif user_list2[0] == user_list2[1] or user_list2[1] == user_list2[2] or user_list2[2] == user_list2[0]:        #判断是否有两个一样的数字

        if user_list2[0] == user_list2[1]:

            num = user_list2[0] * 100 + duizi

        if user_list2[0] == user_list2[2]:

            num = user_list2[2] * 100 + duizi

        if user_list2[2] == user_list2[1]:

            num = user_list2[1] * 100 + duizi

    elif user_list2[0] != user_list2[1] != user_list2[2]:       #最后一种可能，单张

        num = user_list2[2] * 10 + user_list2[1] + danzhang

    return num      #返回计算后的分值

#    定义玩家牌型的底分

zhadan = 100

shunjin = 80

shunzi = 60

duizi = 40

danzhang = 20

gamer = []      #定义新列表，存放玩家数量

gamers = int(input('请输入玩家数量（只能2 - 9名）：'))

if gamers >= 2 and gamers <= 9:        #判断用户输入的人数是否在规定范围内

    for i in range(gamers):  # 玩家数量由用户定义，代表整体循环的次数

        list4 = []  # 用于存储每名玩家随机得到的三张牌

        for j in range(3):

            sun = random.randint(1, len(puke()) - 1)  # 以随机数为扑克整体的下标进行查找对应的牌

            list4.append(puke()[sun])  # 添加进列表

            puke().remove(puke()[sun])  # 把已经发出去的牌在扑克牌整体中进行删除

        print(f'{i + 1}号玩家的底牌：{list4}')

        if i == 0:

            user_1 = func(0)

            gamer.append(user_1)

        elif i == 1:

            user_2 = func(0)

            gamer.append(user_2)

        elif i == 2:

            user_3 = func(0)

            gamer.append(user_3)

        elif i == 3:

            user_4 = func(0)

            gamer.append(user_4)

        elif i == 4:

            user_5 = func(0)

            gamer.append(user_5)

        elif i == 5:

            user_6 = func(0)

            gamer.append(user_6)

        elif i == 6:

            user_7 = func(0)

            gamer.append(user_7)

        elif i == 7:

            user_8 = func(0)

            gamer.append(user_8)

        elif i == 8:

            user_9 = func(0)

            gamer.append(user_9)

else:

    print('你输入的人数不合理，请重新输入。')

old_grade = []       #定义一个新列表，用于存放以玩家排序的分数

new_grade = []         #定义一个新列表，用于存放以大小排序后的分数

for i in gamer:         #遍历玩家分数列表

    old_grade.append(i)

new_grade.extend(old_grade)

old_grade.sort(reverse=True)     #降序排列后的分数列表

user = 1

for j in new_grade:     #遍历玩家顺序的列表

    if j == old_grade[0]:

        print(f'{user}号玩家获胜，得分：{old_grade[0]}')     #最终赢家的分数没有实际意义，仅为了判断最大值

    else:

        user += 1

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

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

class Poker(MutableSequence):

    # 扑克牌的相关定义

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

    suits = 'spades hearts diamonds clubs'.split()  # 黑桃，红桃，方块，梅花

    suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0)#黑桃最大，红桃次之，方块再次之，梅花最小

    def __init__(self):

        self._cards = [Card(rank, suit) for rank in self.ranks

                                           for suit in self.suits]

    def __len__(self):

        return len(self._cards)

    def __getitem__(self, position):  # 仅仅实现了__getitem__方法，该对象就变成可迭代的

        return self._cards[position]

    def __setitem__(self, position, value):

        self._cards[position] = value

    def __delitem__(self, position):

        del self._cards[position]

    def insert(self, position, value):

        self._cards[position] = value

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

Own_Poker = collections.namedtuple('Own_Poker', ['id', 'rank', 'suit', 'score'])

class Player():

    '''

    牌型　　豹子：三张同样大小的牌。　　顺金：花色相同的三张连牌。　　金花：三张花色相同的牌。　

    顺子：三张花色不全相同的连牌。　　对子：三张牌中有两张同样大小的牌。　　单张：除以上牌型的牌。

    '''

    def __init__(self, id, poker):

        self.id = id

        self.poker = poker  #一副扑克牌

        self.pokers = []    #玩家手中的牌

        self.type = 0  # 每个人初始都假定为三张毫无关系的牌，也就是扑克牌赢法中的“单张”

    def set_card_score(self, card):

        '''

        按照点数判定扑克牌的大小

        :param card:扑克牌卡片

        :return:扑克牌点数大小

        '''

        rank_value = Poker.ranks.index(card.rank)

        suit_values = Poker.suit_values

        return rank_value * len(suit_values) + suit_values[card.suit]

    def sort_card_index(self, rank_index_list):

        '''

        通过值减下标的方式分组,如果三个值连续则被分配到同一个g中

        比如说ll=[3,4,5,7,8]，分组时，enumerate(ll)=[(0,3),(1,4),(2,5),(3,7),(4,8)],fun函数值减下标，结果一样的，就归为一组

        在本程序中，如果是三张连续的扑克牌，则应该是同一个g中，此时返回为Ture，否则为False

        :param rank_index_list:

        :return:

        '''

        fun = lambda x: x[1] - x[0]

        for k, g in groupby(enumerate(rank_index_list), fun):  # 返回一个产生按照fun进行分组后的值集合的迭代器.

            if len([v for i, v in g]) == 3:

                return True

        return False

    def judge_type(self):

        '''

        玩家随机发完三张牌后，根据扑克牌玩法进行区分，对手中的牌进行判别属于哪种类型

        :return:

        '''

        suit_list = []

        rank_list = []

        score_list = []

        for poker in self.pokers:

            suit_list.append(poker.suit)

            rank_list.append(poker.rank)

            score_list.append(poker.score)

        rank_index_list = []  # 扑克牌卡片在Poker中rank中的index

        for rank in rank_list:

            index = self.poker.ranks.index(rank)

            rank_index_list.append(index)

        if len(set(rank_list)) == 1:

            self.type = 5  # 豹子

        elif len(set(suit_list)) == 1:

            if self.sort_card_index(rank_index_list):

                self.type = 4  # 顺金

            else:

                self.type = 3  # 金花

        elif self.sort_card_index(rank_index_list):

            self.type = 2  # 顺子

        elif len(set(rank_list)) == 2:

            self.type = 1  # 对子

    def play(self):

        self.judge_type()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

class Winner():

    def __init__(self, player1, player2):

        self.player1 = player1

        self.player2 = player2

    def get_max_card(self, player):

        '''

        筛选出三张牌中最大的牌，这里返回的是在ranks中的index

        :param player:

        :return:

        '''

        ranks = Poker.ranks

        rank_index_list = []  # 扑克牌卡片在Poker中rank中的index

        for poker in player.pokers:

            index = ranks.index(poker.rank)

            rank_index_list.append(index)

        return max(rank_index_list)

    def get_card_suit(self, player):

        '''

        返回扑克牌花色大小

        :param player:

        :return:

        '''

        suit_values = Poker.suit_values

        suit = player.pokers[0].suit

        return suit_values[suit]

    def get_card_value(self, player):

        '''

        当牌型是对子的时候，经过匹配找出是对子的牌和单个的牌，这里返回的是牌的index，便于比较大小

        :param player:

        :return:

        '''

        ranks = Poker.ranks

        rank_index_dict = {}  # 扑克牌卡片在Poker中rank中的index

        repeat_rank_value = 0  # 成对的两张扑克牌的大小

        single_rank_value = 0  # 单个的扑克牌的大小

        for poker in player.pokers:

            index = ranks.index(poker.rank)

            if index in rank_index_dict:

                rank_index_dict[index] += 1

            else:

                rank_index_dict[index] = 1

        rank_index_dict = sorted(rank_index_dict.items(), key=lambda d: d[1], reverse=True)

        n = 0

        for key in rank_index_dict:

            if n == 0:

                repeat_rank_value = key

            else:

                single_rank_value = key

            n += 1

        return repeat_rank_value, single_rank_value

    def get_player_score(self, player):

        '''

        当牌型为单牌时，计算手中的牌相加后的值大小

        :param player:

        :return:

        '''

        ranks = Poker.ranks

        score = 0

        for poker in player.pokers:

            index = ranks.index(poker.rank)  # 扑克牌卡片在Poker中rank中的index

            score += index

        return score

    def get_winner(self):

        player1, player2 = self.player1, self.player2

        # 先比较玩家手中的牌型，大的胜出,玩牌的规则暂时不涉及到牌色，如有修改可以在此基础上调整

        # 豹子> 顺金 > 金花 > 顺子 > 对子 > 单张

        if player1.type > player2.type:

            return player1

        elif player1.type < player2.type:

            return player2

        else:  # 当玩家双方手中的牌型一致时，根据赢法一一判断

            if player1.type == 5 or player1.type == 4 or player1.type == 2:  # 豹子、顺金、顺子 规则说明：按照比点

                if self.get_max_card(player1) > self.get_max_card(player2):

                    return player1

                else:

                    return player2

            elif player1.type == 1:  # 对子 规则说明：先比较相同两张的值的大小，谁大谁胜出；如果对子相同，再比较单个

                repeat_rank_value1, single_rank_value1 = self.get_card_value(player1)

                repeat_rank_value2, single_rank_value2 = self.get_card_value(player1)

                if repeat_rank_value1 > repeat_rank_value2:

                    return player1

                elif repeat_rank_value1 < repeat_rank_value2:

                    return player2

                else:

                    if single_rank_value1 > single_rank_value2:

                        return player1

                    elif single_rank_value1 < single_rank_value2:

                        return player2

                    else:

                        return None  # 平局，大家手上的牌一样大

            else:  # 单牌，金花   规则：比较所有牌的点数大小，不区分牌色

                if self.get_player_score(player1) > self.get_player_score(player2):

                    return player1

                elif self.get_player_score(player1) < self.get_player_score(player2):

                    return player2

                else:

                    return None

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

def compare_card(card1, card2):

    '''

    比较两种扑克牌是否相同

    :param card1:

    :param card2:

    :return: 相同返回为True，否则为False

    '''

    if card1.rank == card2.rank and card1.suit == card2.suit:

        return True

    return False

def dutch_official_work(poker, player1, player2):

    '''

    发牌人（荷官）给两位玩家轮替发牌，发出去的牌都需要从这副扑克牌中剔除出去

    :param poker: 那一副扑克牌

    :param player1:玩家1

    :param player2:玩家2

    :return:整理后的扑克牌

    '''

    def distribute_card(player):

        card = choice(poker)  # 发牌

        player.pokers.append(Own_Poker(player.id, card.rank, card.suit, player.set_card_score(card)))

        for i in range(len(poker)):

            if compare_card(card, poker[i]):

                poker.__delitem__(i)

                break

    shuffle(poker)  # 洗牌

    for k in range(3):

        distribute_card(player1)

        distribute_card(player2)

    return poker