Here I have an example program where a 2 loops implementation works and is crystal clear in its intent, a 1 loop implementation works and is, imho, slightly less clear and eventually a 0 (explicit, btw) loops implementation that, alas, is buggy.

My vote goes to the two loops... further, I'd like to be shown what's wrong with my 0 loops attempt

Code

import itertools

def pm(m):
    for row in m: print row

mat = []
n = 8
for i in range(n):
    mat.append(range(i*n, i*n+n))

# this is shorthand for your splitmat function
res = map(lambda (x,y):
          map(lambda z:z[y[0]:y[1]],mat[x[0]:x[1]]),
          itertools.product([(0,n/2),(n/2,n)],repeat=2))
pm(res)

print "\n2 cycles"
mat = []
for i, j in ((0,1),(2,3)):
    for a, b in zip(res[i],res[j]):
        mat.append(a+b)
pm(mat)

print "\n1 cycle"
mat = []
for i, j in ((0,1),(2,3)):
    map(lambda x: mat.append(x[0]+x[1]), zip(res[i],res[j]))
pm(mat)

print "\n0 cycles"
mat =  map(lambda i_j: 
       map(lambda x: x[0]+x[1], zip(res[i_j[0]],res[i_j[1]])), ((0,1),(2,3)))
pm(mat)

Output

[[0, 1, 2, 3], [8, 9, 10, 11], [16, 17, 18, 19], [24, 25, 26, 27]]
[[4, 5, 6, 7], [12, 13, 14, 15], [20, 21, 22, 23], [28, 29, 30, 31]]
[[32, 33, 34, 35], [40, 41, 42, 43], [48, 49, 50, 51], [56, 57, 58, 59]]
[[36, 37, 38, 39], [44, 45, 46, 47], [52, 53, 54, 55], [60, 61, 62, 63]]

2 cicli
[0, 1, 2, 3, 4, 5, 6, 7]
[8, 9, 10, 11, 12, 13, 14, 15]
[16, 17, 18, 19, 20, 21, 22, 23]
[24, 25, 26, 27, 28, 29, 30, 31]
[32, 33, 34, 35, 36, 37, 38, 39]
[40, 41, 42, 43, 44, 45, 46, 47]
[48, 49, 50, 51, 52, 53, 54, 55]
[56, 57, 58, 59, 60, 61, 62, 63]

1 ciclo
[0, 1, 2, 3, 4, 5, 6, 7]
[8, 9, 10, 11, 12, 13, 14, 15]
[16, 17, 18, 19, 20, 21, 22, 23]
[24, 25, 26, 27, 28, 29, 30, 31]
[32, 33, 34, 35, 36, 37, 38, 39]
[40, 41, 42, 43, 44, 45, 46, 47]
[48, 49, 50, 51, 52, 53, 54, 55]
[56, 57, 58, 59, 60, 61, 62, 63]

0 cicli
[[0, 1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, 14, 15], [16, 17, 18, 19, 20, 21, 22, 23], [24, 25, 26, 27, 28, 29, 30, 31]]
[[32, 33, 34, 35, 36, 37, 38, 39], [40, 41, 42, 43, 44, 45, 46, 47], [48, 49, 50, 51, 52, 53, 54, 55], [56, 57, 58, 59, 60, 61, 62, 63]]

Just initialize the array before you fill it with data. If you want you can allocate more space than needed and it will not take up more RAM because of the way numpy works.

A = np.zeros(R,C)
A[row] = [data]

The memory is used only once data is put into the array. Creating a new array from concatenating two will never finish on a dataset of any size, i.e. dataset > 1GB or so.

Instead of starting with

x = []

you can say

x = numpy.zeros([0, 3])    # 2-dimensional array with 0 rows and 3 columns

and then add rows this way:

x = numpy.vstack([x, a])
x = numpy.vstack([x, b])
x = numpy.vstack([x, c])

...but as user2357112 pointed out, it's much more efficient to start with a list, do x.append(each_array), and only concatenate the list of arrays into a single numpy.ndarray right at the end:

x = []
x.append(a)
x.append(b)
x.append(c)
x = numpy.vstack(x)

NB: numpy.concatenate([x,a]) was working in the direction you didn't expect because, although the default direction for numpy.concatenate is indeed axis=0, which is conventionally thought of as the row-to-row direction in 2-d arrays, your arrays a, b and c are not 2-d arrays and therefore cannot be thought of as single "rows" to start with. They only have dimension 0, so their existing elements vary along dimension 0—the same dimension along which you're concatenating. To do what you intend, you would either have to define them using double brackets to start with, as in a = numpy.array([[1,1,1]]) or convert them from their existing 1-dimensional state by saying b = b[numpy.newaxis, :] before concatenation. numpy.vstack does the latter for you implicitly.