# Boolean arrays¶

```
# Import the array library
import numpy as np
```

We are building up to an answer to the three girls problem. At the end of the lists page, we found a way to simulate one family, and get a count.

Now we know about function arguments, and arrays, we can simplify the list version, like this:

```
# Make an array of four random integers that are either 0 or 1.
# 1 means a girl.
family = np.random.randint(0, 2, size=4)
family
```

```
array([1, 0, 0, 0])
```

```
# Add up the integers to count the number of girls.
count = np.sum(family)
count
```

```
1
```

Our interest in how whether of the `count`

value is equal to 3. We can look at
that number and write down “Yes” if the number is equal to 3 and “No”
otherwise, but we would like the computer to do that routine
work for us. We use comparison:

```
is_three = count == 3
is_three
```

```
False
```

True means our simulation found a family with three girls, and False means we found a family some other number of girls.

In a while, we are going to simulate a very large number of these families, but for now, let us simulate 5 families, in a somewhat laborious way:

```
# Make an array to store the counts for each family.
counts = np.zeros(5)
# Make five families, store the counts.
family = np.random.randint(0, 2, size=4)
counts[0] = np.sum(family)
# Second family
family = np.random.randint(0, 2, size=4)
counts[1] = np.sum(family)
# Third
family = np.random.randint(0, 2, size=4)
counts[2] = np.sum(family)
# Fourth
family = np.random.randint(0, 2, size=4)
counts[3] = np.sum(family)
# Fifth.
family = np.random.randint(0, 2, size=4)
counts[4] = np.sum(family)
# Show the counts
counts
```

```
array([3., 3., 1., 1., 2.])
```

Each value in `counts`

is the number of girls in one simulated family.

Now we have 5 numbers for which we want to ask the question - is this number equal to 3? We would like five corresponding True or False values.

Here is where arrays continue to work their magic - we can get this result with a single expression:

```
are_three = counts == 3
are_three
```

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

`are_three`

is an array with 5 elements, one for every element in the array we
compared, `counts`

.

`are_three`

is a *Boolean array* because it contains only Boolean (True, False) values.

We can see what kind of data the array contains by looking at the `dtype`

attribute of the array. Remember, an attribute is a value attached to another value. In this case it is a value attached to the `are_three`

value.

```
are_three.dtype
```

```
dtype('bool')
```

Each element in `are_three`

has the result of the comparison for the
corresponding element. The code above is equivalent to doing:

```
# Make an array of Boolean type (the "dtype" argument)
are_three_longhand = np.zeros(5, dtype=bool)
# Do the comparisons one by one.
are_three_longhand[0] = counts[0] == 3
are_three_longhand[1] = counts[1] == 3
are_three_longhand[2] = counts[2] == 3
are_three_longhand[3] = counts[3] == 3
are_three_longhand[4] = counts[4] == 3
# Show the result
are_three_longhand
```

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

Now we want to know how many of the `counts`

values are equal to 3. This is
the same as asking how many True values there are in `are_three`

(or
`are_three_longhand`

.

We can do this using the `np.count_nonzero`

function. It accepts an array as its argument, and returns the number of non-zero values in the array. It turns out that `np.count_nonzero`

treats True as non-zero, and False as zero, so `np.count_nonzero`

on a Boolean array counts the number of True values:

```
my_booleans = np.array([True, False, True])
np.count_nonzero(my_booleans)
```

```
2
```

To see the number of times we found 3 in `counts`

:

```
np.count_nonzero(are_three)
```

```
2
```