Either tell python to sort only on the first item

sorted(ls, key=lambda t: t[0])

Or convert the whole thing to a structured numpy array and ask numpy to sort it

ls_arr = np.array(ls, dtype=[('my_val', float), ('my_arr', float, 2)])
ls_arr.sort()

This second option only works if the arrays are always the same length.

np.argsort(A) is sorting each row of A separately. For example,

In [21]: np.argsort([[6,5,4],[3,2,1]])
Out[21]: 
array([[2, 1, 0],
       [2, 1, 0]])

Instead, you want to flatten your array into a 1-dimensional array of values, then argsort that. That can be done by setting the axis parameter to None (thanks to @Akavall for pointing this out):

In [23]: np.argsort(A, axis=None)
Out[23]: array([3, 0, 1, 2])

Then use np.unravel_index to recover the associated index in A.

In [14]: import numpy as np

In [15]: A = np.array([[7, 8], [9, 5]])   

In [4]: np.column_stack(np.unravel_index(np.argsort(A, axis=None)[::-1], A.shape))
Out[4]: 
array([[1, 0],
       [0, 1],
       [0, 0],
       [1, 1]])

Note, for NumPy version 1.5.1 or older, np.unravel_index raises a ValueError if passed an array-like object for its first argument. In that case, you could use a list comprehension:

In [17]: [np.unravel_index(p, A.shape) for p in np.argsort(A, axis=None)[::-1]]
Out[17]: [(1, 0), (0, 1), (0, 0), (1, 1)]

According to the documentation

Returns the indices that would sort an array.

• 2 is the index of 0.0.
• 3 is the index of 0.1.
• 1 is the index of 1.41.
• 0 is the index of 1.48.

In [55]: A = np.array([[0,1,2],[4,9,3],[5,8,7]])                                                                       

argsort with axis None to sort the whole thing:

In [56]: idx=np.argsort(A,None)                                                 
In [57]: idx                                                                    
Out[57]: array([0, 1, 2, 5, 3, 6, 8, 7, 4])

There are indices in the flat or raveled form of A

In [58]: A.flat[idx]                                                            
Out[58]: array([0, 1, 2, 3, 4, 5, 7, 8, 9])

3nd smallest:

In [59]: A.flat[idx[2]]                                                         
Out[59]: 2

We can get 2d indices with:

In [60]: np.unravel_index(idx,A.shape)                                          
Out[60]: (array([0, 0, 0, 1, 1, 2, 2, 2, 1]), array([0, 1, 2, 2, 0, 0, 2, 1, 1]))

I believe these values match your desired set of indices - but I have to convert them to tuple to do the indexing:

In [61]: np.transpose(np.unravel_index(idx,A.shape))                            
Out[61]: 
array([[0, 0],
       [0, 1],
       [0, 2],
       [1, 2],
       [1, 0],
       [2, 0],
       [2, 2],
       [2, 1],
       [1, 1]])
In [63]: A[tuple(_61[2])]                                                       
Out[63]: 2