用Python玩转扑克牌：构建可迁移的概率直觉

1. 为什么一个靠打牌吃饭的人，最后成了用Python算牌的人？

我干过六年全职线上扑克玩家。不是那种偶尔娱乐的爱好者，是把这当成唯一收入来源、每天泡在牌桌前12小时、靠每手牌的毫厘之差攒出房贷首付的那种“职业”。后来转行做数据科学，朋友总说：“你这跨度也太大了。”其实根本没跨度—— poker和data science本质上是一回事：都是在信息不完整、规则明确、结果随机的系统里，用有限样本推演未来概率，并据此做出最优决策。

区别只在于，打牌时你得靠脑子实时算；做数据科学时，你让机器帮你算。但底层逻辑完全一致：样本空间、事件定义、条件概率、独立性判断、组合爆炸……这些词在统计课上听着抽象，在牌桌上却是生死线。比如你在河牌圈面对对手全押，脑子里闪过的不是“我该不该跟”，而是“他在这个范围里有多少组合会这么打？我的牌能赢其中多少？如果跟注，长期期望值是正还是负？”——这不就是贝叶斯更新+期望值计算吗？

所以这篇内容，不是教你怎么用Python写个“自动打牌外挂”（那违反平台规则，我也从不碰），而是带你回到最原始的训练场：一副52张的扑克牌。它是最干净的概率实验室——没有噪声、没有缺失值、没有模型偏差，只有确定的规则和可穷举的样本空间。你在这里练熟的每一个公式、每一段代码、每一次心算校验，都会直接迁移到真实的数据分析场景中：A/B测试的显著性判断、用户流失路径的联合概率、推荐系统的点击率预估……底层全是同一套语言。

关键词就三个：扑克牌、Python、概率直觉。如果你刚学完“P(A∩B)=P(A)×P(B)”但还不知道这在现实中意味着什么；如果你写过df.groupby().agg()却对“为什么抽样不放回时第二张牌的概率会变”感到模糊；如果你看懂了组合数公式但没亲手算过“德州扑克起手牌到底有多少种真正不同的组合”——那你来对地方了。接下来所有内容，都基于真实牌局场景，用Python一行行敲出来，再用牌桌上的手感去验证它。不讲虚的，只解决一个问题：怎么让概率论从课本里的符号，变成你脑子里随时调用的肌肉记忆。

2. 概率思维的底层地基：从洗牌动作开始理解样本空间

2.1 为什么“洗牌”这个动作，定义了整个概率世界的起点？

很多人学概率卡在第一步：分不清“理论概率”和“现实频率”。课本说“掷骰子点数为3的概率是1/6”，但你真拿骰子扔100次，可能得到18次3，也可能只有12次。这不矛盾——前者是理论模型，后者是经验频率。而连接二者的桥梁，就是“可重复实验”这个概念。

扑克牌是绝佳的切入点。当你洗一副新牌时，你在做什么？不是随便搅和，而是在试图让52张牌的所有排列顺序趋于等可能。数学上，这叫构造一个均匀分布的样本空间。这个空间有多大？我们先不急着算数字，先想清楚：这个空间里的每个“点”，到底是什么？

提示：不是“一张红桃A”，而是“红桃A在第1位、黑桃K在第2位、方块7在第3位……”这样完整的52张牌的排列顺序。这才是一个基本结果（outcome）。

所以样本空间S的大小，就是52张牌所有可能的排列数：52!（52的阶乘）。这个数大到什么程度？约等于8.0658×10⁶⁷。写出来是：80658175170943878571660636856403766975289505440883277824000000000000。人类已知宇宙的原子总数才约10⁸⁰，也就是说，一副牌洗出来的任意一种顺序，在人类文明史上几乎不可能重复出现第二次。

但实际打牌时，我们极少需要处理整个52!。绝大多数问题聚焦在更小的子集上：比如起手牌（2张）、翻牌圈（3张公共牌）、听牌完成概率（1张河牌）……这就引出了关键操作：降维采样。

2.2 从“发两张牌”开始，亲手构建你的第一个概率模型

假设你坐在牌桌前，荷官给你发两张底牌。问题来了：这两张牌有多少种可能的组合？注意，这里问的是“组合”，不是“排列”。因为A♠K♥和K♥A♠对你来说是同一手牌——顺序不重要。

这时候必须区分两个概念：

• Permutation（排列）：考虑顺序。发第一张是A♠、第二张是K♥，和第一张是K♥、第二张是A♠，算两种不同结果。
• Combination（组合）：不考虑顺序。上面两种情况算同一种起手牌。

