《三门问题》——Python模拟

1. 问题描述

三门问题（蒙提霍尔问题）：三扇门后有一个正确答案，两个错误答案。
当你做出选择时，事先知道结果的主持人会为你在其它两扇门中排除一个错误答案，然后询问你是否更改你的选择。
例子：现在有1号，2号，3号三扇门
在介绍完规则后，你选择了1号门，然后主持人告诉你3号门是错误的，你是否会更改你的答案呢？

本文尝试模拟较多次的实验数据来观察“修改与否”对结果的影响。

2.过程模拟

2.1 代码实现

直接上代码（逻辑已写在注释中，故不赘述）：

import random


right_question = random.randint(1, 3)   # 使用随机数来指定正确的门牌号
doors = [1, 2, 3]
your_question = int(input('您选择几号门？'))
doors.remove(right_question)   # 将正确答案从列表中移除后，剩余的都是错误答案
if your_question != right_question:   # 如果选手选择的答案是错误的：
    doors.remove(your_question)   # 将选手选择的门从列表中移除
    print(f'主持人为您排除的错误答案为：{doors}')   # 此时列表中的号码就是主持人为选手排除的另一个错误答案
    is_change = input('是否更改您的答案（y/n）：')
    if is_change == 'y':
        print('恭喜！获得奖金500w！')
    if is_change == 'n':
        print(f'你猜错了，正确答案是{right_question}')
else:   # 如果选手的选择是正确的：
    wrong_question_index = random.randint(0, 1)   # 产生一个随机数为其随机排除一个错误答案
    print(f'主持人为您排除的错误答案为：{doors[wrong_question_index]}')
    is_change = input('是否更改您的答案（y/n）：')
    if is_change == 'y':
        print(f'你猜错了，正确答案是{right_question}')
    if is_change == 'n':
        print('恭喜！获得奖金500w！')

2.2 结果预览

3. 循环往复

        模拟一次过程并不是重点，我们的重点是多次实验，观察玩家修改与否对中奖的影响。

        上述代码中的人为操作均改为生成随机数进行判断，这样就可以自动化运行：

import random


count = 1000000  # 试验次数，暂设为100万次
player_change_wish = 50  # 选手的修改意愿值，此值越高，选手修改自己选择的概率越大
# 下面四个参数分别统计四种情况出现的次数：
unchange_right = 0  # 原本是正确的，并且未修改
unchange_wrong = 0  # 原本是错误的，并且未修改
change_right = 0    # 原本是错误的，修改了的
change_wrong = 0    # 原本是正确的，修改了的


for i in range(0, count):   # 实验指定次数
    right_question = random.randint(1, 3)  # 使用随机数来指定正确的门牌号
    your_question = random.randint(1, 3)
    if your_question != right_question:  # 如果选手选择的答案是错误的：
        is_change = random.randint(1, 100)
        if is_change <= player_change_wish:  # 用生成随机数和修改意愿比较来判断选手是否修改
            change_right += 1
        else:
            unchange_wrong += 1
    else:  # 如果选手的选择是正确的：
        is_change = random.randint(1, 100)
        if is_change <= player_change_wish:
            change_wrong += 1
        else:
            unchange_right += 1

    i += 1

print(f'未修改 且 正确的次数:{unchange_right}, 占比为：{round(unchange_right / count, 3)}')
print(f'未修改 且 错误的次数:{unchange_wrong}, 占比为：{round(unchange_wrong / count, 3)}')
print(f'修改 且 正确的次数:{change_right}, 占比为：{round(change_right / count, 3)}')
print(f'修改 且 错误的次数:{change_wrong}, 占比为：{round(change_wrong / count, 3)}')
print(f'获奖的次数:{unchange_right + change_right}, 占比为：{(unchange_right + change_right) / count}')

        程序运行结果不明显，将其列在表格中便于观察：

        

修改意愿：0

情景	次数	占比
未修改 且 正确	332926	0.333
未修改 且 错误	667074	0.667
修改 且 正确	0	0
修改 且 错误	0	0
最终获奖	332926	0.332926

修改意愿：10

情景	次数	占比
未修改 且 正确	300419	0.3
未修改 且 错误	599740	0.6
修改 且 正确	66503	0.067
修改 且 错误	33338	0.033
最终获奖	366922	0.366922

修改意愿：20

情景	次数	占比
未修改 且 正确	266750	0.267
未修改 且 错误	533321	0.533
修改 且 正确	133266	0.133
修改 且 错误	66663	0.067
最终获奖	400016	0.400016

修改意愿：30

情景	次数	占比
未修改 且 正确	233725	0.234
未修改 且 错误	466184	0.466
修改 且 正确	199913	0.2
修改 且 错误	100178	0.1
最终获奖	433638	0.433638

修改意愿：40

情景	次数	占比
未修改 且 正确	200274	0.2
未修改 且 错误	399585	0.4
修改 且 正确	266626	0.267
修改 且 错误	133515	0.134
最终获奖	466900	0.4669

修改意愿：50

情景	次数	占比
未修改 且 正确	167147	0.167
未修改 且 错误	333597	0.334
修改 且 正确	333099	0.333
修改 且 错误	166157	0.166
最终获奖	500246	0.500246

修改意愿：60

情景	次数	占比
未修改 且 正确	133318	0.133
未修改 且 错误	266548	0.267
修改 且 正确	399949	0.4
修改 且 错误	200185	0.2
最终获奖	533267	0.533267

修改意愿：70

情景	次数	占比
未修改 且 正确	100272	0.1
未修改 且 错误	200234	0.2
修改 且 正确	467001	0.467
修改 且 错误	232493	0.232
最终获奖	567273	0.567273

修改意愿：80

情景	次数	占比
未修改 且 正确	66487	0.066
未修改 且 错误	132999	0.133
修改 且 正确	534357	0.534
修改 且 错误	266157	0.266
最终获奖	600159	0.600159

修改意愿：90

情景	次数	占比
未修改 且 正确	33405	0.033
未修改 且 错误	66905	0.067
修改 且 正确	600208	0.6
修改 且 错误	299482	0.299
总计	633613	0.633613

修改意愿：100

情景	次数	占比
未修改 且 正确	0	0
未修改 且 错误	0	0
修改 且 正确	667402	0.667
修改 且 错误	332598	0.333
总计	667402	0.667402

        根据上述实验数据可以看出：随着修改意愿逐步地提高（100万次实验中修改选择的次数增加），最终获奖的概率也在增加。

        个人粗鄙的理解：选手第一次做出选择时，选对的概率为三分之一，选错的概率为三分之二。当被问及是否更改时，如果选择更改，那么将你原本对的选择修改为错误的概率就是三分之一，反之，将原本错误的选择更改为正确的概率就变为了三分之二。而不是主持人排除一个错误结果后的二分之一。

        注：① 表格中保留三位小数的占比是四舍五入后的结果，可能会出现相加不为1的情况；

               ② 表格中的数据为多次运行后趋于稳定的数据，精度为0.001