search
Search
Unlock 100+ guides
search toc
close
account_circle
Profile
exit_to_app
Sign out
What does this mean?
Why is this true?
Give me some examples!
search
keyboard_voice
close
Searching Tips
Search for a recipe:
"Creating a table in MySQL"
Search for an API documentation: "@append"
Search for code: "!dataframe"
Apply a tag filter: "#python"
Useful Shortcuts
/ to open search panel
Esc to close search panel
to navigate between search results
d to clear all current filters
Enter to expand content preview
Doc Search
Code Search Beta
SORRY NOTHING FOUND!
mic
Start speaking...
Voice search is only supported in Safari and Chrome.
Shrink
Navigate to

# NumPy | argsort method

schedule Aug 12, 2023
Last updated
local_offer
PythonNumPy
Tags
mode_heat
Master the mathematics behind data science with 100+ top-tier guides
Start your free 7-days trial now!

Numpy's `argsort(~)` method returns the integer indices of the sorted copy of the input array.

# Parameters

1. `a` | `array_like`

The input array.

2. `axis` | `int` | `optional`

The axis along which to sort the input array. For 2D arrays, the allowed values are as follows:

Value

Meaning

`None`

Flattens the array and sorts it

`0`

Sorts column-wise

`1`

Sorts row-wise

By default, `axis=-1` which means that sorting is performed only on the last axis. For 2D arrays, this means that the default sorting behaviour is row-wise.

3. `kind` | `string` | `optional`

The sorting algorithm to use. Currently, Numpy offers the following choices:

Kind

Speed

Worst case

Memory

Stable

quicksort

1 (fast)

O(n^2)

0

no

mergesort

2

O(nlogn)

~n/2

yes

timsort

2

O(nlogn)

~n/2

yes

heapsort

3 (slow)

O(nlogn)

0

no

Sorting algorithms that are "stable" retain the relative ordering of duplicate values. For instance, suppose you are sorting the array `[(2,3), (2,2), (4,5)]` by the first element of each tuple. We have a duplicate value of 2 here, so stable sorting algorithms ensure that `(2,3)` will always come before `(2,2)` since that is how they are ordered originally. Unstable searches provide no guarantee that such ordering is retained.

By default, `kind="quicksort"`.

WARNING

The datatype determines whether mergesort or timsort is used

Despite the fact that you can specify either mergesort or timsort, Numpy will ultimately make its decision on the data-type of the array. There is currently no way of enforcing your choice of algorithm between the two.

NOTE

Timsort offers the best performance for sorted or nearly sorted arrays

Timsort is the latest searching algorithm added to Numpy (version 1.17). Timsort is still nearly as efficient as mergesort for randomly arranged numbers.

4. `order` | `string` or `list` of `strings` | `optional`

The field to sort by. This is only applicable to structured arrays - see our example below for clarification.

# Return value

A Numpy array containing the indices of the sorted copy of the input array.

# Examples

## Sorting one-dimensional arrays

``` x = np.array([7,5,8,6])np.sort(x) array([1, 3, 0, 2]) ```

## Sorting two-dimensional arrays

Suppose we have the following 2D array:

``` x = np.array([[7,5],[8,6]])x array([[7, 5], [8, 6]]) ```

### Sorting the flattened array

``` np.argsort(x, axis=None) array([1, 3, 0, 2]) ```

### Sorting row-wise

``` np.argsort(x) # or explicitly set axis=1 array([[1, 0], [1, 0]]) ```

### Sorting column-wise

``` np.argsort(x, axis=0) array([[0, 0], [1, 1]]) ```

## Specifying order for structured arrays

Suppose we have the following structured array:

``` dtype = [('name', 'S15'), ('age', int)]values = [('Bob', 35), ('Alex', 15),('Cathy', 24)]x = np.array(values, dtype)x array([(b'Bob', 35), (b'Alex', 15), (b'Cathy', 24)], dtype=[('name', 'S15'), ('age', '<i8')]) ```

Our array `x` consists of three tuples, with the 1st element as the `name`, and the 2nd element as the `age`.

To sort by `name`:

``` np.argsort(x, order="name") array([1, 0, 2]) ```

The returned array here contains the original indices of the tuple with `Alex`, `Bob` and then `Cathy`.

To sort by `age`:

``` np.argsort(x, order="age") array([1, 2, 0]) ```

The returned array here contains the original indices of the tuple with age 15, 24 and then 35.

You could also pass in an array of labels to sort by (e.g. `order=["name", "age"]`), which would sort the array by `name` first, and then by `age`.

Edited by 0 others
thumb_up
thumb_down
Comment
Citation
Ask a question or leave a feedback...
thumb_up
0
thumb_down
0
chat_bubble_outline
0
settings
Enjoy our search
Hit / to insta-search docs and recipes!