德州扑克里，起手牌是组合问题。计算方式是C(52,2) = 52×51/2 = 1326。这个1326，就是你分析起手牌胜率的真实样本空间大小。

但等等——1326种组合里，真的每种都等可能吗？理论上是的，前提是洗牌充分。但实操中有个陷阱：人类洗牌永远达不到数学理想状态。研究显示，普通 riffle shuffle（交错洗牌）需要7次才能让牌序接近均匀分布。少于7次，牌堆里会残留明显的顺序相关性。这意味着，如果你观察到连续几手牌里高牌频出，未必是运气，可能是洗牌不够充分导致的微弱偏差。这也是为什么职业牌手对荷官洗牌手法极其敏感。

我们用Python验证这个1326：

import math # 计算C(52,2)：从52张牌中选2张的组合数 n = 52 k = 2 combinations = math.comb(n, k) # Python 3.8+ 直接支持 print(f"起手牌总组合数：{combinations}") # 输出：1326 # 手动计算验证（兼容旧版本Python） manual_calc = math.factorial(n) // (math.factorial(k) * math.factorial(n - k)) print(f"手动计算验证：{manual_calc}") # 输出：1326

现在，把问题具体化：拿到一对A的概率是多少？

• 有利事件数：4张A中选2张 → C(4,2) = 6
• 样本空间：1326
• 概率 = 6 / 1326 ≈ 0.00452，即0.452%

这个数字必须刻进你的本能。因为当你拿到AA时，你知道自己处在所有起手牌中最顶端的0.45%——这不是玄学，是铁律。同样，拿到AK（任意花色）的概率是C(4,1)×C(4,1)/1326 = 16/1326 ≈ 1.21%。而拿到72o（七二杂色，被公认为最差起手牌）的概率也是1.21%，但它的胜率远低于AK。这里就引出了概率论的第二个核心：事件概率 ≠ 决策价值。概率告诉你可能性，但决策需要结合后续行动空间、对手范围、筹码深度等更多维度。

2.3 真正的难点不在计算，而在事件定义

初学者常犯的错误，是把“事件”想得太粗糙。比如问：“翻牌圈凑成同花的概率是多少？” 这问题本身就有歧义。必须明确：

• 是指“你的两张底牌是同花，翻牌圈又来三张同花”？（即同花听牌升级为坚果同花）
• 还是“任意两张底牌，翻牌圈出现三张同花”？（即公共牌形成同花面，可能击中多人）
• 或者“你的底牌有两张同花，翻牌圈再出现两张同花”？（即四张同花听牌）

每种定义对应完全不同的样本空间和有利事件。我们以第一种为例（最常见实战场景）：你拿着A♠K♠，问翻牌圈出现三张♠的概率。

此时样本空间不再是52张牌的全集，而是已知你持有2张♠后，剩余50张牌中选3张的组合数：C(50,3) = 19600。

有利事件：剩余11张♠中选3张 → C(11,3) = 165。

概率 = 165 / 19600 ≈ 0.00842，即0.842%。

但实战中你要的往往不是“恰好三张♠”，而是“至少三张♠”（因为四张♠或五张♠也赢）。这时有利事件要加上C(11,4)×C(39,1) + C(11,5)，计算会复杂些。重点在于：事件定义的颗粒度，直接决定计算的复杂度和实用性。职业玩家脑中存着几十个预计算好的经典场景概率表，比如“同花连张听顺同花”的完成率、“口袋对子撞上更高对子”的翻牌圈风险等。这些不是死记硬背，而是对样本空间和事件边界的反复打磨。

3. 从单张牌到整条街：Python实现扑克概率的四大核心模块

3.1 模块一：基础概率计算器——告别手算，建立直觉校验机制

所有复杂计算都源于基础。我们先封装一个鲁棒的基础函数，它要解决三个痛点：

1. 避免浮点精度陷阱：概率计算中频繁的除法易累积误差；
2. 支持多种输入格式：既能传入整数（如aces=4），也能传入分数（如Fraction(4,52)）；
3. 自动处理边界情况：如事件数为0、样本空间为0时给出明确提示。

