Time and again, we recommend collecting the arrays in a list, and making the final array with one call. That's more efficient, and usually easier to get right.

alist = []
for item in sorted_arrays:
    alist.append(get_array(item)

or

alist = [get_array(item) for item in sorted_arrays]

There are various ways of assembling the list. Since you want columns, and assuming get_array produces equal sized 1d arrays:

arr = np.column_stack(alist)

Collecting them in rows and transposing that works too:

arr = np.array(alist).T
arr = np.vstack(alist).T
arr = np.stack(alist).T
arr = np.stack(alist, axis=1)

If the arrays are already 2d

arr = np.concatenate(alist, axis=1)

All the stack variations use concatenate, just varying in how they tweak the shape(s) of the input arrays. The key to using concatenate is to understand the dimensions and shapes, and how to add dimensions as needed. That should, soon or later, become fluent in that kind of coding.

If they vary in shape or dimensions, things get messier.

Equally good is to put the arrays in a pre-allocated array. But you need to know the desired final shape

arr = np.zeros((m,n), dtype)
for i, item in enumerate(sorted_arrays):
    arr[:,i] = get_array(item)

n is len(sorted_arrays), and m is the length of one of get_array(item). You also need to know the expected dtype (int, float etc).

hstack stacks horizontally, vstack stacks vertically:

The problem with hstack is that when you append a column you need convert it from 1d-array to a 2d-column first, because 1d array is normally interpreted as a vector-row in 2d context in numpy:

Use with AIa = np.ones(2)          # 2d, shape = (2, 2)
b = np.array([0, 0])    # 1d, shape = (2,)

hstack((a, b)) -> dimensions mismatch error

So either hstack((a, b[:, None])) or column_stack((a, b)):

where None serves as a shortcut for np.newaxis.

If you're stacking two vectors, you've got three options:

As for the (undocumented) row_stack, it is just a synonym of vstack, as 1d array is ready to serve as a matrix row without extra work.

The case of 3D and above proved to be too huge to fit in the answer, so I've included it in the article called Numpy Illustrated.