if you know the number of columns before hand:

>>> xs = np.array([[1,2,3,4,5],[10,20,30,40,50]])
>>> ys = np.array([], dtype=np.int64).reshape(0,5)
>>> ys
array([], shape=(0, 5), dtype=int64)
>>> np.vstack([ys, xs])
array([[  1.,   2.,   3.,   4.,   5.],
       [ 10.,  20.,  30.,  40.,  50.]])

if not:

>>> ys = np.array([])
>>> ys = np.vstack([ys, xs]) if ys.size else xs
array([[ 1,  2,  3,  4,  5],
       [10, 20, 30, 40, 50]])

The way to "start" the array that you want is:

arr = np.empty((0,3), int)

Which is an empty array but it has the proper dimensionality.

>>> arr
array([], shape=(0, 3), dtype=int64)

Then be sure to append along axis 0:

arr = np.append(arr, np.array([[1,2,3]]), axis=0)
arr = np.append(arr, np.array([[4,5,6]]), axis=0)

But, @jonrsharpe is right. In fact, if you're going to be appending in a loop, it would be much faster to append to a list as in your first example, then convert to a numpy array at the end, since you're really not using numpy as intended during the loop:

In [210]: %%timeit
   .....: l = []
   .....: for i in xrange(1000):
   .....:     l.append([3*i+1,3*i+2,3*i+3])
   .....: l = np.asarray(l)
   .....: 
1000 loops, best of 3: 1.18 ms per loop

In [211]: %%timeit
   .....: a = np.empty((0,3), int)
   .....: for i in xrange(1000):
   .....:     a = np.append(a, 3*i+np.array([[1,2,3]]), 0)
   .....: 
100 loops, best of 3: 18.5 ms per loop

In [214]: np.allclose(a, l)
Out[214]: True

The numpythonic way to do it depends on your application, but it would be more like:

In [220]: timeit n = np.arange(1,3001).reshape(1000,3)
100000 loops, best of 3: 5.93 µs per loop

In [221]: np.allclose(a, n)
Out[221]: True

Simply you can use np.append() But note that you need to pass the indices ina list like [[1], [1, 2], []] :

>>> a= np.array([[1], [1, 2], []], dtype=object)
>>> np.append(a,np.array([[],[22]]))
array([[1], [1, 2], [], [], [22]], dtype=object)

Your first use, with list append:

In [146]: alist=[]                                                              
In [147]: for i in range(4): 
     ...:     alist.append(np.arange(i,i+3)) 
     ...:                                                                       
In [148]: alist                                                                 
Out[148]: [array([0, 1, 2]), array([1, 2, 3]), array([2, 3, 4]), array([3, 4, 5])]

and make the array:

In [149]: np.array(alist)                                                       
Out[149]: 
array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4],
       [3, 4, 5]])

or since vstack is happy with a list of arrays:

In [150]: np.vstack(alist)                                                      
Out[150]: 
array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4],
       [3, 4, 5]])

You could use vstack in the loop:

In [151]: arr = np.zeros((0,3),int)                                             
In [152]: for i in range(4): 
     ...:     arr = np.vstack((arr, np.arange(i,i+3))) 
     ...:                                                                       
In [153]: arr                                                                   
Out[153]: 
array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4],
       [3, 4, 5]])

This has two problems:

• it is slower; list append operates in-place simply adding a pointer to the list. vstack makes whole new array each time, with a full copy!

• it is harder to initialize, as you found out. You actually have to understand array shapes, and what concatenate does when it combines 2 or more arrays. Here I started with a (0,3) array.

That is the wrong mental model for using NumPy efficiently. NumPy arrays are stored in contiguous blocks of memory. To append rows or columns to an existing array, the entire array needs to be copied to a new block of memory, creating gaps for the new elements to be stored. This is very inefficient if done repeatedly.

Instead of appending rows, allocate a suitably sized array, and then assign to it row-by-row:

>>> import numpy as np

>>> a = np.zeros(shape=(3, 2))
>>> a
array([[ 0.,  0.],
       [ 0.,  0.],
       [ 0.,  0.]])

>>> a[0] = [1, 2]
>>> a[1] = [3, 4]
>>> a[2] = [5, 6]

>>> a
array([[ 1.,  2.],
       [ 3.,  4.],
       [ 5.,  6.]])

Short answer

Use numpy.zeros instead of numpy.empty to get rid of the surprise garbage values in your new arrays.

details

The arrays created by numpy.zeros have all of their elements initialized to a "zero value". For arrays with dtype=str, this will be the empty string ''.

From the Numpy docs:

Notes

empty, unlike zeros, does not set the array values to zero, and may therefore be marginally faster. On the other hand, it requires the user to manually set all the values in the array, and should be used with caution.

The fact that it works in Python 3 (but not Python 2) is undefined behavior. Basically, it's a quirk of the implementation which the Numpy developers didn't plan. The best practice is to not rely on such things in your code. As you've seen, the outcome of an undefined behavior is not guaranteed to be consistent across versions, implementations, different computers that you run your code on, etc.

Also, it sounds like you might be a little bit confused about how Numpy arrays work. A numpy array starts off at a fixed size when you create it. This is unlike a normal Python list [], which grows dynamically as you add values to it.

Also, you don't need both index and i in _resize_array. Just use one or the other, like this:

for i in range(self.size):
    new_array[i] = self.array[i]

Aside from that your code is fine.

If by empty array, you mean an array with 0 dimensions, you can simply convert to a NumPy array an empty list:

import numpy as np

np.array([])
# array([], dtype=float64)

or use any of the NumPy's initialization functions with a (0,) or 0 shape, e.g.:

np.zeros((0,))
# array([], dtype=float64)

np.ones((0,))
# array([], dtype=float64)

np.empty((0,))
# array([], dtype=float64)

np.full((0,), 0.0)                                                                          
# array([], dtype=float64)

etc.

If by empty you mean an array of given size but not initialized (i.e. you only ask the OS for the required memory), you can use np.empty() specifying the size you need, e.g.:

np.empty((2, 3))
# array([[1.46643506e-316, 0.00000000e+000, 0.00000000e+000],
#        [0.00000000e+000, 0.00000000e+000, 0.00000000e+000]])

You need to append the two numbers inside another list because of the second dim.

arr = np.empty((0,2),int)
arr = np.append(arr, [[0, 1]], axis=0)
arr = np.append(arr, [[1, 1]], axis=0)
arr = np.append(arr, [[5, 1]], axis=0)

arr should now be:

array([[0, 1],
       [1, 1],
       [5, 1]])

Like Oniow said, concatenate does exactly what you saw.

If you want 'default values' that will differ from regular scalar elements, I would suggest you to initialize your array with NaNs (as your 'default value'). If I understand your question, you want to merge matrices so that regular scalars will override your 'default value' elements.

Anyway I suggest you to add the following:

def get_default(size_x,size_y):
    # returns a new matrix filled with 'default values'
    tmp = np.empty([size_x,size_y])
    tmp.fill(np.nan)
    return tmp

And also:

def merge(a, b):
    l = lambda x, y: y if np.isnan(x) else x
    l = np.vectorize(l)
    return map(l, a, b)

Note that if you merge 2 matrices, and both values are non 'default' then it will take the value of the left matrix.

Using NaNs as default value, will result the expected behavior from a default value, for example all math ops will result 'default' as this value indicates that you don't really care about this index in the matrix.