append() creates a new array which can be the old array with the appended element.

I think it's more normal to use the proper method for adding an element:

a = numpy.append(a, a[0])

Nest the arrays so that they have more than one axis, and then specify the axis when using append.

import numpy as np
a = np.array([[1, 2]]) # note the braces
b = np.array([[3, 4]])
c = np.array([[5, 6]])

d = np.append(a, b, axis=0)
print(d)
# [[1 2]
#  [3 4]]

e = np.append(d, c, axis=0)
print(e)
# [[1 2]
#  [3 4]
#  [5 6]]

Alternately, if you stick with lists, use numpy.vstack:

import numpy as np
a = [1, 2]
b = [3, 4]
c = [5, 6]

d = np.vstack([a, b])
print(d)
# [[1 2]
#  [3 4]]

e = np.vstack([d, c])
print(e)
# [[1 2]
#  [3 4]
#  [5 6]]

Appending to numpy arrays is very inefficient. This is because the interpreter needs to find and assign memory for the entire array at every single step. Depending on the application, there are much better strategies.

If you know the length in advance, it is best to pre-allocate the array using a function like np.ones, np.zeros, or np.empty.

desired_length = 500
results = np.empty(desired_length)
for i in range(desired_length):
    results[i] = i**2

If you don't know the length, it's probably more efficient to keep your results in a regular list and convert it to an array afterwards.

results = []
while condition:
    a = do_stuff()
    results.append(a)
results = np.array(results)

Here are some timings on my computer.

def pre_allocate():
    results = np.empty(5000)
    for i in range(5000):
        results[i] = i**2
    return results

def list_append():
    results = []
    for i in range(5000):
        results.append(i**2)
    return np.array(results)

def numpy_append():
    results = np.array([])
    for i in range(5000):
        np.append(results, i**2)
    return results

%timeit pre_allocate()
# 100 loops, best of 3: 2.42 ms per loop

%timeit list_append()
# 100 loops, best of 3: 2.5 ms per loop

%timeit numpy_append()
# 10 loops, best of 3: 48.4 ms per loop

So you can see that both pre-allocating and using a list then converting are much faster.

The problem that stack functions don't work, is that they need that the row added is of the same size of the already present rows. Using np.array([[]]), the first row is has a length of zero, which means that you can only add rows that also have length zero.

In order to solve this, we need to tell Numpy that the first row is of size two and not zero. The array thus needs to be of size (0, 2) and not (0, 0). This can be done using one of the array-initializing functions that accept size arguments, like empty, zeros or ones. Which function does not matter, as there are no spaces to fill.

Then you can use one of the functions mentioned in comments, like vstack or stack. The code thus becomes:

import numpy as np
all_coordinates = np.zeros((0, 2))

for y in range(2):
    for x in range(2):
        coordinate = np.array([[x,y]])

        # append
        all_coordinates = np.vstack((all_coordinates, coordinate))

print(all_coordinates)