Counting the number of elements in a NumPy array is an essential aspect of data analysis, and one of the most common requirements is to count the number of zero and non-zero elements in an array. NumPy provides a built-in function called `count_nonzero()`

that can quickly and easily accomplish this task.

The `count_nonzero()`

function takes an array as its parameter and returns the number of elements that are not equal to zero. By subtracting this value from the total number of elements in the array, we can determine the number of elements that are equal to zero.

## Usage of `count_nonzero()`

function in NumPy arrays

The `count_nonzero()`

function in NumPy arrays has a variety of use cases. Let’s take a closer look at them.

### Counting the number of elements equal to zero

The primary use of the `count_nonzero()`

function is to count the number of elements in a NumPy array that are equal to zero. Here is an example:

```
import numpy as np
a = np.array([[0, 1, 0],
[0, 0, 1]])
print("Number of zero elements:", np.count_nonzero(a == 0))
```

### Output:

```
Number of zero elements: 3
```

In this example, we created a 2D NumPy array and used the `count_nonzero()`

function to count the number of elements that are equal to zero. The function takes an array (`a == 0`

) as input, which returns a Boolean array with `True`

values wherever the condition is met.

So in this case, the Boolean array has `True`

values where the elements in the original array are equal to zero. The `count_nonzero()`

function counts the number of `True`

values in the array and returns it as output.

### Counting the number of elements not equal to zero

The `count_nonzero()`

function can also be used to count the number of elements in a NumPy array that are not equal to zero. Here is an example:

```
import numpy as np
a = np.array([[0, 1, 0],
[0, np.nan, 1]])
print("Number of non-zero elements:", np.count_nonzero(a))
```

### Output:

```
Number of non-zero elements: 3
```

In this example, we created a 2D NumPy array with a NaN value and used the `count_nonzero()`

function to count the number of elements that are not equal to zero. Since the NaN value is not equal to zero, it is counted as a non-zero element by the `count_nonzero()`

function.

Note that if we had used the `count_nonzero()`

function with the Boolean array (`a != 0`

), it would have also counted the NaN value as a non-zero element since NaN does not equal any value, including itself.

### Example of using `count_nonzero()`

function

Let’s look at an example that demonstrates how to use the `count_nonzero()`

function in a real-world scenario.

#### Creating a NumPy array

Suppose we have a dataset that contains the temperatures recorded at different times of the day in a particular city. We want to count the number of times the temperature was above a certain threshold, say 70 degrees Fahrenheit.

```
import numpy as np
# Generate random temperature data for 7 days
temp_data = np.random.randint(low=60, high=90, size=[7, 24])
print("Temperature data:", temp_data)
```

### Output:

```
Temperature data: [[68 72 89 81 82 61 77 68 62 88 63 73 72 71 83 69 81 78 82 62 85 87 63 83]
[70 70 75 86 72 79 67 84 74 83 67 63 79 82 71 85 83 65 68 79 87 82 87 80]
[85 73 81 84 65 66 85 62 70 66 84 79 65 75 78 81 83 77 79 86 63 85 84 72]
[61 70 75 66 77 82 89 67 63 75 75 76 62 83 65 79 74 68 64 60 82 82 86 74]
[73 60 68 82 76 73 60 66 83 64 67 63 81 69 64 63 67 68 72 75 85 89 64 68]
[60 72 63 65 60 60 62 70 74 69 65 75 89 88 87 84 82 75 81 69 85 84 85 88]
[76 77 73 78 77 72 85 79 83 66 65 60 66 87 76 80 76 70 75 89 76 76 84 65]]
```

In this example, we generated a 2D NumPy array with random temperature data for 7 days, with each day containing 24 temperature readings.

#### Counting number of zero and non-zero elements in the array

Next, we want to count the number of times the temperature was above 70 degrees Fahrenheit. We can accomplish this by first creating a Boolean array that specifies whether each element in the temperature array is above 70 degrees.

We can then use the `count_nonzero()`

function to count the number of `True`

values in the Boolean array.

```
# Boolean array that indicates whether temperature is above 70 degrees
above_70 = temp_data > 70
# Count number of True values in above_70 array
num_above_70 = np.count_nonzero(above_70)
print("Number of temperatures above 70 degrees:", num_above_70)
```

### Output:

```
Number of temperatures above 70 degrees: 85
```

In this example, we used the `>`

operator to create a Boolean array that consists of `True`

values wherever the temperature was above 70 degrees Fahrenheit.

We then used the `count_nonzero()`

function to count the number of `True`

values in the Boolean array, which corresponds to the number of temperatures above 70 degrees.

## Conclusion

In this article, we explored the usage of the `count_nonzero()`

