The bottleneck module has a fast partial sort method that works directly with Numpy arrays: bottleneck.partition().

Note that bottleneck.partition() returns the actual values sorted, if you want the indexes of the sorted values (what numpy.argsort() returns) you should use bottleneck.argpartition().

I've benchmarked:

where a is a random 1,000,000-element array.

The timings were as follows:

Newer NumPy versions (1.8 and up) have a function called argpartition for this. To get the indices of the four largest elements, do

>>> ind = np.argpartition(a, -4)[-4:]>>> indarray([1, 5, 8, 0])

>>> top4 = a[ind]>>> top4array([4, 9, 6, 9])

Unlike argsort, this function runs in linear time in the worst case, but the returned indices are not sorted, as can be seen from the result of evaluating a[ind]. If you need that too, sort them afterwards:

To get the top-k elements in sorted order in this way takes O(n + k log k) time.

You can flatten the matrix and then sort it:

You can use np.partition in the same way as the question you linked: the sorting is already along the last axis:

I don't have access to bottleneck, so in this example I am using argsort, but you should be able to use it in the same way:

# Convert it into a 1D arraya_1d = a.flatten()

# Find the indices in the 1D arrayidx_1d = a_1d.argsort()[-N:]

# convert the idx_1d back into indices arrays for each dimensionx_idx, y_idx = np.unravel_index(idx_1d, a.shape)

# Check that we got the largest values.for x, y, in zip(x_idx, y_idx): print(a[x][y])

You can do this (each step is commented for clarity):

y = x.copy() #