1. 从"中奖幻觉"到概率真相：这个模拟器到底在算什么
买彩票这件事，绝大多数人都算过一笔糊涂账。两块钱一注，中了五百万，感觉人生就此翻盘；没中，也就当捐了两块钱做公益。但如果你真的坐下来，用代码把整个摇奖过程跑上一百万次，你会得到一个让人后背发凉的数字——它跟你脑子里那个"万一呢"的直觉，差得不是一星半点。
我写这个彩票模拟器的起因很简单：身边总有人觉得"买得多总会中"，还有人坚信"守号十年必出奇迹"。与其跟他们争论，不如直接写个程序，把摇奖过程、中奖概率、保本概率全部算出来，用数据说话。这个项目不复杂，核心就是三件事：模拟摇奖、计算中奖概率、计算保本概率。它适合刚学完Python基础语法、想找一个有实际意义的练手项目的人，也适合任何对概率感兴趣、想搞清楚彩票数学本质的读者。
先说清楚这个模拟器能做什么。它不预测下一期开奖号码——那是玄学，不是编程。它能做的是：给定一套彩票规则（比如从多少个号码里选几个），用随机数生成器模拟摇奖，然后拿你选的号码去比对，统计在大量重复实验中，你中各个奖级的频率是多少，最终你的投入和回报是否平衡。所谓保本概率，就是你买彩票的钱刚好能通过中奖奖金收回来的概率。这个数字往往低得让人沉默。
为什么用Python来做这件事？因为Python的random模块足够好用，语法简洁，几十行代码就能跑出一个完整的模拟框架。你不需要装什么重型库，标准库就能搞定。而且Python处理大数运算和统计汇总非常顺手，跑一百万次模拟也就几秒钟的事。对于想练手的人来说，这个项目覆盖了随机数生成、循环控制、条件判断、字典统计、概率计算这几个核心知识点，性价比很高。
在动手之前，有一个认知必须先建立起来：彩票的每一次摇奖都是独立事件。这意味着上一期开了什么号码，跟下一期没有任何关系。很多人喜欢研究"走势图"，觉得某个号码"该出了"，这在概率论上叫赌徒谬误。你的模拟器跑出来的结果会反复验证这一点——每个号码出现的频率会趋近于均匀分布，不会因为某个号码"很久没出"就变得更容易出现。理解这一点，是你写这个模拟器之前最重要的心理准备。
接下来我会从规则设计、摇奖模拟、概率统计、保本计算、性能优化几个层面，把这个项目完整拆开讲一遍。代码可以直接跑，参数可以自己改，你想模拟哪种彩票规则都行。
2. 彩票规则建模：先把"游戏规则"翻译成代码
2.1 选号规则的结构化描述
写模拟器之前，第一件事是把彩票规则用数据结构描述清楚。不同彩票的规则差异很大，但核心参数就那么几个：号码池大小（从多少个号码里选）、选号个数（你要选几个）、奖级划分（中几个号对应什么奖）、奖金金额（每个奖级对应多少钱）、单注价格（一注多少钱）。
我以最常见的"从35个号码中选7个"这种类型为例来建模。用字典来存规则是最直观的：
lottery_rule = { "pool_size": 35, # 号码池：1到35 "pick_count": 7, # 每注选7个号 "price_per_ticket": 2, # 每注2元 "prize_tiers": { # 中几个号 -> 奖金 7: 5000000, 6: 50000, 5: 500, 4: 50, 3: 5, } }这个结构的好处是，你想换成"从49个选6个"或者"从33个选6个"，只需要改几个数字，后面的逻辑完全不用动。这就是数据驱动的思路——把规则和逻辑分离，改规则不改代码。
注意：奖级设置里，中奖号码个数必须是连续的或者有明确对应关系的。如果你的规则里"中2个号也有奖"，那就加上去；如果"中6个和7个之间还有一档"，也要补全。奖级表不完整会导致后面统计时出现KeyError。
2.2 为什么用字典而不是列表存奖级
有人可能会想，奖级用列表存不行吗？比如[5, 50, 500, 50000, 5000000]，索引对应中奖个数。这样做的问题是，当奖级不连续时（比如中2个没奖、中3个有奖），列表的索引就对不上了。用字典的键值对，prize_tiers[3]直接拿到中3个号的奖金，语义清晰，不容易出错。
另一个考虑是扩展性。真实彩票往往还有"特别号""追加投注"这类机制，用字典可以很方便地加字段，比如加一个"special_number": True，然后在摇奖逻辑里多摇一个号。列表要做到这一点就得改结构，成本更高。
2.3 单注与复式的处理边界
这个模拟器默认按单注处理，也就是每注独立选号、独立比对。如果你想模拟复式投注（选超过7个号，组合成多注），那需要在选号阶段做组合展开。我的建议是，第一版先不做复式，把单注的逻辑跑通、跑准，再考虑扩展。因为复式投注的组合数增长很快，选10个号就是C(10,7)=120注，选12个号就是C(12,7)=792注，计算量和内存占用都会上去。
如果你确实想加复式功能，核心就是itertools.combinations：
from itertools import combinations def expand_complex(numbers, pick_count): """把复式选号展开成所有单注组合""" return list(combinations(numbers, pick_count))但要注意，复式展开后的每一注都要单独比对、单独统计投入，否则保本概率会算错。这个坑我在后面会详细说。
3. 摇奖模拟的核心：随机数到底该怎么"摇"
3.1 random.sample 与 random.choices 的选择
Python标准库里生成不重复随机数最直接的方法是random.sample：
import random def draw_numbers(pool_size, pick_count): """从1到pool_size中随机抽取pick_count个不重复的号码""" return random.sample(range(1, pool_size + 1), pick_count)random.sample保证抽出来的号码不重复，这正好符合彩票摇奖的实际情况——同一个号码不会在一期里出现两次。如果你用random.choices（注意有s），它是有放回抽样，可能抽到重复号码，那就不对了。
这里有一个细节值得说：random.sample返回的顺序是随机的，但彩票比对时通常不关心顺序，只关心中了几个号。所以后面比对时要用集合运算，而不是逐位比较。
3.2 随机数种子与可复现性
调试阶段，你肯定希望每次跑出来的结果是一样的，这样才能定位问题。random.seed()就是干这个的：
random.seed(42) # 固定种子，每次运行结果一致但在正式跑概率统计时，不要固定种子。固定种子意味着你每次跑的都是同一组随机序列，统计结果会有偏差。正确的做法是：调试时固定种子，正式统计时不设种子（或者用系统时间自动播种）。
我踩过的一个坑是：有一次跑了一百万次模拟，结果中奖概率比理论值高了0.3个百分点，查了半天以为是代码逻辑错了，最后发现是测试时忘了去掉random.seed(42)，那一组特定序列恰好偏向了某些号码组合。去掉种子之后，结果就回归正常了。
3.3 摇奖函数的性能考量
random.sample在号码池不大的时候（几十到几百）性能完全够用。但如果你要模拟号码池上万、选号上百的场景，random.sample内部实现是部分洗牌，效率会下降。这时候可以用random.shuffle配合切片：
def draw_numbers_fast(pool_size, pick_count): pool = list(range(1, pool_size + 1)) random.shuffle(pool) return pool[:pick_count]实测下来，在pool_size=35、pick_count=7的场景下，两种方法差异可以忽略。但如果你要跑上亿次模拟，shuffle版本会略快一点，因为它避免了sample内部的一些边界检查。不过对于这个项目来说，可读性优先，random.sample是更好的选择。
3.4 比对逻辑：集合运算比循环快得多
摇完号之后，要拿你的选号和开奖号码比对，看中了几个。最直观的写法是双重循环：
def count_matches_slow(my_numbers, drawn_numbers): count = 0 for n in my_numbers: if n in drawn_numbers: count += 1 return count但更Pythonic、也更快的方法是集合交集：
def count_matches(my_numbers, drawn_numbers): return len(set(my_numbers) & set(drawn_numbers))集合交集在底层是哈希表操作，时间复杂度接近O(min(m,n))，而双重循环是O(m*n)。在pick_count=7的情况下差异不大，但如果扩展到选几十个号，差距就明显了。养成用集合运算的习惯，对以后处理更大规模的数据有好处。
4. 中奖概率：理论值、模拟值与"感觉"的差距
4.1 组合数学：理论概率怎么算
在跑模拟之前，先算理论概率，这样你才知道模拟结果对不对。中奖概率的本质是组合数之比。
从N个号码中选K个，总的组合数是C(N, K)。你中k个号的组合数是：从开奖的K个号中选k个，再从剩下的N-K个号中选K-k个，即C(K, k) * C(N-K, K-k)。所以中k个号的概率是：
P(k) = C(K, k) * C(N-K, K-k) / C(N, K)
用Python的math.comb可以直接算：
from math import comb def theoretical_probability(pool_size, pick_count, match_count): total = comb(pool_size, pick_count) favorable = comb(pick_count, match_count) * comb(pool_size - pick_count, pick_count - match_count) return favorable / total以35选7为例，中7个号（头奖）的概率是1/C(35,7) = 1/6724520，大约是千万分之一点五。中6个号的概率约为万分之零点三。中3个号（最低奖级）的概率大约是百分之一点六。
把这些数字列出来，你就能直观感受到：中头奖的概率比你出门被鸟屎砸中的概率还低。这不是夸张，是数学。
4.2 模拟统计：跑一百万次看频率
理论值有了，接下来用模拟来验证。核心逻辑是：跑N次，每次摇一组号，跟固定选号比对，统计每个中奖个数的出现次数。
def simulate_probability(rule, my_numbers, trials=1_000_000): stats = {k: 0 for k in rule["prize_tiers"]} for _ in range(trials): drawn = draw_numbers(rule["pool_size"], rule["pick_count"]) matches = count_matches(my_numbers, drawn) if matches in stats: stats[matches] += 1 return {k: v / trials for k, v in stats.items()}跑一百万次，大概需要几秒到十几秒，取决于机器性能。跑出来的频率应该跟理论值非常接近，误差在千分之一以内。如果误差很大，那说明代码有问题，优先检查比对逻辑和奖级映射。
提示：模拟次数越多，频率越接近理论概率，这是大数定律的体现。但注意，大数定律说的是"趋近"，不是"相等"。跑一万次和跑一百万次，结果的波动范围是不一样的。跑一万次时，中头奖的次数可能是0，也可能是2，这都正常。
4.3 为什么"守号"不会提高中奖率
很多人相信"守号"——每期买同一组号码，觉得坚持久了总会中。模拟器可以帮你验证这个想法。你固定一组号码，跑一百万次，中奖频率跟随机选号完全一样。因为每一期摇奖都是独立的，你的号码不会因为"守得久"就变得更容易被摇出来。
这个结论在模拟器里体现得非常清楚：你把my_numbers固定成[1,2,3,4,5,6,7]，跑一百万次，中奖分布跟随机选号没有任何统计上的显著差异。号码没有记忆，随机过程不会补偿任何人。
4.4 模拟结果的波动范围与置信区间
跑模拟的时候，你可能会发现每次跑出来的中奖次数略有不同。这是正常的随机波动。如果你想给出一个更严谨的结论，可以计算置信区间。对于二项分布，当试验次数n很大、概率p很小时，可以用正态近似：
标准误差 SE = sqrt(p * (1-p) / n)
95%置信区间大约是 p ± 1.96 * SE。
比如中头奖概率p ≈ 1.5e-7，跑n=1e6次，SE ≈ sqrt(1.5e-7 / 1e6) ≈ 1.2e-8，置信区间大约是[1.3e-7, 1.7e-7]。这个区间很窄，说明百万次模拟已经足够精确了。但如果你想区分更小的概率差异，就需要更多次模拟。
5. 保本概率：一个比中奖概率更扎心的数字
5.1 保本概率的定义与计算逻辑
保本概率的定义是：你买彩票的总投入，刚好被中奖奖金覆盖（或超过）的概率。注意，这不是"中奖概率"，而是"不亏钱概率"。你可能中了很多次5块钱的小奖，但投入了100块，那还是亏的。
计算逻辑是：对每一次模拟，计算这一注的投入（price_per_ticket）和回报（根据中奖个数查奖金表），然后统计"回报 >= 投入"的次数占比。
def simulate_breakeven(rule, my_numbers, trials=1_000_000): breakeven_count = 0 for _ in range(trials): drawn = draw_numbers(rule["pool_size"], rule["pick_count"]) matches = count_matches(my_numbers, drawn) prize = rule["prize_tiers"].get(matches, 0) if prize >= rule["price_per_ticket"]: breakeven_count += 1 return breakeven_count / trials以35选7、单注2元为例，中3个号奖金5元，已经超过2元投入，所以保本。中4个号50元，也保本。中5个号500元，保本。中6个、7个更不用说。所以保本概率 = P(中3个) + P(中4个) + P(中5个) + P(中6个) + P(中7个)。
算出来大概是百分之一点七左右。也就是说，你买100次，大约只有不到2次是不亏的，剩下98次以上都是纯亏。
5.2 单注保本 vs 多注保本：一个容易算错的坑
如果你一次买多注，保本概率的计算就复杂了。比如你买10注，总投入20元，那么"保本"意味着这10注的总奖金 >= 20元。这时候不能简单地把单注保本概率乘以10，因为各注之间不是独立事件（它们共享同一个开奖结果）。
正确的做法是：每次模拟摇一组号，然后对这10注分别比对、分别算奖金，汇总后判断是否保本。这个逻辑在代码里就是一个内层循环：
def simulate_multi_ticket_breakeven(rule, my_tickets, trials=100_000): breakeven_count = 0 total_cost = len(my_tickets) * rule["price_per_ticket"] for _ in range(trials): drawn = draw_numbers(rule["pool_size"], rule["pick_count"]) total_prize = 0 for ticket in my_tickets: matches = count_matches(ticket, drawn) total_prize += rule["prize_tiers"].get(matches, 0) if total_prize >= total_cost: breakeven_count += 1 return breakeven_count / trials我实测过，买10注的保本概率比单注的1.7%高一些，但也就百分之十几，远没有到"买得多就容易保本"的程度。因为多注虽然增加了中奖机会，但投入也成倍增加，奖金的增长跟不上投入的增长。
5.3 期望值：彩票的数学本质
比保本概率更本质的指标是期望值。期望值 = 所有可能结果的奖金乘以对应概率之和，再减去投入。
def expected_value(rule): ev = 0 for match_count, prize in rule["prize_tiers"].items(): p = theoretical_probability(rule["pool_size"], rule["pick_count"], match_count) ev += p * prize return ev - rule["price_per_ticket"]以35选7为例，算出来的期望值大概是负一点几元。也就是说，你每买一注2元的彩票，长期来看平均亏1块多。这个数字是彩票的"抽水率"——一部分奖金池被运营成本拿走了。任何彩票的期望值都是负的，否则发行方就亏了。这是数学上的必然，不是运气问题。
5.4 奖金结构对保本概率的影响
保本概率高度依赖奖金结构。如果最低奖级的奖金刚好等于或略高于票价，那保本概率就等于"中最低奖级及以上"的概率。如果最低奖级奖金低于票价，那保本概率会更低。
你可以用模拟器做敏感性分析：把最低奖级奖金从5元改成3元、2元、1元，看保本概率怎么变。实测下来，最低奖级奖金每降低1元，保本概率可能下降零点几个百分点。这个分析对理解彩票设计很有帮助——发行方通过调整奖级和奖金，精确控制着返奖率。
6. 代码组织与性能优化：让模拟器跑得更快更稳
6.1 函数拆分与模块化
一个可维护的模拟器应该拆成几个独立函数：规则定义、摇奖、比对、单次模拟、批量统计、结果输出。每个函数只做一件事，方便单独测试和替换。
我习惯把规则定义放在最上面，用字典或类来存。如果用类，可以这样：
class LotteryRule: def __init__(self, pool_size, pick_count, price, prize_tiers): self.pool_size = pool_size self.pick_count = pick_count self.price = price self.prize_tiers = prize_tiers类比字典的好处是可以加方法，比如get_prize(match_count)、validate()等。但对于这个项目，字典已经够用，类反而增加了复杂度。选择最简单的方案，除非有明确理由不用它。
6.2 用numpy加速大规模模拟
如果你要跑上千万次甚至上亿次模拟，纯Python循环会变慢。这时候可以用numpy做向量化操作。核心思路是一次性生成大量随机数，然后批量比对。
import numpy as np def simulate_numpy(rule, my_numbers, trials=10_000_000): pool = np.arange(1, rule["pool_size"] + 1) my_set = set(my_numbers) # 批量生成开奖号码 draws = np.array([np.random.choice(pool, rule["pick_count"], replace=False) for _ in range(trials)]) # 批量比对 matches = np.array([len(my_set & set(d)) for d in draws]) # 统计 unique, counts = np.unique(matches, return_counts=True) return dict(zip(unique, counts / trials))numpy版本比纯Python快5到10倍，但内存占用也更高。跑一千万次时，draws数组会占用几百MB内存。如果内存不够，可以分批跑，每批一百万次，最后汇总。
注意：
np.random.choice在replace=False时，对于大号码池性能不如random.sample。如果号码池很大，建议还是用random.sample生成，再转成numpy数组做后续统计。
6.3 进度显示与中断处理
跑长时间模拟时，加一个进度显示会让人安心很多。可以用tqdm库，也可以自己用print打点：
def simulate_with_progress(rule, my_numbers, trials): stats = {} report_interval = trials // 10 for i in range(trials): drawn = draw_numbers(rule["pool_size"], rule["pick_count"]) matches = count_matches(my_numbers, drawn) stats[matches] = stats.get(matches, 0) + 1 if (i + 1) % report_interval == 0: print(f"进度: {(i+1)/trials*100:.0f}%") return {k: v / trials for k, v in stats.items()}另外，建议加上KeyboardInterrupt处理，让用户可以用Ctrl+C中断模拟并输出当前统计结果。这在调试时很有用。
6.4 结果输出与可视化
模拟跑完之后，把结果整理成表格输出，比直接打印字典直观得多。可以用tabulate库，也可以手动格式化：
def print_results(rule, simulated_probs): print(f"{'中奖个数':<10}{'理论概率':<15}{'模拟概率':<15}{'奖金':<10}") for match_count in sorted(rule["prize_tiers"], reverse=True): p_theory = theoretical_probability(rule["pool_size"], rule["pick_count"], match_count) p_sim = simulated_probs.get(match_count, 0) prize = rule["prize_tiers"][match_count] print(f"{match_count:<10}{p_theory:<15.8f}{p_sim:<15.8f}{prize:<10}")如果想画图，用matplotlib画一个柱状图对比理论值和模拟值，一眼就能看出吻合程度。不过对于这个项目，表格已经足够，画图属于锦上添花。
7. 实测中的几个反直觉发现
7.1 中奖次数比想象中多，但都是小奖
跑一百万次模拟，中3个号的次数大约有一万六千次，看起来不少。但中4个号只有几百次，中5个号只有几十次，中6个号个位数，中7个号基本是0。中奖次数多，但绝大多数是最低奖级，奖金刚好覆盖成本甚至不够。这就是为什么很多人觉得"我经常中奖啊"，但算总账还是亏的。
7.2 买得越多，亏得越确定
单注的期望值是负的，买10注期望值就是负的10倍。模拟器跑出来的结果会告诉你：买得越多，总亏损的方差越小，也就是说亏损越来越确定。买1注可能中个大奖翻盘，买100注基本就是稳定亏损。这个结论跟直觉相反，但数学上无懈可击。
7.3 号码组合的"冷热"是错觉
模拟器可以统计每个号码出现的频率。跑一百万次之后，每个号码出现的频率都在理论值附近波动，没有哪个号码显著偏多或偏少。所谓"热号""冷号"，在足够大的样本下都会回归均匀。你如果只跑几十次，确实会看到某些号码出现得多，但那只是小样本波动，不代表任何趋势。
7.4 保本概率对奖金结构极度敏感
把最低奖级奖金从5元改成4元，保本概率可能从1.7%降到1.2%。因为中3个号的概率是1.6%左右，这部分人原本能保本，奖金降低后就变成亏损了。这个敏感性分析说明：彩票的返奖率是设计出来的，不是随机形成的。发行方通过精算，确保长期返奖率控制在一个固定比例。
8. 把这个模拟器用出更多花样
8.1 模拟不同彩票规则的对比
你可以把多套规则放在一起跑，对比它们的期望值和保本概率。比如35选7和49选6，哪个更"划算"？模拟器会告诉你答案。实测下来，不同规则的期望值都是负的，但负的程度不同。有些彩票返奖率设计得高一些，亏损慢一些，但长期来看都是亏。
8.2 用模拟器做概率教学
这个项目很适合用来教概率论。你可以让学生自己改参数、跑模拟、对比理论值，直观理解组合数学和大数定律。比在黑板上写公式生动得多。我试过让完全没学过概率的人跑一遍，他们很快就理解了"独立事件"和"期望值"的概念。
8.3 扩展到其他随机场景
这个模拟器的框架可以迁移到很多场景：抽卡游戏的概率验证、骰子游戏的赔率计算、甚至A/B测试的显著性判断。核心逻辑都是"生成随机结果 -> 比对 -> 统计频率"。把彩票规则换成抽卡规则，代码几乎不用改。
8.4 代码复现的完整清单
如果你想直接跑起来，按这个清单操作：
- 安装Python 3.8以上版本，标准库就够，不需要额外装包。
- 把规则定义、摇奖函数、比对函数、统计函数写在一个
.py文件里。 - 设置
trials=1000000，运行，观察输出。 - 修改
prize_tiers，看保本概率怎么变。 - 把
my_numbers改成固定号码，验证"守号"无效。 - 如果想加速，装numpy，用向量化版本。
整个项目代码量不大，核心逻辑一两百行就能写完。但就是这么点代码，能把彩票的数学本质扒得干干净净。我自己的体会是：写完这个模拟器之后，再看到"中奖新闻"心态完全不一样了——那不是幸运，那是概率海洋里的一朵小浪花，恰好被镜头拍到了而已。
