德州扑克和双倍下注python

1. 德州扑克的赢率
   从52张（不包括大小王）扑克牌中任意选取5张牌。

1. 使用模拟（simulation）的方法，估算五张牌是同样花色的几率。
2. 使用模拟的方法，估算五张牌是顺子的几率。（提示：先排序可能会方便一些）
3. (Optional) 如果仍然有时间，使用模拟的方法，估算下列牌型发生的几率：
   一对加三个单张，两对，相同的三张加两个单张，5张的顺子但不是同花，5张的同花但不是顺子，相同的三张加一对，有相同的4张，是5张的同花顺
   提示：可以考虑使用如下的模拟方法：从1-52整数中不放回的随机抽取5个整数，如果抽取的数是1-13，则认为是黑桃A2-K，如果是14-26，则认为是红桃A2-K，以此类推。

import random


class Poker:
    def __init__(self):
        self.pai = [i for i in range(1, 53)]
        print(self.pai)

    def huase(self, pai):
        # 红桃 0 黑桃 1 方块 2 梅花 3
        if pai <= 13:
            return 0
        elif 13 < pai <= 26:
            return 1
        elif 26 < pai <= 38:
            return 2
        else:
            return 3

    def choupai(self, number):
        b = self.pai
        random.shuffle(b)
        # print("抽牌如下: ", b[0:number])
        return b[0:number]

    def huaseshu(self, pais):
        temp = []
        for i in pais:
            a = self.huase(i)
            if a not in temp:
                temp.append(a)
        # print("花色数为: ", len(temp))
        return len(temp)
    def shunzi(self, pais):
        only_num = []
        for i in pais:
            only_num.append(int(i % 13))
        only_num.sort()
        k = 0
        for j in range(1, 5):
            if only_num[j] - only_num[j - 1] == 0:
                return False
        return only_num[-1] - only_num[0] == 4

if __name__ == '__main__':
    p = Poker()

    # 1)	使用模拟（simulation）的方法，估算五张牌是同样花色的几率。
    n = 10000  # 模拟10000次
    times = 0  # 同样花色次数
    for i in range(n):
        pai = p.choupai(5)
        if p.huaseshu(pai) == 1:
            times += 1
    print("五张牌是同样花色的几率为: ", times * 1.0 / n)

    shunzi = 0
    for i in range(n):
        pai = p.choupai(5)
        if p.shunzi(pai):
            shunzi += 1
    print("五张牌是顺子的几率为: ", shunzi * 1.0 / n)

2. 双倍下注（Double Down）策略的盈亏
   一个游戏，每玩一次耗时1分钟。赢的几率为p，如果赢了，则压上的资金翻倍。如果输了。则压上的资金全部输掉。考虑下述的所谓双倍下注策略。

1. 第一次压上1元钱，如果输了，则压上2元，如果又输了，则压上4元。每次压上上次一倍的钱，知道赢了为止。
2. 如果赢了，则下次压上1元，重复上面1）
3. 如果钱全部输光，则结束整个游戏。
4. 如果剩下的钱不够1）中所需要的，则全部压上。
5. 总共最多玩事先给定的时间，到时则结束整个游戏。

创建一个函数，给定初始资金N，赢的几率p，最多玩的时间M分钟，使用模拟（simulation）的方法，估算上述策略的平均盈亏。
提示：可以考虑使用如下的模拟方法：在0-1之间抽取一个随机的浮点数，如果小于p， 则认为赢。

# 一个游戏，每玩一次耗时1分钟。赢的几率为p，如果赢了，则压上的资金翻倍。如果输了。
# 则压上的资金全部输掉。考虑下述的所谓双倍下注策略。
# 1)	第一次压上1元钱，如果输了，则压上2元，如果又输了，则压上4元。每次压上上次一倍的钱，知道赢了为止。
# 2)	如果赢了，则下次压上1元，重复上面1）
# 3)	如果钱全部输光，则结束整个游戏。
# 4)	如果剩下的钱不够1）中所需要的，则全部压上。
# 5)	总共最多玩事先给定的时间，到时则结束整个游戏。
#
# 创建一个函数，给定初始资金N，赢的几率p，最多玩的时间M分钟，使用模拟（simulation）的方法，估算上述策略的平均盈亏。
# 提示：可以考虑使用如下的模拟方法：在0-1之间抽取一个随机的浮点数，如果小于p， 则认为赢。
import random


class Game:
    def __init__(self, N, p, M): # 初始资金N，赢的几率p，最多玩的时间M分钟
        self.N = N
        self.p = p
        self.M = M
        print(f"初始资金{N}，赢的几率{p}，最多玩的时间{M}分钟")

    def is_win(self):
        a = random.random()
        return a < self.p

    def play(self):
        xiazhu = 1
        for i in range(self.M):
            if self.N == 0:
                print("输光了")
                return 0
            if self.N - xiazhu < 0:
                xiazhu = self.N
            self.N -= xiazhu
            if self.is_win():
                self.N += xiazhu * 2
                xiazhu = 1
            else:
                xiazhu *= 2
        print("结束, 最终资金为: ", self.N)
        return self.N


if __name__ == '__main__':
    g = Game(1000, 0.5, 200)
    g.play()

    g = Game(2000, 0.6, 200)
    g.play()