python——扑克牌案列

斗地主发牌程序：
模拟一个斗地主发牌程序，实现对三个玩家进行手牌的派发，实现功能：

********** 欢迎进入 XX 斗地主 **********
请输入玩家姓名：<用户控制台输入 A>
请输入玩家姓名：<用户控制台输入 B>
请输入玩家姓名：<用户控制台输入 C>
洗牌中...
洗牌完成!
发牌中...
发牌完成！
A：<在这里展示 A 的所有手牌，要求按照从小到大的顺序排序，相同点数的情况下，按照黑桃 > 红桃 > 方片 > 梅花的大小关系排列>
B：<在这里展示 B 的所有手牌，要求按照从小到大的顺序排序，相同点数的情况下，按照黑桃 > 红桃 > 方片 > 梅花的大小关系排列>
C：<在这里展示 C 的所有手牌，要求按照从小到大的顺序排序，相同点数的情况下，按照黑桃 > 红桃 > 方片 > 梅花的大小关系排列>
谁叫地主？ <用户控制台输入 A>
地主牌：<在这里展示地主牌，要求按照从小到大的顺序排序，相同点数的情况下，按照黑桃 > 红桃 > 方片 > 梅花的大小关系排列>
A：<在这里展示 A 的所有手牌，要求按照从小到大的顺序排序，相同点数的情况下，按照黑桃 > 红桃 > 方片 > 梅花的大小关系排列>
B：<在这里展示 B 的所有手牌，要求按照从小到大的顺序排序，相同点数的情况下，按照黑桃 > 红桃 > 方片 > 梅花的大小关系排列>
C：<在这里展示 C 的所有手牌，要求按照从小到大的顺序排序，相同点数的情况下，按照黑桃 > 红桃 > 方片 > 梅花的大小关系排列>

解题思路：
1. 需要准备一副扑克牌：
a. 一副扑克牌，本身就是一个数据容器，其中存储了54个扑克牌对象
b. 扑克牌类，需要具有的属性和方法：
ⅰ. 属性：点数、花色
ⅱ. 功能：显示（将自己的点数和花色拼接成一个字符串返回），可以比较大小
c. 扑克牌的点数和花色的类型：
ⅰ. 问题：无法直接通过字符串，比较大小
ⅱ. 解决：自定义数据类型，包含两个属性：呈现效果，权重
d. 顺序生成54张牌
e. 洗牌
2. 发牌
a. 遍历牌堆，依次给每一个玩家发牌
b. 【偷懒】切片，切17张牌给到玩家


import random


class Poker:
	def __init__(self, suit, color, suit_weight, color_weight):
		self.suit = suit
		self.color = color
		self.suit_weight = suit_weight
		self.color_weight = color_weight

	def __repr__(self):
		if self.color != None:
			return f"{self.suit}{self.color}"
		else:
			return f"{self.suit}"


def initPoker():
	poker_list = []
	for i in range(1, 14):
		suit = None
		suit_weight = i
		if i == 1:
			suit = "A"
			suit_weight = 12
		elif i == 2:
			suit = 2
			suit_weight = 13
		elif i == 11:
			suit_weight = 9
			suit = "J"
		elif i == 12:
			suit_weight = 10
			suit = "Q"
		elif i == 13:
			suit_weight = 11
			suit = "K"
		else:
			suit_weight = i - 2
			suit = i
		for k in range(1, 5):
			color = None
			color_weight = k
			match k:
				case 1:
					color = "♠"
				case 2:
					color = "♥"
				case 3:
					color = "♣"
				case 4:
					color = "♦"
			poker_list.append(Poker(suit, color, suit_weight, color_weight))
	poker_list.append(Poker("大王", None, 100, None))
	poker_list.append(Poker("小王", None, 99, None))
	return poker_list


def getThreePlayerName():
	# 输入三个玩家的名字
	s1 = set()
	while True:
		p1 = input("请输入第一个玩家的名字:")
		p2 = input("请输入第二个玩家的名字:")
		p3 = input("请输入第三个玩家的名字:")
		s1.add(p1)
		s1.add(p2)
		s1.add(p3)
		if len(s1) < 3:
			print("输入的玩家有重名的，请重新输入!")
			continue
		else:
			return p1, p2, p3


class Player:

	def __init__(self, name):
		self.name = name
		self.poker_list = list()

	def __repr__(self):
		return f"{self.name}"


# 发牌方法
"""
def send_pokers(self, poker_list: list[Poker], player_list: list[Player]):
	for i in range(17):
		print(player_list[0])

		player_list[0].poker_list.append(poker_list.pop())
		player_list[1].poker_list.append(poker_list.pop())
		player_list[2].poker_list.append(poker_list.pop())
"""



def showAllPlayerPoker(player_list: list[Player]):
	for i in range(len(player_list)):
		player = player_list[i]
		print(f"玩家的名字{player.name}")
		player.poker_list = sorted(player.poker_list, key=lambda poker: (poker.suit_weight, poker.color_weight))
		print(f"玩家的牌是:{player.poker_list}")


