A few weeks ago, I watched an episode of Numberphile about the Monty Hall problem. This happens to be one of my favorite little “that-doesn’t-seem-right” statistics things, and I thought it would be a great way to play with Python.
Contents [show]
The Problem
If you’re not familiar with the Problem, here’s the gist of it. There are three doors and you’re asked to pick one of them. Now, behind one door is an amazing prize: a new car, a bunch of money, a trip to a tropical island. You get the idea. Behind the other two doors, though, there’s something useless or just nothing. Maybe it’s a goat. Regardless, you don’t want what’s behind those other two doors.
So you pick your door and the host, Monty Hall, opens one of the two doors you didn’t pick. It’s always one of the horrible non-prizes. And now comes the stressful part of the game: Monty asks if you’d like to switch doors. Do you stick with the door you picked in the beginning or do you switch to the new door?
Our Python Classes
While you think about that, let’s get to the code. We need a couple of things set up before we can play the game. Mostly, though, we need a door.
class Door(object):
prize = False
opened = False
So, OK, here’s our door. By default, it’s closed (opened = False) and it doesn’t have a prize. Since we’ll make multiple doors for a game, I think it makes more sense to have the game pick which door has the prize than it does for the doors to decide for themselves. No one wants a sentient door.
Speaking of our game, let’s look at that object too.
class Game(object):
chosen_door = None
switched_doors = False
def __init__(self):
self.doors = [
Door(),
Door(),
Door()
]
# Pick a random door and give it a prize
random.choice(self.doors).prize = True
We start with no doors chosen and, of course, since no doors have been chosen, the player couldn’t possibly have switched doors. Then we create three doors and randomly pick one of them to have a prize. We’re all set up to play the game.
The Whole Game
Here’s a gist of the entire game:
| from __future__ import print_function | |
| from collections import namedtuple | |
| import random | |
| # Create an easy-to-return and easy-to-inspect data | |
| # structure for Game results. | |
| Results = namedtuple('Results', ['won', 'switched']) | |
| class Door(object): | |
| prize = False | |
| opened = False | |
| class Game(object): | |
| chosen_door = None | |
| switched_doors = False | |
| def __init__(self): | |
| self.doors = [ | |
| Door(), | |
| Door(), | |
| Door() | |
| ] | |
| # Pick a random door and give it a prize | |
| random.choice(self.doors).prize = True | |
| def pick_door(self): | |
| self.chosen_door = random.choice(self.doors) | |
| def open_false_door(self): | |
| # Get the non-chosen doors | |
| available_doors = [door for door in self.doors | |
| if door is not self.chosen_door] | |
| for door in available_doors: | |
| if not door.prize: | |
| # Open the first prizeless door | |
| door.opened = True | |
| break | |
| def switch_doors(self): | |
| available_door = [door for door in self.doors | |
| if door is not self.chosen_door | |
| and not door.opened][0] | |
| if random.randint(0, 1): | |
| # Randomly decide to switch doors | |
| self.switched_doors = True | |
| self.chosen_door = available_door | |
| @classmethod | |
| def play(cls): | |
| game = cls() | |
| game.pick_door() | |
| game.open_false_door() | |
| game.switch_doors() | |
| return Results(game.chosen_door.prize, game.switched_doors) | |
| # Play 1000 runs of the game to get significant numbers | |
| games = [Game.play() for _ in range(1000)] | |
| # Games where the player switched doors and won the prize | |
| won_switched = list(filter(lambda g: g.won and g.switched, games)) | |
| # Games where the player did *not* switch doors and won the prize | |
| won_original = list(filter(lambda g: g.won and not g.switched, games)) | |
| # Games where the player did *not* switch doors and lost | |
| lost_original = list(filter(lambda g: not g.won and not g.switched, games)) | |
| # Games where the player switched doors and lost | |
| lost_switched = list(filter(lambda g: not g.won and g.switched, games)) | |
| print("Won and switched:", len(won_switched)) | |
| print("Won and didn't switch:", len(won_original)) | |
| print("Lost and switched:", len(lost_switched)) | |
| print("Lost and didn't switch:", len(lost_original)) |
The way it’s set up, you can just call Game.play() however many times you want to play the game. I found that playing it a small number of times, say 10–50, doesn’t yield any noticeable results but bump the number up into the hundreds or thousands and you start to see real answers.
For example, here’s what I’ve gotten when I run it:
| Won & Switched | Won & Stayed | Lost & Switched | Lost & Stayed |
|---|---|---|---|
| 340 | 178 | 170 | 312 |
| 322 | 194 | 162 | 322 |
| 329 | 161 | 190 | 320 |
| 317 | 160 | 187 | 336 |
| 337 | 167 | 186 | 310 |
While this is only the results of running the script 5 times, you can see that it’s generally a 2:1 ration of winning when the player switches compared to winning when they don’t switch.
Takeaways
My script is pretty simple. You could easily change this to have more doors or to take user input on whether or not to switch. You could also use the handy plotting techniques from Data Science Basics to make a chart showing wins and loses, switches and stays. Oh, and if the list comprehensions and uses of filter and lambda are confusing, we have a couple of workshops on those you should check out. All of the code in the gist should run in both Python 2 and Python 3.
So, what’s your decision? Will you switch doors or stick with the one you have?
Photo by Frank Müller
I recently built a similar model in R and put it up. The simulator allows you to select the # of doors, in order to see how probability changes.
Looking at the detailed results was crucial for my own understanding. Perhaps this will help you make sense of the question as well –
http://igotMontyHallProblems.us
This was a really fun example of taking something abstract and real world and creating a program to understand the problem more. It just goes to show you that anything can be programmed if you put your mind to it.