NumPy, or Numerical Python, is a widely used library in the field of data science and scientific computing. It provides an array object that allows for efficient computation of large amounts of numerical data.
One of the most common tasks when working with arrays is sorting them. In this article, we will explore the three different techniques for sorting arrays in NumPy, namely: sort(), argsort(), and lexsort().
NumPy sort() function:
The sort() function is perhaps the simplest way to sort a NumPy array. When used without any parameters, it sorts the array in ascending order.
Here’s an example:
import numpy as np
arr = np.array([3, 1, 4, 5, 2])
arr = np.sort(arr)
print(arr)
Output: [1 2 3 4 5]
By default, sort() works on the flattened array. However, you can also specify an axis parameter to sort along a specific axis.
For example, if you have a two-dimensional array and you want to sort each row, you can do this:
arr = np.array([[3, 1, 2], [4, 5, 6]])
arr = np.sort(arr, axis=1)
Output: [[1 2 3]
[4 5 6]]
Additionally, sort() function can be used to sort the array in descending order by setting the optional parameter ‘kind’ to ‘quicksort’ and specifying the order of sorting as ‘-1’.
arr = np.array([3, 1, 4, 5, 2])
arr = np.sort(arr, kind=’quicksort’)[::-1]
print(arr)
Output: [5 4 3 2 1]
Row-wise sorting:
In some cases, you may want to sort an array row-wise rather than column wise. In this situation, you can simply transpose the array, sort it, and then transpose it back.
Here’s an example:
arr = np.array([[3, 1, 2], [4, 5, 6]])
arr = np.transpose(arr)
arr = np.sort(arr)
arr = np.transpose(arr)
print(arr)
Output: [[1 2 3]
[4 5 6]]
NumPy argsort() function:
The argsort() function is used to return the indices that would sort an array. Here’s an example:
arr = np.array([3, 1, 4, 5, 2])
idx = np.argsort(arr)
print(idx)
Output: [1 4 0 2 3]
You can see that the original array was sorted in ascending order, and the indices of the elements were returned. This can be useful in cases where you want to sort an array, but you also need to keep track of where each value came from.
NumPy lexsort() function:
The lexsort() function is used to sort a sequence of keys. It performs an indirect sort on multiple keys in the order specified.
Here’s an example:
arr1 = np.array([3, 1, 4, 5, 2])
arr2 = np.array([50, 30, 40, 10, 20])
idx = np.lexsort((arr1, arr2))
print(idx)
Output: [1 4 0 2 3]
You can see that the arrays were sorted according to the order given in the tuple (arr1, arr2). The first key (arr1) was used for the primary sorting, and the second key (arr2) was used for the secondary sorting.
In conclusion, sorting arrays is an important task in handling data using NumPy. Using the sort(), argsort(), and lexsort() functions, NumPy users can sort their arrays in various ways to suit their needs. By utilizing the different parameters for each function, one can sort their data in both ascending and descending order as well as along specific rows or axes as required.
3) NumPy argsort() function
Sorting and obtaining sorted index values:
The argsort() function takes an array as input and returns the indices that would sort the array in ascending order. This is useful when you want to sort an array, but you also need to keep track of where each element came from.
In some cases, you may not want to sort the entire array itself but rather only obtain the sorted index values. For example, you may want to sort an array but retain the original data order.
In such cases, sorting the array and then using the sorted index values to extract the sorted array elements can be useful.
Obtaining sorted array elements using sorted index values:
Once you have obtained the indices that would sort the array, you can use them to obtain the sorted array elements.
One way to do this is to use array indexing. Here’s an example:
arr = np.array([3, 1, 4, 5, 2])
idx = np.argsort(arr)
sorted_arr = arr[idx]
print(sorted_arr)
Output: [1 2 3 4 5]
You can see that the sorted index values obtained using argsort() are used to obtain the sorted array elements using array indexing. This can be useful in cases where you want to sort an array, but you also need to keep track of where each value came from.
Another way to obtain the sorted array elements is to use the take() function. Here’s an example:
arr = np.array([3, 1, 4, 5, 2])
idx = np.argsort(arr)
sorted_arr = np.take(arr, idx)
print(sorted_arr)
Output: [1 2 3 4 5]
You can see that the take() function is used to extract the sorted array elements based on the sorted index values obtained using argsort(). This can be useful if you have multiple arrays that need to be sorted in the same order.
4) NumPy lexsort() function
Sorting with two arrays:
Often, you may need to sort an array based on multiple keys. In such cases, the lexsort() function can be used.
The function takes a tuple of arrays as input and returns the indices that would sort the arrays in ascending order, based on the order of the keys in the tuple. Here’s an example:
arr1 = np.array([3, 1, 4, 5, 2])
arr2 = np.array([50, 30, 40, 10, 20])
idx = np.lexsort((arr1, arr2))
print(idx)
Output: [1 4 0 2 3]
You can see that the arrays were sorted according to the order given in the tuple (arr1, arr2). The first key (arr1) was used for the primary sorting, and the second key (arr2) was used for the secondary sorting.
The lexsort() function can be used with more than two arrays. Here’s an example:
arr1 = np.array([3, 1, 4, 5, 2])
arr2 = np.array([50, 30, 40, 10, 20])
arr3 = np.array([5, 10, 15, 20, 25])
idx = np.lexsort((arr1, arr2, arr3))
print(idx)
Output: [1 4 0 2 3]
You can see that the arrays were sorted according to the order given in the tuple (arr1, arr2, arr3). The first key (arr1) was used for the primary sorting, the second key (arr2) was used for the secondary sorting, and the third key (arr3) was used for the tertiary sorting.
In conclusion, the argsort() and lexsort() functions are powerful tools for sorting arrays in NumPy. The argsort() function can be used to obtain sorted index values for an array, and these index values can be used to extract the sorted array elements. The lexsort() function can be used to sort arrays based on multiple keys, making it a flexible tool for sorting complex datasets.
By utilizing these functions, data analysts can sort and organize their arrays easily and efficiently. In this article, we explored the three different techniques for sorting arrays in NumPy, namely sort(), argsort(), and lexsort().
We learned how to sort arrays in ascending and descending order, along specific rows or axes. We also understood how argsort() can be used to obtain sorted index values, which can be further used to extract sorted array elements.
Lastly, we saw how lexsort() function is used to sort arrays based on multiple keys, making it a flexible tool for sorting complex datasets. These functions are powerful tools widely used in scientific computing and are essential for data analysts to efficiently sort and organize their arrays.
By utilizing these functions, developers can optimize their code and perform tasks with minimal memory and computation time.