# numpy.mod() in Python: Introduction, Syntax & Examples

The numpy.mod() function in Python is a part of the NumPy library used for various numerical and mathematical operations. It is used to compute the element-wise remainder of the division between two arrays.

In this article, we will understand Python numpy.mod() function, its syntax, and demonstrate it with various examples. Let’s get started.

## Syntax of numpy.mod() Function

Let us get started by understanding the fundamental constituents of the numpy.mod() function with the help of its syntax given below.

Syntax:

```numpy.mod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None)
```

Parameters:

• x1: This is the dividend array or the scalar value.
• x2: This is the divisor array or the scalar value.
• out (optional): This is an optional parameter that specifies the location where the result should be stored. If not provided, a new array will be created.
• where (optional): This parameter is used for conditional execution. If provided, only the elements where the condition is True will be included in the result.
• casting (optional): This parameter controls what kind of data casting may occur. The default is ‘same_kind’, which means that only casting between similar kinds (e.g., float to float) is allowed.
• order (optional): Specifies the memory layout of the result. The default is ‘K’ which means the order is determined by the input array’s memory layout.
• dtype (optional): This parameter allows us to set the data type of the output array. If not specified, it is determined by the data types of the input arrays.

Return:

The numpy.mod() function returns an array with the same shape as the input arrays, where each element is the remainder of the corresponding elements in x1 divided by x2.

## Examples of numpy.mod() Function

Let us now look at some examples to demonstrate the use of numpy.mod() function in Python.

### Modulus of Two Arrays

Let’s start computing the reminders by passing one-dimensional arrays into the numpy.mod() function.

Example:

```import numpy as np

ar1 = np.array([180, 90, 160, 290])
ar2 = np.array([6, 25, 12, 12])

result = np.mod(ar1, ar2)

print(result)
```

In the above code, we first imported the NumPy library as np and then by using it we created two arrays: ar1 and ar2. Then we passed these two arrays in the nump.mod() function which will be responsible for returning the array of remainders and then we saved the outcome into the result variable.

Output:

Here we can see that the numpy.modf() function does the element-wise operation between the two arrays ar1 and ar2 by dividing each item from the array ar1 with the corresponding item of the second array ar2 and returns us the array of remainders.

### Storing the Output Array Inside a Specific Array

In this example, let’s try to store our output array inside a specified array using the ‘out’ parameter.

Example:

```import numpy as np

ar1= np.array([8,12,87,14])
ar2= np.array([5,90,36,6])

result = np.zeros_like(ar1)
np.mod(ar1, ar2, out=result)

print(result)
```

Firstly like above we created two arrays: ar1 and ar2 for performing the operation on them. Then we created an array filled with zeros with the same shape as the ar1 using numpy.zeros_like() function and stored the outcome in the result variable. Then we passed the result array to the out parameter in the numpy.mod() function along with both the arrays means after performing the operation on ar1 and ar2 the outcome from the operation will be stored in the result array.

Output:

### Deciding on Which Items the Operation Should Be Performed

In this example, we will perform the mod operation by filtering the elements from the arrays by passing the ‘where’ parameter in the numpy.mod() function.

Example:

```import numpy as np

ar1 = np.array([6,13,117,8,110,123])
ar2 = np.array([3,2,11,65,54,4])

condAr = np.array([True, False, True, False, True,False])
result = np.mod(ar1, ar2, where=condAr)

print(result)
```

This time we have created a boolean array that contains boolean data type elements in it for doing the operation. Then we passed this boolean array condAr to the ‘where’ parameter in the numpy.mod() function which decides on which elements from the arrays: ar1 and ar2 the operation should be performed.

That means the first element of the condAr is True that’s why the mod operation between both the arrays ar1 and ar2 will be performed and the outcome will be returned in the result variable. In the same way, the second element of condAr is False so the mod operation will not be performed between the arrays so the elements from the array ar2 will be returned as it is in the result variable.

Output:

### Passing the ‘dtype’ Parameter in the numpy.mod() Function

As we know in numpy.mod() function the default datatype of the output array is the same as the datatype of our input arrays. So let’s change the datatype of our output array by passing parameter ‘dtype’ in the numpy.mod() function.

Example:

```import numpy as np

ar1 = np.array([4, 15, 20, 12, 11])
ar2 = np.array([3, 2, 4, 5, 7])

result = np.mod(ar1, ar2, dtype=np.float64)

print(result)
```

Output:

Here we have taken the input arrays: ar1 and ar2 of integer datatype. But we can see that the elements of our output array are of type float because we have passed float to the ‘dtype’ parameter in the numpy.mod() function.

## Conclusion

In this tutorial, we have discussed numpy.mod() function provided by Python’s NumPy library, its syntax, and parameters, and also explored a few examples to get an understanding of it. After reading this tutorial, we hope you can easily get the element-wise remainder of the division between two NumPy arrays.

Read More: numpy.reciprocal() in Python – Get Reciprocal of Array Elements

## Reference

https://numpy.org/doc/stable/reference/generated/numpy.mod.html

Articles: 44