# partition() – Partial Sort in NumPy # partition() – Partial Sort in NumPy

Hi Enthusiastic Learners! In this article we will be studying about “partition() – partial sort in NumPy“. Have you ever wondered, if you are given an array and you only want `n` smallest numbers from your array instead of completely sorting it? Well, that is exactly the case where we should use `partition() - partial sort` & and we are calling partition() a partial sort because we actually will be sorting only few parts of given array or you can say getting a partition of `n` smallest values. Before jumping on to partition() – partial sort in NumPy, please check out other articles related to sorting in NumPy:

## partition() – Partial Sort Syntax

`np.partition(arr, pos, axis=-1, kind='introselect', order=None)`

Where,

• arr is the array which has to be sorted
• pos position in array.
• axis defines the axis along which you need to do sorting & -1 value means last axis.
• kind gives you liberty to choose sorting algorithm. Default algo ‘introselect’
• order — if arr is a structured array, this argument specifies which fields to compare first, second, etc.

Let’s begin with creating a array `arr`.

In :
```import numpy as np

arr = np.array([3, 7, 4, 2, 8, 9, 0, 18, 1])
print("-- Base Array --")
print(arr)
```
```-- Base Array --
[ 3  7  4  2  8  9  0 18  1]
```

Sorting array for `pos = 3`. Now, partition() will create a copy of original array and will arrange number in such a way such that till `pos` all values will be the smallest values in array & after that position other values will be as it is.

Note that they may not be ordered. Its just that, till `pos = 3`, that is `4` elements as indexing in arrays starts from `0`, we will be getting 4 smallest values & remaining values will be shifted as it is towards right and there is no order in sorted values.

Syntax for it will be — `np.partition(arr, 2)`

In :
```sort_for_3 = np.partition(arr, 3)

print("-- Sorted Array till 3rd Position --")
print(sort_for_3)
```
```-- Sorted Array till 3rd Position --
[ 2  1  0  3  7  9  4 18  8]
```

As, we can clearly from above example, that 1st four elements (till pos = 3) are smallest among complete array & other values are just shifted towards right in the same order they naturally were. Also, there is no order in sorted values.

#### partition() on 2-dimensional array

We can do partial sort for 2-D arrays as well & we can choose axis along which we want values to be sorted.

Let’s begin with creating a 2-D array

In :
```arr_2d = np.random.randint(0, 10, (4, 6))

print("-- 2D Array --\n")
print(arr_2d)
```
```-- 2D Array --

[[2 5 6 1 6 3]
[7 0 2 6 0 0]
[1 6 2 6 4 3]
[9 5 9 6 9 3]]
```

Get 2 smallest values for each row of array.

Syntax for it will be — `np.partition(arr_2d, 1, axis=1)`

In :
```sorted_2d = np.partition(arr_2d, 1, axis=1)

print("-- Partially Sorted 2D Array -- \n")
print(sorted_2d)
```
```-- Partially Sorted 2D Array --

[[1 2 6 5 6 3]
[0 0 2 6 7 0]
[1 2 6 6 4 3]
[3 5 9 6 9 9]]
```

From above example it clear, that for each row we are getting smallest value till index (pos) value = 1, that is 2 smallest elements in each row.

Stay tuned & keep learning! In our next post we will be covering more sorting techniques that can be achieved in NumPy.

This site uses Akismet to reduce spam. Learn how your comment data is processed.