The NumPy module of Python provides a method for clipping the elements of an array. **The method is called numpy.clip().** Let’s explore the numpy.clip method in further detail.

*Also read: How to Use Numpy Minimum on Arrays?*

## What is the Numpy.clip() method?

The Numpy.clip() method is a function that takes an array of numbers, a minimum, and a maximum value, and returns an array with all values outside of the specified range replaced with the min/max value specified.

This can be useful for making sure all values in an array are within a certain range, for example for scaling or normalizing data. It can also be used to limit the range of values in an array to a certain range.

### Defining numpy.clip()

Numpy is a powerful module for performing mathematical and scientific operations in Python. To use it, first ensure it is installed by typing ‘`pip3 install numpy`

‘ into your command prompt shell.

Once installed, you can use the ‘numpy.clip()’ function to limit the range of values in an array. This can be useful in certain data processing scenarios.

### Syntax of numpy.clip()

```
numpy.clip(array,Â array_min_element,Â array_max_element,Â out=None)Â
```

**The numpy.clip() methods takes three arguments:**

**array**: The array of values to be clipped.**array_min_element**: The minimum value that elements of the array are allowed to reach.**array_max_element**: The maximum value that elements of the array are allowed to reach.**out (optional)**: An optional output array.

## Working of clip() function

The clip() function is used to clip the elements of an array within a specified range. Here’s how it works:

- Specify the array and the range between the second and third parameters (array_Minimum_limit, array_maximum_limit).
- If all the elements in the original array are less than or equal to the minimum limit, they will be replaced and shown as the minimum limit.
- The rest of the elements will be compared with the maximum limit.
- If the element/s is less than the maximum limit, the value/s from the original array will be printed.
- If the element/s is equal to the maximum limit, ’10’ will be printed. If it is more than the maximum limit, it will be replaced with the maximum limit.

Note: The length of the original array and the clipped array will be the same.

## Examples of Numpy.clip() in action

Let’s start with the most basic example here so you can understand how this works. We’ll use the numpy.arange() method here.

```
import numpy as np
x= np.arange(12)
print("x:",x)
y = np.clip(x,2,12)
print("y:",y)
```

**Parameters used above**

`x: original_array`

An array containing elements to clip.`array_min_element, array_max_element`

:*Passing the limit range.*

Minimum and Maximum values are given for interval edges.**None**can be given for any of the edges, clipping will not work for the corresponding edge only**one**of the parameters can be None.`out: ndarray,`

*optional*

clip( ) function returns ndarray, the results will be stored in this array. It can be the original/input array in place of the clipping array. If it’s the input array it updates the values of the original array and stores the clipped values.- Returns :

An array with the elements of x(original array) where values <= Minimum limit is replaced with array_min_element and those with >= Maximum limit with array_max_element.

**For more understanding following are a few more examples with different inputs.**

### Example 1: Basic Array Clipping

This code creates an array of numbers (a) from 0 to 9 and then uses the Numpy.clip() method to create a new array (x) where all values outside of 4 and 8 are replaced with either 4 or 8. In this case, all values in the array x will be between 4 and 8, inclusive.

```
import numpy as np
a = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
x=np.clip(a, 4, 8)
print("a:",a)
print("x:",x)
```

### Example 2: When Minimum_limit > Maximum_limit

This code creates an array “a” of numbers ranging from 0 to 8. It then uses the Numpy.clip() method to create a new array “x” with all values outside of the range 1 to 8 replaced with the min/max value specified. In this case, all values less than 1 will be replaced with 1, and all values greater than 8 will be replaced with 8. So the resulting array “x” will contain the values 1, 2, 3, 4, 5, 6, 7, and 8.

```
import numpy as np
a = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8])
x=np.clip(a, 8, 1)
print("a:",a)
print("x:",x)
```

When `array_min`

is greater than `array_max,`

`clip`

returns an array in which all values are equal to *array_max*, as shown in the second example.

### Example 3: Using the ‘out’ parameter

This code imports the Numpy library and creates an array called ‘a’ with values from 0 to 8. Then, the Numpy.clip() method is used to clip the values in array ‘a’ to a range between 3 and 6.

The out argument means that the new array will overwrite the original array ‘a’. The result is that array ‘a’ now contains only the values 3, 4, 5 and 6.

```
import numpy as np
a = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8])
print("a:",a)
x=np.clip(a, 3, 6, out=a)
print("x:",x)
print("a:",a)
```

Here the input array gets **updated.**

### Example 4: Using List as Minimum Limit.

This code demonstrates the use of the Numpy.clip() method. It creates an array ‘a’ containing the numbers 0 to 9 and then uses the Numpy.clip() function to create a new array ‘x’ containing all the values in ‘a’, with any values outside of the range [3, 4, 1, 1, 1, 4, 4, 4, 4, 4] replaced with the min/max value of 6.

```
import numpy as np
a = np.arange(10)
x=np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 6)
print("a:",a)
print("x:",x)
```

## Summary

The Numpy.clip() method is a useful function for clipping the elements of an array to a certain range. It takes an array of numbers, a minimum, and a maximum value, and returns an array with all values outside of the specified range replaced with the min/max value specified. This can be used to limit the range of values in an array, as well as for scaling or normalizing data. The out parameter can be used to store the results in the input array, which can be useful for overwriting the original array with clipped values.