Simulating and Calculating Probabilities
00:00
Great, you’re nearly there. Now it’s time to put it all together. In this session, you’re going to simulate and calculate probabilities by implementing a program that for one, uses the random
module to generate random numbers and simulates many coin tosses.
00:19 Then it’s going to calculate the ratio of heads to tails, and it will allow you to alter the behavior of the coin so that you get different ratios of heads or tails.
00:31
One of the key modules that you’ll be using and when you’ll be simulating random events in general is the random
module. You can import random
with the import
keyword, and after that, you can use one of the functions in the random
module, such as randint()
. randint()
takes two numbers, a starting one and an ending one.
00:51
Then it will choose a random integer, a whole number between 1
and 10
. So every time you run randint()
, it’s going to give you a different result. This time, it was 9
.
01:02
If you ran it again, it might give you 2
, or it might give you 6
or 3
.
01:08
Armed with this handy function from the random
module, you can define a coin_flip()
function. This coin_flip()
function randomly returns "heads"
or "tails"
by using the random.randint()
function.
01:23
It passes 0
as the first lower bound to randint()
and 1
as the upper bound, so you’re only going to get 0
and 1
whenever you run this. You’ve got your if
keyword here, and it’s checking whether this expression, random.randint(0, 1) == 0
, whether that evaluates to True
or False
. If it evaluates to True
, then it’s going to return "heads"
. If it evaluates to False
, then it’s going to return "tails"
.
01:55 So you can roughly expect a fifty-fifty split between these two results whenever you call this function. With that function loaded up in IDLE, try and call it within your program …
02:12
and save and run it with F5. Oops, so you need to print the actual output of that because the function only returns. It doesn’t print. So now you’ve got heads
.
02:26
Run it again. heads
. Run it again. tails
tails
tails
. A lot of tails
in a row. heads
heads
. As you can see, it behaves roughly the same as a coin.
02:41
Let’s try and run this ten times. How might you run this ten times in the same program without having to type out coin_flip()
ten times? You do that with a for
loop.
02:51
So let’s go for i in r
for … range(),
good. Now, for i in range(10):
print(coin_flip())
.
03:06 Now you can run this with F5, and as you can see, you can get this to run ten times in quick succession. And as you can see, it does indeed behave a lot like a coin.
03:20
So let’s take that a step further and actually simulate this properly. Here you can initialize two variables, a heads_tally
and a tails_tally
, and basically these will serve to count the number of times that heads
turns up or tails
turns up.
03:36
Then you can create a huge for
loop of 10_000
iterations, and you can execute the coin_flip()
within an if
clause and checking if it equals heads
. And if it does, then you increment the heads_tally
. And if it doesn’t, then you increment the tails_tally
.
03:58 So go over to IDLE and type this out.
04:03
Okay. So you’ve got this typed up in IDLE. And remember just to do that below the coin_flip()
function, because this depends on the coin_flip()
function.
04:13
And then at the end, you can print("heads", heads_tally)
and ("tails", tails_tally)
. You’re printing the string "heads"
just so you know what you’re looking at. And over to the left here, you can see one result of the execution is that heads
was slightly more common than tails
. So how about you run this a couple times?
04:30
heads
more common again. This time, tails
is more common. But as you can see, there’s not much difference there.
04:41
How about you increase this to, say, 100_000_000
times? This might take a while.
04:56 That did take a while. It took a few minutes. But as you can see, the numbers are very close. So this is a pretty good coin.
05:07
This function is slightly different. It doesn’t use the randint()
function. It uses the random()
function from the random
module.
05:15
The random()
function is called without arguments, and it will return a floating-point number—that, is a decimal number between 0
and 1
.
05:25
So it could return 0.535444443
, something like in that order, anywhere between 0
and 1
. So the idea with this function, which is called unfair_coin_flip()
, is that you pass in a probability_of_tails
.
05:39
So if you want it to be a fair coin tos, you can pass in a probability_of_tails
of 0.5
, and then this will roughly behave as a normal coin.
05:48
But if you pass in a probability_of_tails
of 0.3
, then you’re much more likely to get a heads
as a result. So go and type this up in IDLE.
06:02
Here, you have your new function, unfair_coin_flip()
. So let’s simulate that. Let’s not do a hundred million because that takes a long, long time.
06:13
Let’s do a hundred thousand because that’s quite a reasonable number for your computer to do very quickly. So instead of coin_flip()
here, you’ll want to do unfair_coin_flip()
,
06:28
and you’ll want a probability of 0.2
, say. Okay, so now save this and run this. And as you can see, the probability is nearly 0.2
. tails
is almost at twenty thousand, while heads takes eighty thousand.
06:46
So now you can change this to something like 0.4
, and let’s see if that works out properly. And yes, forty-sixty split, as might be expected.
07:01
Well done. You’ve simulated and calculated probabilities. In this session, you implemented a program that used the random
module and two of its functions.
07:10 And you simulated many, many, many coin tosses. You calculated the ratio of heads to tails in these simulations. And you wrote another function that allowed you to alter the behavior of the coin, leaning heavily towards tails or heads, depending on what you pass into that function.
Become a Member to join the conversation.