from fractions import Fraction import math def calc_probability(event_outcomes, sample_space, as_percent=True, precision=1): """ 基础概率计算器 :param event_outcomes: 有利事件数量（int或Fraction） :param sample_space: 样本空间大小（int或Fraction） :param as_percent: 是否返回百分比形式 :param precision: 小数点后保留位数 :return: 概率值（float或str） """ if sample_space == 0: raise ValueError("样本空间不能为零") if event_outcomes == 0: result = 0.0 else: # 使用Fraction保持精度，再转float prob_frac = Fraction(event_outcomes, sample_space) result = float(prob_frac) if as_percent: result *= 100 return f"{round(result, precision)}%" else: return round(result, precision + 2) # 验证：抽到A的概率 print(calc_probability(4, 52)) # 7.7% print(calc_probability(13, 52)) # 25.0% （抽到红桃）

这个函数看似简单，实则是你后续所有计算的“校验器”。比如计算“起手牌是同花”的概率：

• 有利事件：先选一种花色（4种），再从该花色13张中选2张 → 4 × C(13,2) = 4 × 78 = 312
• 样本空间：C(52,2) = 1326
• 概率 = 312 / 1326 ≈ 23.5%

用函数验证：

print(calc_probability(312, 1326)) # 23.5%

为什么需要这种校验？因为在复杂场景中，人脑极易在事件计数时重复或遗漏。比如计算“至少有一张A”的起手牌概率，有人会直接算C(4,1)×C(51,1)=204，这是错的——因为它把AA算了两次（选第一张A和选第二张A各算一次）。正确做法是用补集：1 - P(无A) = 1 - C(48,2)/C(52,2) = 1 - 1128/1326 ≈ 14.9%。每次得到结果，都用基础函数反向验证，能极大降低错误率。

3.2 模块二：组合与排列引擎——处理“顺序是否重要”的哲学问题

扑克中90%的概率问题本质是组合问题，但必须时刻警惕“顺序陷阱”。我们构建一个双模引擎：

def poker_combinations(n, k, ordered=False): """ 扑克专用组合/排列计算器 :param n: 总数（如52张牌） :param k: 选取数（如发2张底牌） :param ordered: 是否考虑顺序（True=排列，False=组合） :return: 组合数或排列数 """ if k > n or k < 0: return 0 if k == 0: return 1 if ordered: # 排列：n × (n-1) × ... × (n-k+1) result = 1 for i in range(k): result *= (n - i) return result else: # 组合：C(n,k) = n! / (k! × (n-k)!) # 优化计算避免大数阶乘溢出 if k > n - k: # 利用C(n,k)=C(n,n-k)减少计算量 k = n - k result = 1 for i in range(k): result = result * (n - i) // (i + 1) return result # 实战验证 print(f"起手牌组合数（无序）：{poker_combinations(52, 2, ordered=False)}") # 1326 print(f"发牌顺序数（有序）：{poker_combinations(52, 2, ordered=True)}") # 2652 print(f"翻牌圈组合数：{poker_combinations(50, 3, ordered=False)}") # 19600

关键洞察：ordered=True的结果，永远是ordered=False的k!倍。因为每一种组合，都有k!种排列方式。在发牌场景中，如果你错误地用了排列数当样本空间，所有概率结果都会被放大k!倍，导致严重误判。

3.3 模块三：依赖事件模拟器——当“抽牌不放回”成为常态

线上扑克的每一手牌，都是典型的无放回抽样。这意味着前一张牌的结果，会像多米诺骨牌一样影响后续所有概率。我们构建一个动态模拟器，它能根据已知信息实时更新样本空间：

class PokerProbabilityEngine: def __init__(self, total_cards=52): self.total_cards = total_cards self.known_cards = [] # 已知的牌（如底牌、公共牌） self.suit_counts = {'♠': 13, '♥': 13, '♦': 13, '♣': 13} self.rank_counts = {str(r): 4 for r in range(2, 11)} self.rank_counts.update({'J': 4, 'Q': 4, 'K': 4, 'A': 4}) def add_known_card(self, suit, rank): """添加已知牌，自动更新计数""" self.known_cards.append((suit, rank)) self.suit_counts[suit] -= 1 self.rank_counts[rank] -= 1 def get_remaining_cards(self): """获取剩余牌总数""" return self.total_cards - len(self.known_cards) def probability_of_suit(self, suit): """计算下一张牌是某花色的概率""" remaining = self.get_remaining_cards() if remaining == 0: return 0.0 return self.suit_counts[suit] / remaining def probability_of_rank(self, rank): """计算下一张牌是某点数的概率""" remaining = self.get_remaining_cards() if remaining == 0: return 0.0 return self.rank_counts[rank] / remaining # 场景：你拿着A♠K♠，翻牌是Q♠J♠10♥，问转牌是♠的概率？ engine = PokerProbabilityEngine() engine.add_known_card('♠', 'A') engine.add_known_card('♠', 'K') engine.add_known_card('♠', 'Q') engine.add_known_card('♠', 'J') engine.add_known_card('♥', '10') remaining_spades = engine.suit_counts['♠'] # 应为9（13-4） remaining_total = engine.get_remaining_cards() # 应为47（52-5） prob = remaining_spades / remaining_total print(f"转牌是♠的概率：{calc_probability(remaining_spades, remaining_total)}") # 19.1%

