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.
Answer from Roger Fan on Stack Overflowpython - Optimal way to append to numpy array - Stack Overflow
Issues with Optimization / Appending to a Numpy Array
python - Add single element to array in numpy - Stack Overflow
python - How to use the function numpy.append - Stack Overflow
Videos
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.
https://paste.ofcode.org/zpT6HK22LuswbXhTHZfUK6
I am working on a starter project which involves storing pixel coordinates for various "territories" (dictionaries) on a map. Because there are a huge amount of coordinates (33 million pixels), I have been trying to optimize the program so it uses less memory. I have been using numpy's int16 type and ndarray to save memory. The problem I am getting however, is with adding pixels to territories. Each territory (dictionary) has a "pixels" key with an array as a value, and to add pixels to that array I use the following method:
def addPixel(territory, pixel):
pixels = getProperty(territory, "pixels")
territory["pixels"] = numpy.append(pixels, pixel)This method, however, appears to be very slow, and it would take a huge amount of time to iterate over millions of pixels. Does anyone know of a faster way the append items to ndarrays?
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)