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]])

Transpose using zip(*l) to get a list of columns, then sort each individual column, then transpose back:

list(zip(*(sorted(col) for col in zip(*initial_table))))

Step by step output:

print(list(zip(*initial_table)))
# [(1, 5, 2), (2, 4, 3), (3, 3, 4)]
print([sorted(l) for l in zip(*initial_table)])
# [[1, 2, 5], [2, 3, 4], [3, 3, 4]]
print(list(zip(*(sorted(col) for col in zip(*initial_table)))))
# [(1, 2, 3), (2, 3, 3), (5, 4, 4)]