Get a random boolean in python?

Question

I am looking for the best way (fast and elegant) to get a random boolean in python (flip a coin).

For the moment I am using random.randint(0, 1) or random.getrandbits(1).

Are there better choices that I am not aware of?

This is a good and valid question about performance of various options for getting a random boolean, but I feel like lost in the noise of all the benchmarks is the fact that the best performer saves less than a second versus the worst performer over a _million_ iterations. If you've come here looking for a way to speed up an application, you should probably look at other options first. — Ian McLaird, Oct 15 '20 at 14:16

score 481 · Accepted Answer · edited Feb 14 '23 at 04:17

Adam's answer is quite fast, but I found that random.getrandbits(1) to be quite a lot faster. If you really want a boolean instead of a long then

import random
bool(random.getrandbits(1))

is still about twice as fast as random.choice([True, False])

Both solutions need to import random

If utmost speed isn't to priority then random.choice definitely reads better.

Note that random.choice() is slower than just choice() (after from random import choice) due to the attribute lookup.

$ python3 --version
Python 3.9.7
$ python3 -m timeit -s "from random import choice" "choice([True, False])"
1000000 loops, best of 5: 376 nsec per loop
$ python3 -m timeit -s "from random import choice" "choice((True, False))"
1000000 loops, best of 5: 352 nsec per loop
$ python3 -m timeit -s "from random import getrandbits" "getrandbits(1)"
10000000 loops, best of 5: 33.7 nsec per loop
$ python3 -m timeit -s "from random import getrandbits" "bool(getrandbits(1))"
5000000 loops, best of 5: 89.5 nsec per loop
$ python3 -m timeit -s "from random import getrandbits" "not getrandbits(1)"
5000000 loops, best of 5: 46.3 nsec per loop
$ python3 -m timeit -s "from random import random" "random() < 0.5"
5000000 loops, best of 5: 46.4 nsec per loop

If we're all about performance, `not not random.getrandbits(1))` is faster than `bool` ;) — Michał Bentkowski, Jul 26 '11 at 09:38
You likely don't even need to cast to a boolean at all, since 0/1 have the proper truth values. — Adam Vandenberg, Jul 26 '11 at 16:46
You could speed it up further by doing `from random import getrandbits` to avoid the attribute lookup. :-) — kindall, Jul 26 '11 at 23:07
actually, the missing attribute lookup seems to be the reason why `random() < 0.5` is the fastest. When using `from random import getrandbits` `getrandbits` is faster than `random() < 0.5`. — jl005, Feb 22 '21 at 15:27

score 268 · Answer 2 · edited Nov 11 '21 at 01:18

268

import random
random.choice([True, False])

would also work.

edited Nov 11 '21 at 01:18

castis

8,154
4
41
63

answered Jul 26 '11 at 02:48

Adam Vandenberg

19,991
9
54
56

Do I need to import some library? – hola Oct 08 '21 at 02:54
3

