Arrays are some of the most common and fundamental objects when working with NumPy. Therefore, learning to perform various actions on array objects is hugely significant to your productivity.

This tutorial resolves to guide you on using `NumPy.nanprod()`

method, starting with the function syntax, accepted parameters, return value, and practical examples.

## Introduction to the NumPy `nanprod()`

Function

When working with NumPy, you will encounter an array that contains missing values. In most cases, NumPy and other Python packages represent missing values as `NaN`

or `Not A Number`

.

The `nanprod()`

function in NumPy enables us to determine the product of each element in a given array, even in an array containing `NaN`

values.

## Function Syntax

Provided below is the syntax of the `nanprod()`

function in NumPy:

```
numpy.nanprod(a, **axis**=None, **dtype**=None, **out**=None, **keepdims**=<no value>, **initial**=<no value>, **where**=<no value>)
```

## Function Parameters

From the syntax above, we can see the function accepts the following arguments:

**a**– represents the input array whose elements' products are to be computed. It is a required parameter; the function will return an error if its value is missing.**axis**– This parameter (optional) defines along which axis the product of the array is computed. With the axis set to 0, the function returns the product of the elements along the columns. Otherwise, if the axis is set to 1, the product is calculated for the elements along the rows. By default, the axis value is set to None, which returns the product of all elements in the array.**dtype**– the`dtype`

parameter enables you to specify the data type of the array to be returned.**out**– the out parameter is an optional value that defines an alternative array to place the resulting array. The alternative array must have a similar shape as the expected output.**keepdims**– If this parameter's value is set to true, the reduced axes are left in the result as the dimensions with size one.**initial**– states the starting value for the product.**where**– sets the elements to include in the product computation.

## Function Return Value

The function returns the product of each element in the given array over the specified axis. The array returned is the same shape as the input array defined by the `a`

parameter.

The function treats all `NaN`

values as 1.

## Examples of Using the `NumPy.nanprod()`

Function

The example below provides an example code on how to use the `nanprod()`

function with a 1-dimensional array:

```
import numpy as np
arr = np.array([15, np.nan, 30])
product = np.nanprod(arr)
print("original array: ", arr)
print("resulting array: ", product)
```

Output

```
original array: [15. nan 30.]
resulting array: 450.0
```

We declare a new 1-D array with three elements in the example above. One element is a NaN value as provided by `np.nan`

.

Calculating the product of the array forces the value of `NaN`

to be treated as 1, leading to the computation:

$$

15 * 1 * 30 = 450.0

$$

## Using the `nanprod()`

function with a 2-Dimensional Array

The `nanprod()`

function supports operation on a 2-D array, as demonstrated in the code below:

```
import numpy as np
arr = np.array([[15, np.nan, 30],
[10, np.nan, np.nan]])
product = np.nanprod(arr)
print("original array: ", arr)
print("resulting array: ", product)
```

After the product operation:

```
original array: [[15. nan 30.]
[10. nan nan]]
resulting array: 4500.0
```

The function will treat all `NaN`

values as 1, making the resulting expression:

$$

15 * 1 * 30 * 10 * 1 * 1 = 4500.0

$$

## Using the `nanprod()`

function along the zero axis (column-wise)

The example code below illustrates how to use the `nanprod()`

function along the 0 axis. It will only perform the product along the column values.

```
import numpy as np
arr = np.array([[15, np.nan, 30],
[10, np.nan, np.nan]])
product = np.nanprod(arr, axis=0)
print("original array: ", arr)
print("resulting array: ", product)
```

Output from the above operation:

```
original array: [[15. nan 30.]
[10. nan nan]]
resulting array: [150. 1. 30.]
```

In this case, since we are performing the product along the column values, the resulting expression:

$$

Column[0] \rightarrow 15 * 10 = 150\

Column[1] \rightarrow 1 * 1 = 1\

Column[2] \rightarrow 30 * 1 = 10\

$$

## Using the `nanprod()`

function along the one axis (row-wise)

We can also perform row-wise product computation as demonstrated in the code below:

```
import numpy as np
arr = np.array([[15, np.nan, 30],
[10, np.nan, np.nan]])
product = np.nanprod(arr, axis=1)
print("original array: ", arr)
print("resulting array: ", product)
```

Result:

```
original array: [[15. nan 30.]
[10. nan nan]]
resulting array: [450. 10.]
```

Similarly, the resulting expression along the one axis:

$$

Row[0] \rightarrow 15 * 1 * 30 = 450\

Row[1] \rightarrow 10 * 1 * 1 = 10

$$

## Using the `nanprod()`

Function on `NaN`

array

The example below calls the `nanprod()`

function on an array containing all `NaN`

values.

```
import numpy as np
arr = np.array([[np.nan, np.nan, np.nan],
[np.nan, np.nan, np.nan]])
product = np.nanprod(arr, axis=None)
print("original array: ", arr)
print("resulting array: ", product)
```

Output:

```
original array: [[nan nan nan]
[nan nan nan]]
resulting array: 1.0
```

As you can guess, passing an array of `NaN`

values to the `nanprod`

function returns 1.

## Conclusion

This tutorial discussed how to use `NumPy.nanprod()`

function to calculate the product of elements in a given input array while treating `NaN`

values as 1.