扑克玩法:9点半–数据分析

扑克玩法:9点半--数据分析
一、前言
又是新的一年,在这里先给各位读者大大们拜个晚年。祝大家新年快乐,万事如意,阖家欢乐。
过年拜年是中国的传统习俗,在春节期间人们会互相拜访并送上祝福。拜年不仅是一项重要的社交活动,也是一次难忘的旅程。它让我们感受到了团圆与温暖,同时也增强了彼此之间的联系。
小编每年大年初一都会去祖母那儿拜年,一起去的还有我的叔叔、堂兄弟们。我们一般上午到,互相拜个年,寒暄一阵,拉拉家常。由于去的人比较多,一般会待到下午4,5点钟。闲来无事,大伙便会找些事情打发下时间,由于扑克牌几乎家家常备,而且玩法多样也简单,于是大年初一打牌就成了我们一个保留节目。
我们玩的最多的一种玩法是9点半,这是一种我们家乡的玩法,至于是不是特有的就不得而知了。玩的也不大,主要是娱乐,这种玩法人越多,越有意思,越刺激。气氛也就越活跃。
我虽然也是从小玩到大,前些年还经常赢,不过最近几年老是输,已经当了好几年的“输记”了。今年正好有空,于是想通过Python来分析一下9点半这种玩法点数情况。
首先介绍一下这种玩法。如果只想看代码的,请跳过下面的规则介绍。
温馨提示:未成年人禁止赌bo。
1.1 9点半玩法规则
简单的介绍一下这种玩法的规则。
1.1.1 流程
将一副扑克牌中的大小王去除,剩下52张牌。洗牌并切牌并放好。
回合开始,如果桌面上没有筹码了,则每人将商量好的一定数额的筹码放置在桌上。作为启动筹码。
所有玩家按照顺序进行抓牌(每次抓一张),当每人抓完2张牌后计算各自计算自己的点数(点数计算规则见下方)。
所有玩家按照抓牌的顺序依次发声,此时发声人员可以根据自己手牌的点数和位置决定自己要不要桌上的筹码,如果自认为自己的手牌是这一回合中最大的,则可以大喊一声:我要了,并将自己的手牌盖到桌上的筹码上(切不可展示手牌)。表明自己要了所有的筹码。完成叫牌。如果点数不大,没有希望赢的话,则可以说:不要。跳过自己的回合。所以这个玩法又叫“要不要”。
后续有未发声的人员,如果自认为手牌比之前叫牌的玩家还要大,则可以说一声:连了或讨了,之前叫牌玩家则必须将筹码放到桌面上,筹码的数量等于桌面上的筹码数量。连了的玩家也要上桌面上等额的筹码。后续还有未发声的玩家或已发声但是叫牌了的玩家也是同样操作。而那些跳过自己回合的玩家则不能参与。
一直持续上一步,直到没有玩家连了为止。
回合结算,所有玩家都摊开手牌,直接对比点数,如果最后一个连了的玩家的手牌最大,那么他将赢者通吃,将桌面上所有的筹码全部拿走。如果点数不是最大,那么该玩家则不进行任何操作。这回合中点数最大的参与叫牌的玩家,将拿走他之前上的筹码的2倍。桌上剩下的筹码作为下一回合开始后的启动筹码。
第4步时,如果其它玩家都不要,那么就都摊开手牌,对比点数。如果叫牌玩家的点数是这一回合中最大的,则叫牌玩家可以拿走桌上的全部筹码。否则,这一回合中谁的点数最大,谁就在下一回合先抓牌。
回合结束,下一回合开始
1.1.2 计算手牌大小
每回合中,每人摸2张牌,将摸到的牌进行相加计算点数,看谁的点数大。
在算点数时,J、Q、K算半点,A算1点,其它扑克牌按照自身的点数计算。
如果两张牌的点数加在一起,超过10点的要减去10点。
特别地,如果是10点,则被称为“闭十”,也就是0点,是最小的点数。所以我们这边”闭十”也有一种骂人很菜、很差劲的意思。
如果两张牌一样,则称为对子,并且如果颜色也一样(比如都是黑色),则称为“健对子”(真对子),否则称为“万对子”(假对子)。
手牌大小比较:真对子 > 假对子 > 点数
特殊的:如果都是一样大小的真对子,则根据当时是白天还是晚上来区分大小,即:白天时,红色的真对子 > 黑色的真对子,晚上时,黑色的真对子 > 红色的真对子。这个规则也被称为“日红夜黑”。
所以一般情况下,在没有玩家摸到对子的时候,本回合中最大的点数就是9点半了,这也是这个玩法名字的由来。
1.1.3 其它
如果有2位玩家的手牌都很大,那么经过几次的叫牌,桌上的筹码很快会多起来。筹码一多,所有的玩家就都会兴奋起来。叫牌的想赢筹码,没叫牌的也有机会,希望叫牌的人能相互杠上,只要不是最后一个叫牌的人最大,那么桌上总有一半的筹码会留到下一回合。
如果参与的玩家比较多,那么前面叫牌的玩家很容易被后面的玩家杠上,点数不小于叫牌的玩家,但是因为有人叫牌,自己又不敢乱动。于是,桌上更容易因为杠上导致筹码越来越多。
有的玩家在叫牌时会很大声,上筹码时比较用力,以表明自己这一回合志在必得,不管牌大牌小,气势上不能输。但是这种情况也有可能是在虚张声势,让后面的玩家不敢轻举妄动。有的玩家在叫牌时小心翼翼,动作也比较轻,反而有可能手握大牌,所以在玩这个9点半时一定要考虑每个玩家的性格。不要被忽悠了,导致大牌不敢要。
二、代码

