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.
If you know the size of the array at the end of the run, then it is going to be much faster to pre-allocate an array of the appropriate size and then set the values. If you do need to append on-the fly, it's probably better to try to not do this one element at a time, instead appending as few times as possible to avoid generating many copies over and over again. You might also want to do some profiling of the difference in timings of np.append, np.hstack, np.concatenate. etc.
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])
When appending only once or once every now and again, using np.append on your array should be fine. The drawback of this approach is that memory is allocated for a completely new array every time it is called. When growing an array for a significant amount of samples it would be better to either pre-allocate the array (if the total size is known) or to append to a list and convert to an array afterward.
Using np.append:
b = np.array([0])
for k in range(int(10e4)):
b = np.append(b, k)
1.2 s ± 16.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
Using python list converting to array afterward:
d = [0]
for k in range(int(10e4)):
d.append(k)
f = np.array(d)
13.5 ms ± 277 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
Pre-allocating numpy array:
e = np.zeros((n,))
for k in range(n):
e[k] = k
9.92 ms ± 752 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
When the final size is unkown pre-allocating is difficult, I tried pre-allocating in chunks of 50 but it did not come close to using a list.
85.1 ms ± 561 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)