1. Python already sorts numbers numerically. If you want lexigraphic sort, you'd need to convert numbers to strings.

2. Easiest way to sort by multiple columns is by employing the fact that Python guarantees sorts are stable - which means order of elements is kept in case they are tied in regards to sorting key. Using that, you can sort from least significant to most significant key, resulting in expected output:

res = sorted(
        sorted(
            sorted(
                sorted(arr, key = lambda x: x[3]),
                key = lambda x: x[2]),
            key = lambda x: x[1]),
        key = lambda x: x[0])

Output:

[96, 132, 122, 112]
[96, 132, 329, 114]
[130, 175, 75, 152]
[130, 175, 182, 152]
[174, 218, 141, 196]
[174, 218, 328, 194]
[661, 701, 21, 683]
[707, 746, 375, 724]
[768, 806, 26, 788]
[768, 806, 286, 787]
[894, 933, 80, 914]
[894, 933, 166, 913]
[957, 998, 305, 980]
[957, 998, 394, 974]

Yes. The sorted built-in accepts a key argument:

sorted(li,key=lambda x: x[1])
Out[31]: [['Jason', 1], ['John', 2], ['Jim', 9]]

note that sorted returns a new list. If you want to sort in-place, use the .sort method of your list (which also, conveniently, accepts a key argument).

or alternatively,

from operator import itemgetter
sorted(li,key=itemgetter(1))
Out[33]: [['Jason', 1], ['John', 2], ['Jim', 9]]

Read more on the python wiki.

Using lexsort:

import numpy as np    
a = np.array([(3, 2), (6, 2), (3, 6), (3, 4), (5, 3)])

ind = np.lexsort((a[:,1],a[:,0]))    

a[ind]
# array([[3, 2],
#       [3, 4],
#       [3, 6],
#       [5, 3],
#       [6, 2]])

a.ravel() returns a view if a is C_CONTIGUOUS. If that is true, @ars's method, slightly modifed by using ravel instead of flatten, yields a nice way to sort a in-place:

a = np.array([(3, 2), (6, 2), (3, 6), (3, 4), (5, 3)])
dt = [('col1', a.dtype),('col2', a.dtype)]
assert a.flags['C_CONTIGUOUS']
b = a.ravel().view(dt)
b.sort(order=['col1','col2'])

Since b is a view of a, sorting b sorts a as well:

print(a)
# [[3 2]
#  [3 4]
#  [3 6]
#  [5 3]
#  [6 2]]

Numpy includes a native function for sub-sorting by columns, lexsort:

idx = np.lexsort((arr[:,0], arr[:,1]))
arr_sorted = arr[idx]

Alternatively, you can use pandas syntax if you're more familiar; this will have some memory/time overhead but should be small for < 1m rows:

arr = [
    [5,  0],
    [3,  1],
    [7,  0],
    [2,  1]
]
df = pd.DataFrame(data=arr).sort_values([1,0])
arr_sorted = df.to_numpy()

output (both):

array([[5, 0],
       [7, 0],
       [2, 1],
       [3, 1]])

Use .argsort() it returns an numpy.array of indices that sort the given numpy.array. You call it as a function or as a method on your array. For example, suppose you have

import numpy as np

arr = np.array([[-0.30565392, -0.96605562],
                [ 0.85331367, -2.62963495],
                [ 0.87839643, -0.28283675],
                [ 0.72676698,  0.93213482],
                [-0.52007354,  0.27752806],
                [-0.08701666,  0.22764316],
                [-1.78897817,  0.50737573],
                [ 0.62260038, -1.96012161],
                [-1.98231706,  0.36523876],
                [-1.07587382, -2.3022289 ]])

You can now call .argsort() on the column you want to sort, and it will give you an array of row indices that sort that particular column which you can pass as an index to your original array.

>>> arr[arr[:, 1].argsort()]
array([[ 0.85331367, -2.62963495],
       [-1.07587382, -2.3022289 ],
       [ 0.62260038, -1.96012161],
       [-0.30565392, -0.96605562],
       [ 0.87839643, -0.28283675],
       [-0.08701666,  0.22764316],
       [-0.52007354,  0.27752806],
       [-1.98231706,  0.36523876],
       [-1.78897817,  0.50737573],
       [ 0.72676698,  0.93213482]])

You can equivalently use numpy.argsort()

>>> arr[np.argsort(arr[:, 1])]
array([[ 0.85331367, -2.62963495],
       [-1.07587382, -2.3022289 ],
       [ 0.62260038, -1.96012161],
       [-0.30565392, -0.96605562],
       [ 0.87839643, -0.28283675],
       [-0.08701666,  0.22764316],
       [-0.52007354,  0.27752806],
       [-1.98231706,  0.36523876],
       [-1.78897817,  0.50737573],
       [ 0.72676698,  0.93213482]])