function in NumPy arrays. We covered how to count the number of elements that are equal to zero and not equal to zero, and provided an example demonstrating how to use the function to count the number of temperatures above a certain threshold in a dataset.

By utilizing the `count_nonzero()`

function, we can efficiently count the number of relevant elements in NumPy arrays and streamline the data analysis process. The `count_nonzero()`

function is a handy tool in NumPy that enables us to count the number of elements that meet a specific condition in an array.

This function can be used to count the number of elements that are equal to zero or non-zero in a NumPy array. In this article, we will take an in-depth look at the output produced by using the `count_nonzero()`

function.

## Displaying the results of counting zero and non-zero elements

When using the `count_nonzero()`

function, we might want to display the results of the counts that we are performing. In NumPy, the output of the `count_nonzero()`

function is an integer value, representing the number of elements that meet the specified condition.

We can display this value in a variety of ways, depending on our needs. For instance, if we were counting the number of non-zero elements in an array, we could simply print the integer value returned by the `count_nonzero()`

function, as shown below:

```
import numpy as np
# Initialize a 1D numpy array
my_arr = np.array([4, 2, 0, 9, 0, 8, 1])
# Count the number of non-zero elements in my_arr
num_nonzero = np.count_nonzero(my_arr)
# Print the value of num_nonzero
print("The number of non-zero elements in my_arr is:", num_nonzero)
```

### The output of this code snippet will be:

```
The number of non-zero elements in my_arr is: 5
```

In the above example, we initialized a 1D NumPy array called `my_arr`

and counted the number of non-zero elements in it using the `count_nonzero()`

function. We stored the result in the `num_nonzero`

variable and displayed it using the `print()`

statement.

As evident from the output, there were five non-zero elements in `my_arr`

. Alternatively, we can use the format string method to display the results of our counts along with informative text.

Here’s an example:

```
import numpy as np
# Initialize a 2D numpy array
my_arr = np.array([[1, 0, 3], [5, 0, 7]])
# Count the number of zero elements in my_arr
num_zero = np.size(my_arr) - np.count_nonzero(my_arr)
# Display the results
print("In my_arr, there are {} zero elements and {} non-zero elements.".format(num_zero, np.count_nonzero(my_arr)))
```

### The output of this code snippet will be:

```
In my_arr, there are 2 zero elements and 4 non-zero elements.
```

In the above example, we initialized a 2D NumPy array called `my_arr`

, which contained six elements in total.

We then counted the number of zero elements in `my_arr`

and stored it in the variable `num_zero`

. The number of non-zero elements in `my_arr`

was simply the count of all elements minus the number of zero elements.

We then displayed the results using a formatted string.

We can also use the `count_nonzero()`

function to count the number of elements that meet more complicated conditions.

For instance, suppose we have a 2D array of test scores, and we want to count the number of scores that are greater than or equal to 80 and less than 90. We can achieve this using the following code:

```
import numpy as np
# Initialize a 2D numpy array of test scores
scores = np.array([[75, 94, 82], [88, 79, 91], [70, 84, 87]])
# Count the number of scores that are greater than or equal to 80 and less than 90
num_scores = np.count_nonzero(np.logical_and(scores >= 80, scores < 90))
# Display the results
print("The number of test scores between 80 and 89 is:", num_scores)
```

### The output of this code snippet will be:

```
The number of test scores between 80 and 89 is: 4
```

In the above example, we initialized a 2D NumPy array called `scores`

, which contained test scores. We then counted the number of scores that are greater than or equal to 80 and less than 90 by using the `logical_and()`

function, which returns a Boolean array with `True`

values wherever the specified conditions are met.

Finally, we used the `count_nonzero()`

function to count the number of `True`

values in the Boolean array and display the results.

## Conclusion

The NumPy `count_nonzero()`

function is a powerful tool for counting the number of elements in a NumPy array that meet specific conditions. We can display the results of our counts in various ways, including by printing the results, using formatted strings, or using other advanced techniques.

Ultimately, the choice of how to display the results of our counts depends on our preferences and the specific requirements of the problem at hand. The `count_nonzero()`

function, along with its versatile output display options, makes data analysis both efficient and intuitive.

In conclusion, the `count_nonzero()`

function in NumPy is a powerful tool that allows us to easily count the number of elements that meet specific conditions in an array. We can display the results of our counts in various ways, such as printing, using formatted strings, or using other advanced techniques.

By utilizing this function, we can streamline the data analysis process, making our work more efficient and intuitive. The key takeaway is that by using the `count_nonzero()`

function, we can gain valuable insights into our data and make informed decisions based on the results.

Overall, the `count_nonzero()`

function is a crucial component in the NumPy toolbox and is essential for any data analysis endeavor.