斗地主发牌程序：
模拟一个斗地主发牌程序，实现对三个玩家进行手牌的派发，实现功能：
********** 欢迎进入 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)