Just `random`. [It is part of the standard library](https://docs.python.org/3/library/random.html#random.choice) – castis Nov 11 '21 at 01:18
1

Indeed - the same `random` used by most of the other answers here. – Karl Knechtel Nov 11 '21 at 01:28

Pavel Radchenko · Answer 3 · 2021-06-11T10:55:43.040

56

Found a faster method:

$ python -m timeit -s "from random import getrandbits" "not getrandbits(1)"
10000000 loops, best of 3: 0.222 usec per loop
$ python -m timeit -s "from random import random" "True if random() > 0.5 else False"
10000000 loops, best of 3: 0.0786 usec per loop
$ python -m timeit -s "from random import random" "random() < 0.5"
10000000 loops, best of 3: 0.0579 usec per loop

edited Jun 11 '21 at 10:55

answered Mar 05 '14 at 15:23

Pavel Radchenko

709
5
4

6

`random() > 0.5` already evaluates to a bool which is even faster! – John La Rooy Mar 08 '14 at 09:15
32

`random() >= 0.5`, otherwise you will be a tiny bit biased towards False. – Simon Lindholm Mar 17 '14 at 22:42
29

`random() < 0.5` makes more sense as changing 0.5 to some other probability works as expected – akxlr Nov 07 '15 at 11:24
Changed to `random() < 0.5`, thanks @SimonLindholm and @akxlr. – Pavel Radchenko Jun 11 '21 at 10:56
`True if random() > 0.5 else False` Ahhhhh!!!!!!!! My eyes. – Eric Duminil Oct 28 '22 at 08:19

score 13 · Answer 4 · answered Sep 22 '13 at 08:22

13

I like

 np.random.rand() > .5

answered Sep 22 '13 at 08:22

Maarten

4,549
4
31
36

score 13 · Answer 5 · answered Dec 07 '11 at 22:39

13

If you want to generate a number of random booleans you could use numpy's random module. From the documentation

np.random.randint(2, size=10)

will return 10 random uniform integers in the open interval [0,2). The size keyword specifies the number of values to generate.

answered Dec 07 '11 at 22:39

Chris

44,602
16
137
156

I was curious as to how the speed of this method performed against the answers since this option was left out of the comparisons. To generate one random bool (which is the question) this is much slower but if you wanted to generate many then this mecomes much faster: $ python -m timeit -s "from random import random" "random() < 0.5" 10000000 loops, best of 3: 0.0906 usec per loop – ojunk Aug 08 '18 at 10:00

score 6 · Answer 6 · answered Nov 26 '19 at 11:07

6

You could use the Faker library, it's mainly used for testing, but is capable of providing a variety of fake data.

Install: https://pypi.org/project/Faker/

>>> from faker import Faker
>>> fake = Faker()
>>> fake.pybool()
True

answered Nov 26 '19 at 11:07

Partiban

136
3
9

score 4 · Answer 7 · answered Aug 08 '18 at 10:09

I was curious as to how the speed of the numpy answer performed against the other answers since this was left out of the comparisons. To generate one random bool this is much slower but if you wanted to generate many then this becomes much faster:

$ python -m timeit -s "from random import random" "random() < 0.5"
10000000 loops, best of 3: 0.0906 usec per loop
$ python -m timeit -s "import numpy as np" "np.random.randint(2, size=1)"
100000 loops, best of 3: 4.65 usec per loop

$ python -m timeit -s "from random import random" "test = [random() < 0.5 for i in range(1000000)]"
10 loops, best of 3: 118 msec per loop
$ python -m timeit -s "import numpy as np" "test = np.random.randint(2, size=1000000)"
100 loops, best of 3: 6.31 msec per loop

score 3 · Answer 8 · answered Dec 23 '20 at 23:15

3

u could try this it produces randomly generated array of true and false :

a=[bool(i) for i in np.array(np.random.randint(0,2,10))]

out: [True, True, True, True, True, False, True, False, True, False]

answered Dec 23 '20 at 23:15

gourav naik

31
1

score 2 · Answer 9 · edited Oct 28 '15 at 22:16

2

A new take on this question would involve the use of Faker which you can install easily with pip.

from faker import Factory

#----------------------------------------------------------------------
def create_values(fake):
    """"""
    print fake.boolean(chance_of_getting_true=50) # True
    print fake.random_int(min=0, max=1) # 1

if __name__ == "__main__":
    fake = Factory.create()
    create_values(fake)

edited Oct 28 '15 at 22:16

Shawn Mehan

4,513
9
31
51

answered Oct 28 '15 at 21:34

Althea

87
1

17

You should at least explain why you think this is a better solution, considering it involves downloading a different package and is messier. – Martino Jan 13 '16 at 14:23
3

I disagree with the downvotes. If you're creating random data, you may well be in a situation where Faker is a very useful tool. The `fake.boolean()` syntax is clean and easy for others to grok. – Jason McVetta Jul 10 '17 at 05:31
4

Regardless of whether or not the package is useful, the complete lack of explanation as to why one should consider this makes the answer useless. – Apollys supports Monica Jun 09 '18 at 17:14

score 0 · Answer 10 · answered Oct 05 '22 at 11:00

0

Below methods would also work for this purpose:

import random
random.choice([0, 1])

or

import random
random.choice(range(2))

answered Oct 05 '22 at 11:00

Javad

2,033
3
13
23

Get a random boolean in python?

10 Answers10

Linked