# Encoding: utf-8  
# Author: 思必得  
# Date: 2023-01-24 10:02  
# Project name: FrbPythonFiles  
# IDE: PyCharm  
# File name: main  
# 模块说明:  
"""  
"""  
# 模块导入  
from paPath.mdTxt import csNovel  
from mdTools import ftDecTimeIt  
from threading import Thread  
from tqdm import trange  
import random  
import pickle  
import os  
# 更新日志:  
"""  
1、2023-01-24:  
    a、创建文件  
"""  
# 待修改:  
"""  
"""  
novel = csNovel()  


class csHalfPastNine:  
    def __init__(self, pmPersons=5, pmTimes=3):  
        self.abCards = []  
        self.abPersons = pmPersons  
        self.abTimes = pmTimes  
        self.abResult = []  

    def _CreatCards(self):  
        self.abCards = [f'{x}{y}' for x in tuple('234567890JQKA') for y in tuple('rb')] * 2  
        return self.abCards  

    def _ShuffleCards(self):  
        random.shuffle(self.abCards)  
        return self.abCards  

    def _thTakeCards(self):  
        self._CreatCards()  
        Cards = self._ShuffleCards()  
        while len(Cards) >= self.abPersons * 2:  
            group = [(Cards[_], Cards[_ + self.abPersons]) for _ in range(self.abPersons)]  
            self.abResult.append(group)  
            Cards = Cards[self.abPersons * 2:]  

    def _TakeCards(self):  
        threads = []  
        for _ in trange(self.abTimes):  
            t = Thread(target=self._thTakeCards, args=())  
            threads.append(t)  
            t.start()  
        for _ in threads:  
            _.join()  # 如果执行了join代码,则主线程会等待所有的子线程全部执行完毕后才会执行后面的代码。  
        return self.abResult  

    def _DataPersistence(self):  
        data = {self.abPersons: self.abPersons, self.abTimes: self.abTimes, 'Datas': self.abResult}  
        with open(f'data-{self.abPersons}-{self.abTimes}.pik', 'wb') as f:  
            pickle.dump(data, f)  

    def _GetDataFromFile(self):  
        with open(f'data-{self.abPersons}-{self.abTimes}.pik', 'rb') as f:  
            return pickle.load(f)['Datas']  

    @ftDecTimeIt(1)  
    def mtCreatResult(self):  
        hpn._TakeCards()  
        hpn._DataPersistence()  
        return self.abResult  

    def _IsPair(self, pmCards: tuple):  # pmCards:('Kr', '6b')  
        if pmCards[0][0] != pmCards[1][0]:  
            return 0  
        return 2 if pmCards[0][1] == pmCards[1][1] else 1  

    def _Point(self, pmCards: tuple):  # pmCards:('Kr', '6b') --> 6.5  
        if self._IsPair(pmCards):  
            return -1  
        if pmCards[0][0] in ('J', 'Q', 'K'):  
            point1 = 0.5  
        elif pmCards[0][0] == 'A':  
            point1 = 1  
        else:  
            point1 = int(pmCards[0][0])  
        if pmCards[1][0] in ('J', 'Q', 'K'):  
            point2 = 0.5  
        elif pmCards[1][0] == 'A':  
            point2 = 1  
        else:  
            point2 = int(pmCards[1][0])  
        point_temp = point1 + point2  
        return point_temp if point_temp < 10 else point_temp - 10  

    def _CombinationFormat(self, pmCards: tuple):  # pmCards:('Kr', '6b') --> K6  
        dct = {'2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '0': 10, 'J': 11, 'Q': 12, 'K': 13, 'A': 14}  
        one = pmCards[0][0]  
        two = pmCards[1][0]  
        return one + two if dct[one] > dct[two] else two + one  

    def _AvgPoint(self, pmCards: list):  # pmCards:[('Kr', '6b'), ('6r', '5r'), ('2b', '9r'), ('7b', '5r'), ('7r', '4b')]  -->  2.3  
        points = [self._Point(card) for card in pmCards if self._Point(card) != -1]  
        avg_point = sum(points) / len(points)  
        return float(str(avg_point)[:5])  

    def _MaxPoint(self, pmCards: list):  # pmCards:[('Kr', '6b'), ('6r', '5r'), ('2b', '9r'), ('7b', '5r'), ('7r', '4b')]  -->  6.5  
        points = [self._Point(card) for card in pmCards if self._Point(card) != -1]  
        return max(points)  

    def _MinPoint(self, pmCards: list):  # pmCards:[('Kr', '6b'), ('6r', '5r'), ('2b', '9r'), ('7b', '5r'), ('7r', '4b')] -->  1  
        points = [self._Point(card) for card in pmCards if self._Point(card) != -1]  
        return min(points)  

    def mtAnalysisResult(self):  
        datas = self._GetDataFromFile()  
        datas_len = len(datas)  
        datas_num = datas_len * self.abPersons  
        result = {'总数据量': datas_num, '回合数': datas_len}  
        pair_num = 0  # 对子数量  
        pair_false_num = 0  # 假对子数量  
        min_points = []  # 每一回合中最小的点数  
        max_points = []  # 每一回合中最大的点数,不包括对子  
        avg_points = []  # 每一回合中平均的点数,不统计对子  
        round_pairs_num = []  # 每一回合中出现对子的数量,包括真对子和假对子  
        points = []  # 每一回合,每一个人摸到的所有的点数集合  
        pairs = []  # 所有的对子  
        combinations = []  # 所有的组合情况  
        # 按回合分析  
        for index in trange(datas_len):  # [('Kr', '6b'), ('6r', '5r'), ('2b', '9r'), ('7b', '5r'), ('7r', '4b')]  
            min_points.append(self._MinPoint(datas[index]))  
            max_points.append(self._MaxPoint(datas[index]))  
            avg_points.append(self._AvgPoint(datas[index]))  
            round_pairs_num.append(sum(1 for _ in datas[index] if self._IsPair(_)))  
            # 分析所有  
            for _ in datas[index]:  
                if self._IsPair(_):  
                    if _[1][1] == 'r':  
                        pairs.append(_[1] + _[0])  
                    else:  
                        pairs.append(_[0] + _[1])  
                    pair_num += 1  
                    if self._IsPair(_) == 1:  
                        pair_false_num += 1  
                points.append(self._Point(_))  
                combinations.append(self._CombinationFormat(_))  

        # 按回合显示  
        print('每回合中最小点数')  
        novel.mtShowWordsFrequency(min_points, 'o', 0, '-', 0)  
        print('每回合中最大点数')  
        novel.mtShowWordsFrequency(max_points, 'o', 0, '-', 0)  
        print('每回合中平均点数')  
        novel.mtShowWordsFrequency(avg_points, 'o', 0, '-', 0)  
        print('每回合中对子数')  
        novel.mtShowWordsFrequency(round_pairs_num, 'o', 0, '-', 0)  

        # 显示所有  
        print('显示所有的点数')  
        novel.mtShowWordsFrequency(points, 'o', 0, '-', 0)  
        print('显示所有的对子')  
        novel.mtShowWordsFrequency(pairs, 'o', 0, '-', 0)  
        print('显示所有的组合')  
        novel.mtShowWordsFrequency(combinations, 'o', 0, '-', 0)  

        pair_true_num = pair_num - pair_false_num  # 真对子数量  
        result['对子数'] = pair_num  
        result['真对子数'] = pair_true_num  
        result['假对子数'] = pair_false_num  
        result['非对子数'] = datas_num - pair_num  

        print(result)  
        return result  


if __name__ == '__main__':  
    os.chdir(r'E:\\')  
    hpn = csHalfPastNine(pmPersons=5, pmTimes=400000)  
    # hpn.mtCreatResult()  
    hpn.mtAnalysisResult()

三、结果及分析
上面的代码中,分析了40万副扑克牌,玩家数设置为5,一共产生了200万回合的结果。每个回合有5次结果。总共1千万次的手牌结果。
以下为这些数据的分析结果:
3.1 每回合中最小点数
******* 开始显示柱图 *******
序号 其它 频数 占比 柱图
1 1 548917 27.4% ----------------------------
2 0 439892 22.0% ----------------------
3 0.5 275474 13.8% --------------
4 2 156956 7.8% --------
5 1.5 153814 7.7% -------
6 3 118684 5.9% ------
7 2.5 98237 4.9% -----
8 3.5 53933 2.7% --
9 4 52837 2.6% --
10 5 32960 1.6% -
11 4.5 30136 1.5% -
12 5.5 12983 0.6%
13 6 11612 0.6%
14 6.5 5414 0.3%
15 7 5260 0.3%
16 7.5 1462 0.1%
17 8 983 0.0%
18 8.5 282 0.0%
19 9 152 0.0%
20 9.5 12 0.0%
******* 结束显示柱图 *******
上述是统计每回合中最小点数出现的频次以及占比(忽略对子)。可以看到每回合中出现的最小点数最大概率的是1点,其次是0点和0.5点。加起来占比超过62%。
从5.5开始,随着点数的增大,出现的频次和占比也变小了。
3.2 每回合中最大点数
******* 开始显示柱图 *******
序号 其它 频数 占比 柱图
1 9 456833 22.8% -----------------------
2 9.5 342601 17.1% -----------------
3 8 242359 12.1% ------------
4 8.5 225195 11.3% -----------
5 7 192775 9.6% ----------
6 7.5 150197 7.5% -------
7 6 92659 4.6% ----
8 6.5 89515 4.5% ----
9 5 64089 3.2% ---
10 5.5 53104 2.7% --
11 4.5 25999 1.3% -
12 4 25993 1.3% -
13 3 14093 0.7%
14 3.5 12915 0.6%
15 2.5 4558 0.2%
16 2 3990 0.2%
17 1.0 1531 0.1%
18 1.5 1474 0.1%
19 0.5 98 0.0%
20 0 22 0.0%
******* 结束显示柱图 *******
上述是统计每回合中最大点数出现的频次以及占比(忽略对子)。可以看到每回合中出现的最大点数最大概率的是9点,其次是9.5点、8点和8.5点。加起来占比超过63%。
5个玩家的情况下,在每一回合中,点数超过8点概率居然超过了63%,比实际感受上要高。看来下次要注意了。
3.3 每回合中平均点数
******* 开始显示柱图 *******
序号 其它 频数 占比 柱图
1 4.5 61317 3.1% ----
2 5.0 59155 3.0% ---
3 4.0 56934 2.8% ---
4 5.5 49931 2.5% ---
5 3.5 46309 2.3% ---
6 4.6 43762 2.2% --
7 4.4 43642 2.2% --
8 4.7 43520 2.2% --
9 4.8 43456 2.2% --
10 4.3 43179 2.2% --
11 4.9 42668 2.1% --
12 4.2 42310 2.1% --
13 4.1 41714 2.1% --
14 5.1 40747 2.0% --
15 5.2 39895 2.0% --
16 3.9 39056 2.0% --
17 5.3 38194 1.9% --
18 3.8 37665 1.9% --
19 6.0 37322 1.9% --
20 5.4 36494 1.8% --
21 3.7 35950 1.8% --
22 3.6 34140 1.7% --
23 5.6 33493 1.7% --
24 3.0 33458 1.7% --
25 5.7 31521 1.6% --
26 3.4 30602 1.5% --
27 5.8 29619 1.5% -
28 3.3 28629 1.4% -
29 5.9 27790 1.4% -
30 3.2 26488 1.3% -
31 6.5 24506 1.2% -
32 3.1 24238 1.2% -
33 6.1 23666 1.2% -
34 6.2 21973 1.1% -
35 2.5 20796 1.0% -
36 2.9 20766 1.0% -
37 6.3 19610 1.0% -
38 2.8 18678 0.9% -
39 6.4 18022 0.9% -
40 2.7 16799 0.8% -
41 4.625 15339 0.8% -
42 4.75 15194 0.8% -
43 4.25 15059 0.8% -
44 4.375 14972 0.7% -
45 4.875 14945 0.7%
46 2.6 14823 0.7%
47 4.125 14702 0.7%
48 6.6 14279 0.7%
49 5.125 14260 0.7%
50 7.0 13958 0.7%
51 5.25 13779 0.7%
52 3.875 13731 0.7%
53 3.75 13420 0.7%
54 5.375 13276 0.7%
55 6.7 12875 0.6%
56 3.625 12617 0.6%
57 5.625 12113 0.6%
58 2.4 11854 0.6%
59 5.75 11552 0.6%
60 3.375 11455 0.6%
61 6.8 11312 0.6%
62 2.0 11031 0.6%
63 3.25 10798 0.5%
64 5.875 10620 0.5%
65 2.3 10381 0.5%
66 6.9 9995 0.5%
67 3.125 9781 0.5%
68 6.125 9332 0.5%
69 2.2 8936 0.4%
70 6.25 8675 0.4%
71 2.875 8379 0.4%
72 2.1 7761 0.4%
73 2.75 7731 0.4%
74 6.375 7698 0.4%
75 7.1 7484 0.4%
76 2.625 6875 0.3%
77 7.5 6798 0.3%
78 7.2 6396 0.3%
79 6.625 6250 0.3%
80 6.75 5663 0.3%
81 1.9 5540 0.3%
82 7.3 5501 0.3%
83 2.375 5236 0.3%
84 6.875 5073 0.3%
85 1.5 4841 0.2%
86 2.25 4730 0.2%
87 1.8 4642 0.2%
88 7.4 4492 0.2%
89 2.125 4095 0.2%
90 1.7 3843 0.2%
91 7.125 3791 0.2%
92 7.25 3224 0.2%
93 7.6 3186 0.2%
94 1.6 3082 0.2%
95 1.875 2871 0.1%
96 8.0 2787 0.1%
97 7.375 2710 0.1%
98 1.75 2614 0.1%
99 7.7 2610 0.1%
100 4.166 2194 0.1%
101 4.333 2148 0.1%
102 1.625 2132 0.1%
103 7.8 2111 0.1%
104 4.666 2111 0.1%
105 4.833 2110 0.1%
106 3.833 2086 0.1%
107 3.666 2077 0.1%
108 1.4 2063 0.1%
109 5.166 2035 0.1%
110 5.333 1999 0.1%
111 7.625 1902 0.1%
112 3.333 1868 0.1%
113 1.0 1798 0.1%
114 5.833 1788 0.1%
115 5.666 1779 0.1%
116 7.75 1663 0.1%
117 3.166 1661 0.1%
118 7.9 1642 0.1%
119 1.3 1615 0.1%
120 6.166 1565 0.1%
121 1.375 1351 0.1%
122 2.833 1339 0.1%
123 6.333 1299 0.1%
124 2.666 1292 0.1%
125 1.2 1239 0.1%
126 7.875 1217 0.1%
127 1.25 1164 0.1%
128 6.666 1084 0.1%
129 8.1 1069 0.1%
130 2.333 1019 0.1%
131 6.833 1012 0.1%
132 1.1 932 0.0%
133 8.5 904 0.0%
134 1.125 893 0.0%
135 2.166 870 0.0%
136 8.2 849 0.0%
137 8.125 821 0.0%
138 7.166 820 0.0%
139 8.25 752 0.0%
140 7.333 643 0.0%
141 1.833 633 0.0%
142 8.3 569 0.0%
143 1.666 567 0.0%
144 0.9 558 0.0%
145 7.666 504 0.0%
146 8.375 495 0.0%
147 8.4 479 0.0%
148 0.875 468 0.0%
149 0.75 426 0.0%
150 1.333 423 0.0%
151 7.833 422 0.0%
152 0.5 378 0.0%
153 0.8 372 0.0%
154 1.166 319 0.0%
155 8.625 277 0.0%
156 8.166 276 0.0%
157 0.625 253 0.0%
158 8.6 232 0.0%
159 0.7 223 0.0%
160 9.0 210 0.0%
161 0.833 202 0.0%
162 8.75 196 0.0%
163 8.333 194 0.0%
164 0.666 162 0.0%
165 0.6 157 0.0%
166 8.7 130 0.0%
167 8.875 121 0.0%
168 8.666 118 0.0%
169 8.8 94 0.0%
170 8.833 93 0.0%
171 0.375 78 0.0%
172 8.9 68 0.0%
173 0.25 60 0.0%
174 0.333 55 0.0%
175 0.4 54 0.0%
176 9.125 36 0.0%
177 9.166 36 0.0%
178 9.25 30 0.0%
179 0.166 23 0.0%
180 0.0 22 0.0%
181 0.3 21 0.0%
182 9.1 16 0.0%
183 0.125 15 0.0%
184 9.5 12 0.0%
185 9.333 10 0.0%
186 0.2 4 0.0%
187 9.2 4 0.0%
188 9.375 4 0.0%
189 0.1 3 0.0%
190 9.3 1 0.0%
******* 结束显示柱图 *******
上述是统计每回合中平均点数出现的频次以及占比(忽略对子)。可以看到每回合中出现的平均点数最大概率的是4.5点,其次是5点、4点、5.5点和3.5点。平均点数在3.5和5.5之间占比超过55%。也就是5个玩家的情况下,所有人点数的平均值有一半会落在3.5到5.5之间。
3.4 每回合中对子数
******* 开始显示柱图 *******
序号 其它 频数 占比 柱图
1 0 1477940 73.9% --------------------------------------------------------------------------
2 1 460232 23.0% -----------------------
3 2 58058 2.9% --
4 3 3661 0.2%
5 4 109 0.0%
******* 结束显示柱图 *******
5个玩家的情况下,每回合出现对子的概率超过了1/4,这个概率比比较高了。怪不得在玩的时候经常看到有对子的情况。
3.5 显示所有的点数
******* 开始显示柱图 *******
序号 其它 频数 占比 柱图
1 1 966269 9.7% ----------
2 3 603931 6.0% ------
3 9 603134 6.0% ------
4 5 603060 6.0% ------
5 7 601309 6.0% ------
6 -1 587767 5.9% ------
7 4 483980 4.8% -----
8 2 483045 4.8% -----
9 0 482978 4.8% -----
10 6 482881 4.8% -----
11 8 482740 4.8% -----
12 4.5 362268 3.6% ----
13 6.5 362241 3.6% ----
14 8.5 362057 3.6% ----
15 3.5 362051 3.6% ----
16 1.5 361990 3.6% ----
17 2.5 361895 3.6% ----
18 9.5 361890 3.6% ----
19 0.5 361642 3.6% ----
20 7.5 361508 3.6% ----
21 5.5 361364 3.6% ----
这个结果就比较有意思了,大致可以看到有4档。1点是独一档,占比最高。这应该是由于组成1点的组合最多造成的。第2档就是其它基数整数点和所有的对子数(-1)。第3档就是所有的偶数整数点。第4档就是所有的非整数点。
3.6 显示所有的对子
******* 开始显示柱图 *******
序号 其它 频数 占比 柱图
1 7r7b 30490 5.2% ------
2 8r8b 30460 5.2% ------
3 0r0b 30430 5.2% ------
4 4r4b 30305 5.2% ------
5 JrJb 30264 5.1% ------
6 ArAb 30211 5.1% ------
7 KrKb 30188 5.1% ------
8 3r3b 30177 5.1% ------
9 QrQb 30055 5.1% ------
10 2r2b 30037 5.1% ------
11 5r5b 30022 5.1% ------
12 6r6b 29975 5.1% ------
13 9r9b 29866 5.1% ------
14 0r0r 7635 1.3% -
15 ArAr 7623 1.3% -
16 5b5b 7612 1.3% -
17 9r9r 7602 1.3% -
18 7b7b 7590 1.3% -
19 JbJb 7573 1.3% -
20 QrQr 7558 1.3% -
21 9b9b 7556 1.3% -
22 KbKb 7539 1.3% -
23 JrJr 7527 1.3% -
24 6b6b 7527 1.3% -
25 3b3b 7522 1.3% -
26 5r5r 7518 1.3% -
27 8b8b 7518 1.3% -
28 4r4r 7517 1.3% -
29 0b0b 7486 1.3% -
30 QbQb 7481 1.3% -
31 7r7r 7477 1.3% -
32 KrKr 7459 1.3% -
33 8r8r 7458 1.3% -
34 AbAb 7450 1.3% -
35 2r2r 7446 1.3% -
36 4b4b 7437 1.3% -
37 3r3r 7437 1.3% -
38 6r6r 7390 1.3% -
39 2b2b 7349 1.3% -
******* 结束显示柱图 *******
至于所有的对子,可以看到分为2档,假对子的概率是真对子概率的约4倍。
3.7 显示所有的组合
******* 开始显示柱图 *******
序号 其它 频数 占比 柱图
1 KQ 121415 1.2% --
2 AJ 121258 1.2% --
3 75 121246 1.2% --
4 95 121224 1.2% --
5 Q3 121171 1.2% --
6 92 121164 1.2% --
7 73 121140 1.2% --
8 K6 121117 1.2% --
9 63 121053 1.2% --
10 A5 121046 1.2% --
11 02 121028 1.2% --
12 32 120991 1.2% --
13 94 120989 1.2% --
14 Q4 120988 1.2% --
15 08 120978 1.2% --
16 A3 120965 1.2% --
17 J2 120947 1.2% --
18 J9 120935 1.2% --
19 86 120931 1.2% --
20 62 120929 1.2% --
21 Q0 120922 1.2% --
22 65 120918 1.2% --
23 03 120918 1.2% --
24 A8 120869 1.2% --
25 04 120860 1.2% --
26 85 120829 1.2% --
27 K5 120815 1.2% --
28 K4 120793 1.2% --
29 97 120793 1.2% --
30 J3 120789 1.2% --
31 42 120784 1.2% --
32 74 120783 1.2% --
33 KJ 120776 1.2% --
34 05 120756 1.2% --
35 K8 120756 1.2% --
36 Q8 120744 1.2% --
37 J6 120694 1.2% --
38 A2 120687 1.2% --
39 64 120683 1.2% --
40 A9 120646 1.2% --
41 A7 120636 1.2% --
42 K2 120633 1.2% --
43 K7 120606 1.2% --
44 98 120606 1.2% --
45 A4 120592 1.2% --
46 J8 120557 1.2% --
47 72 120547 1.2% --
48 Q7 120536 1.2% --
49 82 120509 1.2% --
50 76 120508 1.2% --
51 Q9 120502 1.2% --
52 J4 120487 1.2% --
53 J0 120485 1.2% --
54 54 120477 1.2% --
55 83 120465 1.2% --
56 Q5 120465 1.2% --
57 K9 120453 1.2% --
58 96 120447 1.2% --
59 84 120441 1.2% --
60 Q6 120430 1.2% --
61 QJ 120416 1.2% --
62 AQ 120413 1.2% --
63 J7 120366 1.2% --
64 52 120344 1.2% --
65 A0 120332 1.2% --
66 93 120330 1.2% --
67 AK 120319 1.2% --
68 Q2 120315 1.2% --
69 87 120274 1.2% --
70 06 120258 1.2% --
71 K0 120235 1.2% --
72 07 120214 1.2% --
73 53 120197 1.2% --
74 09 120188 1.2% --
75 A6 120186 1.2% --
76 K3 120091 1.2% --
77 J5 120084 1.2% --
78 43 119959 1.2% --
79 77 45557 0.5%
80 00 45551 0.5%
81 88 45436 0.5%
82 JJ 45364 0.5%
83 AA 45284 0.5%
84 44 45259 0.5%
85 KK 45186 0.5%
86 55 45152 0.5%
87 33 45136 0.5%
88 QQ 45094 0.5%
89 99 45024 0.5%
90 66 44892 0.4%
91 22 44832 0.4%
******* 结束显示柱图 *******
由于数据量比较大,各种组合出现的概率还是十分均匀的。对子出现的概率为0.5%,其它任何一种非对子的概率为1.2%。

本站文章如无特殊说明,均为本站原创,如若转载,请注明出处:扑克玩法:9点半–数据分析 - Python技术站

(0)
上一篇 2023年3月31日 下午9:08
下一篇 2023年3月31日 下午9:08

相关文章

  • 数字(number)

    4.2 数字(number) Python中数字类型有4种: 整型(int) 布尔型(bool) 浮点数(float) 复数(complex) 4.2.1 整型(int) 形如:1、233、-6、69这样的数据都是整型。1、在Python3中只有一种整型int,表示长整型,没有Python2中的long。2、理论上Python3中的int类型可以表示无限大的…

    Python开发 2023年4月2日
    00
  • 元组(tuple)

    4.5 元组(tuple) 元组这种数据类型和列表非常相似,也是一种序列。和列表的不同之处在于存放到元组内的数据不能直接修改。元组是一种可迭代对象。使用元组可以使程序运行性能提升,因为一般来说,创建元组类型tuple的变量比列表类型list要快,而且占用更小的存储空间。 4.5.1 元组的创建 4.5.1.1 通过逗号创建 >>> tup1…

    Python开发 2023年4月2日
    00
  • Python函数

    5.1 函数相关基础概念 5.1.1 函数是什么 函数是指一段可以直接被另一段程序或代码引用的程序或代码。也叫做子程序、(OOP中)方法。一个较大的程序一般应分为若干个程序块,每一个模块用来实现一个特定的功能。所有的高级语言中都有子程序这个概念,用子程序实现模块的功能。在程序设计中,常将一些常用的功能模块编写成函数,放在函数库中供公共选用。开发者要善于利用函…

    Python开发 2023年4月2日
    00
  • 类型转换及相关函数

    4.11 类型转换及相关函数 在Python中,不同的数据类型是可以相互转换的,下面列举一些之前没有介绍但是比较常见的数据类型转换及相关函数,以供参考。 4.11.1 进制转换类 4.11.1.1 bin(x) 描述将整数转变为以“0b”前缀的二进制字符串。示例>>> bin(3)>>> bin(-10) ‘0b11”-…

    Python开发 2023年4月2日
    00
  • 包和库

    2.3 包和库 2.3.1 包的概念 包是在模块之上的概念,为了方便管理而将多个脚本文件(模块文件)进行打包。包是一种用点式模块名构造 Python 模块命名空间的方法。例如,模块名 A.B 表示包 A 中名为 B 的子模块。正如模块可以区分不同模块之间的全局变量名称一样,点式模块名可以区分 NumPy 或 Pillow 等不同多模块包之间的模块名称。包其实…

    2023年4月2日
    00
  • Python代码块及输入输出

    3.7 Python代码块及输入输出 3.7.1 Python代码块 前面分别介绍了关键字、运算符,由运算符和操作数组成了表达式。而语句由关键字、标识符、表达式组成。而代码块由若干条语句组成。通常Python中的代码块是通过缩进来创建的。在很多语言中,都使用一个特殊的单词或字符,比如begin或{来标识代码块的起始位置,并使用另一个特殊的单词或字符,如end…

    Python开发 2023年4月2日
    00
  • Python获取时光网电影数据

    Python获取时光网电影数据 一、前言 有时候觉得电影真是人类有史以来最伟大的发明,我喜欢看电影,看电影可以让我们增长见闻,学习知识。从某种角度上而言,电影凭借自身独有的魅力大大延长了人类的”寿命”。一部电影如同一本故事书,我可以沉迷到其中,来的一个新的世界,跟着电影主角去经历去感悟。而好的电影是需要慢慢品尝的,不仅提供了各种视觉刺激和情感体验,更能带来思…

    2023年4月2日
    00
  • 定义(创建)、调用函数及返回值

    5.2 定义(创建)、调用函数及返回值 5.2.1 定义(创建)函数 要调用一个函数,首先要定义它。在Python中使用关键字def来定义一个函数。函数通常由函数名、参数列表以及一系列语句组成的函数体构成的。函数定义的一般格式如下: def 函数名(参数列表): 函数体 例如: def sayhello(): print(‘hello’) 最简单的函数: d…

    Python开发 2023年4月2日
    00
合作推广
合作推广
分享本页
返回顶部