# 欢迎界面
def showMainScreen():
	print("**********欢迎进入东湖斗地主**********")
	n1, n2, n3 = getThreePlayerName()
	print(n1, n2, n3)
	playerList:list[Player] = [Player(n1), Player(n2), Player(n3)]
	# 初始化一下牌
	poker_list = initPoker()
	print(poker_list)
	print("洗牌中...")
	random.shuffle(poker_list)
	# 调用洗牌方法
	print("洗牌完成!")
	print(poker_list)
	print("发牌中...")
	# 调用发牌方法
	print(poker_list)
	print(playerList)
	# send_pokers(poker_list, playerList)
	for i in range(17):

		playerList[0].poker_list.append(poker_list.pop())
		playerList[1].poker_list.append(poker_list.pop())
		playerList[2].poker_list.append(poker_list.pop())

	print(poker_list)
	showAllPlayerPoker(playerList)
	# 叫地主
	master = input("谁叫地主?  ")
	if master in (n1, n2, n3):
		print(f"{master}是地主!")
		master_player = None
		for player in playerList:
			if master == player.name:
				master_player = player

		master_player.poker_list += poker_list
	print("**********叫地主结束**********")
	showAllPlayerPoker(playerList)
	print("发牌完成！")


# 调用主方法
showMainScreen()

第二种方法：

"""
    1 创建一个类，Poker 类  点位JQKA  花色   权重  花色权重
    2、主屏幕
    3、初始化一副牌  54张
    3、调用三个玩家的初始化操作  玩家类 Player  属性  name  List存放玩家的牌
    4、洗牌 random.shuffle
    5、发牌  需要一个List[Poker]   使用 pop 冒出来一张，给三个玩家，同时删除这个List中的一张
    6、展示某个玩家的牌
"""
import random


class Poker:
    def __init__(self,suit,color,suit_weight,color_weight):
        self.suit=suit
        self.color=color
        self.suit_weight=suit_weight
        self.color_weight=color_weight

    def __repr__(self):
        # 大小王怎么办？
        if self.color is None:
            return str(self.suit)
        else:
            return self.color+str(self.suit)

# 初始化三个玩家，姓名要不同
def initPlayer():

    s1 = set() # 存储3个玩家的姓名
    # 定义一个List集合，存储各个玩家对象
    initPlayerList = []
    while True:
        name = input(f"请输入第{len(s1)+1}个玩家的姓名（不要重复）:")
        s1.add(name)
        if len(s1) == 3:
            break

    for name in s1:
        initPokerList = []
        player = Player(name,initPokerList)
        initPlayerList.append(player)
    return initPlayerList




class Player:
    def __init__(self,name,list):
        self.name=name
        self.list = list

    def __repr__(self):
        return self.name +",扑克牌是："+ ",".join(self.list)

# 初始化一副牌
def initPoker():
    #54张牌
    initPokerList = []
    for i in range(1,14):
        suit = i
        suit_weight = i
        match i:
            case 1:
                suit = 'A'
                suit_weight = 14
            case 11:
                suit = 'J'
                suit_weight = 9
            case 12:
                suit = 'Q'
                suit_weight = 10
            case 13:
                suit = 'K'
                suit_weight = 11
            case 2:
                suit_weight = 15
            case _:
                suit_weight = i - 2
        for color in ['♥','♠','♦','♣']:
            # 黑桃 > 红桃 > 方片 > 梅花
            color_weight = 0
            match color:
                case '♠':
                    color_weight = 1
                case '♥':
                    color_weight = 2
                case '♦':
                    color_weight = 3
                case '♣':
                    color_weight = 4

            poker = Poker(suit, color, suit_weight,color_weight)
            initPokerList.append(poker)

    initPokerList.append(Poker('大王',None,100,None))
    initPokerList.append(Poker('小王',None,100,None))
    return initPokerList


def showAllPokerByPlayer(player):
    print(f"开始展示{player.name}的所有牌：")
    pokerList = player.list
    # 先将所有的牌排序
    pokerList = sorted(pokerList,key=lambda poker: (poker.suit_weight,poker.color_weight) )
    print(pokerList)

if __name__ == '__main__':
    print("----欢迎来到新澳门葡京娱乐城------")
    playList = initPlayer()
    print(playList)
    pokerList = initPoker()
    print(pokerList)
    # 开始洗牌
    print("洗牌中.....")
    random.shuffle(pokerList)
    print(pokerList)
    print("开始发牌.....")
    for index in range(len(pokerList)-3):
        poker = pokerList.pop()
        player = playList[index % 3]
        player.list.append(poker)



    # 先叫地主
    name = input("叫地主:")
    for player in playList:
        if player.name == name:
            print(f"{name}是地主")
            # 两个list的合并
            player.list += pokerList

    # 展示所有的底牌
    # 展示所有人的牌
    print("展示所有玩家的牌....")
    for player in playList:
        showAllPokerByPlayer(player)