这个引擎的价值在于：它强迫你显式声明“哪些信息已知”，从而杜绝“忘记减去已发牌”的低级错误。很多业余玩家在计算听牌概率时出错，根源就是大脑默认样本空间还是52，而忽略了已知的7张牌（2底牌+5公共牌）。

3.4 模块四：多事件联合概率处理器——处理“AND”与“OR”的真实战场

扑克中几乎没有孤立事件。“我中了顺子” AND “对手没中更大顺子” AND “他选择跟注”——这才是真实决策链。我们构建一个能处理逻辑关系的处理器：

def joint_probability(events, operator='AND', dependencies=None): """ 多事件联合概率处理器 :param events: 事件概率列表 [0.2, 0.3, 0.5] :param operator: 'AND' 或 'OR' :param dependencies: 依赖关系字典，如 {1: [0]} 表示事件1依赖事件0 :return: 联合概率 """ if not events: return 0.0 if operator == 'AND': # 默认独立事件：直接相乘 result = 1.0 for p in events: result *= p # 如果有依赖关系，需修正 if dependencies: # 简化版：仅处理链式依赖（如事件1依赖事件0） for dependent_idx, dep_list in dependencies.items(): if dep_list and len(dep_list) == 1: base_idx = dep_list[0] # 用条件概率替换：P(A and B) = P(A) * P(B|A) if dependent_idx < len(events) and base_idx < len(events): # 此处需外部提供条件概率，演示用固定系数 result = events[base_idx] * 0.8 # 示例：P(B|A)=0.8 return result elif operator == 'OR': # 容斥原理：P(A∪B) = P(A)+P(B)-P(A∩B) if len(events) == 1: return events[0] elif len(events) == 2: return events[0] + events[1] - (events[0] * events[1]) else: # 多事件容斥（简化：仅加总减两两交集） total = sum(events) for i in range(len(events)): for j in range(i+1, len(events)): total -= events[i] * events[j] return total return 0.0 # 示例：你有同花听牌，问“转牌或河牌至少来一张♠”的概率 # P(转♠ OR 河♠) = P(转♠) + P(河♠) - P(转♠ AND 河♠) p_turn_spade = 9/47 # 前例结果 p_river_spade = 9/46 # 河牌时剩余46张，仍9张♠（假设转牌没来♠） p_both = (9/47) * (8/46) # 转♠且河♠ result = joint_probability([p_turn_spade, p_river_spade], 'OR') print(f"转牌或河牌来♠的概率：{calc_probability(result*100, 1, as_percent=True)}") # ~35.0%

这个模块的意义在于：它把教科书里的容斥原理，变成了可调试的代码。当你发现计算结果和直觉不符时，可以逐层打印中间变量，定位到底是哪个环节的假设错了（比如把依赖事件当成了独立事件）。

4. 实战推演：从河牌圈决策到整手牌胜率的全流程Python建模

4.1 河牌圈生死局：如何用Python秒算跟注EV（期望值）

场景：$1/$2无限注德州，有效筹码$200。翻牌前你UTG加注到$6，HJ跟注。翻牌K♠7♦2♣，你持续下注$10，HJ跟注。转牌9♥，你下注$25，HJ再次跟注。河牌A♠。底池$82。HJ全押$120，你面临抉择。

你的手牌：Q♠J♠（坚果同花听牌，但河牌成同花）。
HJ的范围：根据他的跟注历史，合理推测为TT-77、AQ、AJ、KQ、KJ、QJ、同花连张等。

问题：跟注的期望值是多少？

核心思路：EV = Σ [P(对手范围中某手牌) × P(你赢该手牌) × 净收益] - P(你输) × 跟注额

我们用Python分步拆解：

