# Random Choice

## Contents

# Random Choice#

In this section we explore how to make random choices using Python. Additionally, we make use of arrays, and see how appending and summing over Boolean arrays help us to keep track of our results.

To start, suppose we have a list of choices that are equally likely to occur and we want to choose one.

In `numpy`

, the function `np.random.choice()`

will output exactly one item from the input sequence, selecting from it randomly and uniformly - or with equal opportunity.

To illustrate, suppose we toss a coin and want to know the outcome. Since we expect a random output of heads or tails, we create a list titled `coin`

with those options and call the `np.random.choice`

function on `coin`

to give us exactly one result from the list.

But first – we import `numpy`

.

## Coin Toss#

```
import numpy as np
coin = ['heads', 'tails']
flip = np.random.choice(coin)
flip
```

```
'heads'
```

We will see the np.random.choice() function used in various ways throughout this textbook. In this section, we focus on the basic arguments of this function.

The random choice function does not have a fixed output and running it multiple times will eventually produce a different result.

In fact, if we want to run this experiment more than once it might be useful to keep track of the results in an array.

### Investigation with Arrays#

We can store information in arrays as seen in Chapter 4.3. Below we create an array that contains our first experiment result – our first flip – and append our next outcome.

```
flip_array = np.array([flip])
flip_array
```

```
array(['heads'], dtype='<U5')
```

Let’s toss the coin again, choosing randomly from our list of possible outcomes.

```
flip = np.random.choice(coin)
flip
```

```
'tails'
```

And now let’s add this outcome to our list `flip_array`

, using the `append`

method.

This method takes as input an array and elements to be appended, and returns a new array whose elements are those of the input array extended by the input elements.

```
np.append(flip_array, flip)
```

```
array(['heads', 'tails'], dtype='<U5')
```

Since elements are added to a copy of the input array, `append`

does not change the input array. For example, `flip_array`

gives us the original array with one coin flip result.

```
flip_array
```

```
array(['heads'], dtype='<U5')
```

To remedy this, we must use assignment. We can either rename our new list *first * or assign it a new name entirely.

```
flip_array = np.append(flip_array,'tails')
flip_array
```

```
array(['heads', 'tails'], dtype='<U5')
```

Appending items to lists and arrays is an important tool when working in Python. However, the random choice function allows an additional argument that corresponds to repeating the experiment, with results returned as an array. In fact we can repeat the coin flip experiment as many times as we want. Here we repeat 7 times:

```
outcomes = np.random.choice(coin, 7)
outcomes
```

```
array(['heads', 'tails', 'heads', 'heads', 'tails', 'heads', 'tails'],
dtype='<U5')
```

### Boolean Arrays#

Since our experiment is small, we can easily count how many ‘heads’ or ‘tails’ we have. If we have a large experiment it might be tedious, even erroneous, to count by hand. We can instead find all instances where our `outcomes`

array is equal to “heads” and sum over these instances with the help of a *Boolean array*. A *Boolean array* is a special array that contains the binary values of *True* and *False* or the integers \(1\) and \(0\), respectively. Such arrays are often the result of using comparison operations, but can also be constructed manually.
For example, the expression `outcomes == 'heads'`

, performs an elementwise comparison of the array `outcomes`

with the string `'heads'`

, and returns an array of binary values reflecting that comparision. That is, each element in `outcomes`

is compared to `'heads'`

and the truth value of each comparison is returned in an array.

```
outcomes == 'heads'
```

```
array([ True, False, True, True, False, True, False])
```

With this, we can quickly and easily count the number of “heads” in our `outcomes`

array - by summing over the above Boolean array.

For arithmetic operations, `True`

is treated as `1`

and `False`

is treated as `0`

; and so, the sum of a Boolean array counts all instances of `True`

, and disregards all instances of `False`

, giving exactly the number of “heads” in this example.

```
sum(outcomes == 'heads')
```

```
4
```

We can do the same with “tails”:

```
sum(outcomes == 'tails')
```

```
3
```

Since summing over a Boolean array counts all instances of `True`

, another way to count the number of “tails” is with the expression `outcomes != 'heads'`

, and summing over this instead.

Here the Boolean array we create contains instances of `True`

wherever our coin flip landed on “tails”, and `False`

when “heads” was the result of our flip.

```
outcomes != 'heads'
```

```
array([False, True, False, False, True, False, True])
```

Summing over this array also counts the number of tails!

```
sum(outcomes != 'heads')
```

```
3
```

Thus we have these methods of utilizing ways to store data - lists, arrays, etc - to then organize, track, mimic, and count repeated experiments.

The next sections delve deeper into foundational programming techniques that provide more tools on how we can manipulate our data.