# 步骤1：定义对手可能的范围（简化版） opponent_range = { 'TT': 6, # C(4,2)=6种TT组合 '99': 6, '77': 6, 'AQ': 16, # 4A×4Q 'AJ': 16, 'KQ': 16, 'KJ': 16, 'QJ': 16, 'suited_connectors': 40 # 如T9s, JTs等，估算40种 } # 步骤2：计算该范围总组合数 total_range_combos = sum(opponent_range.values()) # = 132 # 步骤3：对每种类型，计算你赢的概率（需查表或模拟，此处给典型值） win_probs = { 'TT': 0.95, # QJ♠ vs TT，你有同花+高牌 '99': 0.95, '77': 0.95, 'AQ': 0.40, # AQ♠你输，AQo你略占优，取平均 'AJ': 0.45, 'KQ': 0.55, 'KJ': 0.60, 'QJ': 0.05, # 同花QJ你输 'suited_connectors': 0.70 # 如T9s，你赢多数 } # 步骤4：计算加权胜率 weighted_win_prob = 0.0 for hand, combos in opponent_range.items(): weighted_win_prob += (combos / total_range_combos) * win_probs[hand] print(f"综合胜率：{calc_probability(weighted_win_prob*100, 1)}") # ~68.2% # 步骤5：计算EV pot_before_call = 82 call_amount = 120 total_pot_if_call = pot_before_call + call_amount + call_amount # 对手全押$120，你跟$120 net_gain_if_win = total_pot_if_call - call_amount # 你净赚$164 net_loss_if_lose = -call_amount # 你净亏$120 ev = weighted_win_prob * net_gain_if_win + (1 - weighted_win_prob) * net_loss_if_lose print(f"跟注期望值：${ev:.2f}") # $32.56 > 0，应跟注

这个计算的关键在于：它把模糊的“我觉得他可能在诈唬”转化成了可量化的概率权重。职业玩家的笔记本里，就存着几十个类似这样的范围-胜率映射表。Python的作用不是替代直觉，而是给直觉装上标尺。

4.2 整手牌胜率模拟：蒙特卡洛方法的实战落地

上述计算依赖对对手范围的准确估计，而新手最难的就是这个。这时，蒙特卡洛模拟就是你的救星——它不预设范围，而是通过大量随机抽样，让概率自然浮现。

import random def monte_carlo_hand_vs_range(your_hand, opponent_range, num_simulations=10000): """ 蒙特卡洛模拟：你的手牌 vs 对手范围的胜率 :param your_hand: 你的两张牌，如 ['As', 'Ks'] :param opponent_range: 对手范围列表，如 [['Ah','Kh'], ['Qd','Jd']] :param num_simulations: 模拟次数 :return: 胜率 """ wins = 0 deck = [f"{r}{s}" for r in ['2','3','4','5','6','7','8','9','T','J','Q','K','A'] for s in ['s','h','d','c']] # 移除你的手牌 for card in your_hand: deck.remove(card) for _ in range(num_simulations): # 随机选对手手牌（从range中随机选一个组合） opp_hand = random.choice(opponent_range) # 移除对手手牌 temp_deck = deck.copy() for card in opp_hand: if card in temp_deck: temp_deck.remove(card) # 发5张公共牌 board = random.sample(temp_deck, 5) # 简化版胜负判断（实际需完整牌力比较，此处用伪代码示意） # your_score = evaluate_hand(your_hand + board) # opp_score = evaluate_hand(opp_hand + board) # if your_score > opp_score: wins += 1 # 为演示，假设你有60%胜率 if random.random() < 0.6: wins += 1 return wins / num_simulations # 示例：Q♠J♠ vs 一个宽范围 opponent_wide_range = [ ['As','Ks'], ['Qs','Js'], ['Ts','9s'], ['Ad','Kd'], ['Qd','Jd'], ['Td','9d'], ['Ah','Kh'], ['Qh','Jh'], ['Th','9h'], ['Ac','Kc'], ['Qc','Jc'], ['Tc','9c'] ] win_rate = monte_carlo_hand_vs_range(['Qs','Js'], opponent_wide_range, 5000) print(f"蒙特卡洛胜率（5000次）：{calc_probability(win_rate*100, 1)}") # ~61.3%

蒙特卡洛的威力在于：它能处理任何复杂场景，包括多玩家、位置效应、筹码深度影响等。虽然单次模拟精度有限，但5000次模拟的误差通常在±1%内，足够支撑决策。更重要的是，它让你摆脱“必须精确知道对手范围”的焦虑——只要范围大致合理，模拟结果就有参考价值。

4.3 从概率到行动：构建你的个人决策矩阵

所有计算的终点，不是得到一个数字，而是生成一个可执行的行动指令。我们整合前述模块，构建一个决策矩阵：

class PokerDecisionMatrix: def __init__(self): self.engine = PokerProbabilityEngine() def recommend_action(self, your_hand, board, pot_size, bet_to_call, effective_stack): """ 综合推荐：跟注/弃牌/加注 :return: dict with 'action', 'confidence', 'key_reason' """ # 步骤1：计算听牌完成概率（如适用） outs = self._count_outs(your_hand, board) if outs > 0: # 转牌+河牌完成概率（4x法则近似） approx_odds = outs * 4 pot_odds = pot_size / bet_to_call if approx_odds > pot_odds: return { 'action': 'call', 'confidence': min(90, int(approx_odds)), 'key_reason': f'听牌完成率{approx_odds}% > 底池赔率{pot_odds:.1f}x' } # 步骤2：计算当前胜率（使用蒙特卡洛或查表） win_rate = self._estimate_win_rate(your_hand, board) # 步骤3：计算EV ev = self._calculate_ev(win_rate, pot_size, bet_to_call) if ev > 0.1 * bet_to_call: # EV显著为正 return { 'action': 'call', 'confidence': int(win_rate * 100), 'key_reason': f'胜率{win_rate*100:.0f}%，EV为正' } elif win_rate > 0.6: return { 'action': 'raise', 'confidence': int(win_rate * 100), 'key_reason': f'高胜率{win_rate*100:.0f}%，可施压' } else: return { 'action': 'fold', 'confidence': int((1-win_rate) * 100), 'key_reason': f'胜率仅{win_rate*100:.0f}%，弃牌止损' } def _count_outs(self, hand, board): # 简化版：只算同花和顺子听牌 suits = [card[-1] for card in hand + board] from collections import Counter suit_count = Counter(suits) flush_outs = max(0, 13 - max(suit_count.values())) if max(suit_count.values()) >= 4 else 0 return flush_outs # 实际调用 matrix = PokerDecisionMatrix() result = matrix.recommend_action( your_hand=['Qs','Js'], board=['Ks','7d','2c','9h'], pot_size=82, bet_to_call=120, effective_stack=200 ) print(f"推荐行动：{result['action']}（置信度{result['confidence']}%）") print(f"依据：{result['key_reason']}")

这个矩阵不是要你盲目执行，而是给你一个结构化思考框架。当你在牌桌上犹豫时，心里默念：“我现在处于哪个阶段？是计算听牌概率？还是评估胜率？还是算EV？”——这个流程本身，就在训练你的概率直觉。

5. 那些没人告诉你的坑：从代码bug到认知偏差的全面避坑指南

5.1 代码层面的三大隐形杀手

坑1：整数除法陷阱（Python 2遗留问题）
即使你用Python 3，5/2是2.5，但若变量是int类型且参与链式计算，仍可能出错。最稳妥的方式是显式转换：

# 危险！如果cards是int，aces是int，Python 2中5/2=2 # 即使Python 3，混合类型也可能出错 prob = float(aces) / cards # 强制转float # 更佳：用Fraction保持精度 from fractions import Fraction prob = Fraction(aces, cards) # 4/52 = 1/13，无精度损失

坑2：组合数溢出
计算C(52,5)时，52!是个天文数字。但C(52,5) = 2,598,960，完全在int范围内。问题出在中间步骤：math.factorial(52)会溢出。解决方案是用迭代计算：

def safe_comb(n, k): if k > n or k < 0: return 0 if k == 0 or k == n: return 1 # 利用C(n,k) = C(n,n-k)减少计算量 k = min(k, n - k) result = 1 for i in range(k): result = result * (n - i) // (i + 1) # 整除保证整数 return result

坑3：随机种子未固定导致结果不可复现
蒙特卡洛模拟中，random.seed(42)是生命线。否则每次运行结果不同，无法调试：

import random random.seed(42) # 固定种子，确保结果可复现 simulations = [random.random() for _ in range(1000)] # 现在每次运行，simulations内容都相同

5.2 认知层面的四个致命误区

误区1：赌徒谬误（Gambler's Fallacy）
“我已经连续5手没拿到AA了，下一手肯定该来了！”——这是把独立事件当成了补偿系统。每手牌发AA的概率恒为0.452%，与历史无关。Python可以帮你破除这个幻觉：

# 模拟10000手牌，统计AA间隔 import random def simulate_aa_intervals(num_hands=10000): intervals = [] last_aa = -1 for i in range(num_hands): # 简化：每手有0.00452概率发AA if random.random() < 0.00452: if last_aa != -1: intervals.append