32

I am trying to fill an empty(not np.empty!) array with values using append but I am gettin error:

My code is as follows:

import numpy as np
result=np.asarray([np.asarray([]),np.asarray([])])
result[0]=np.append([result[0]],[1,2])

And I am getting:

ValueError: could not broadcast input array from shape (2) into shape (0)
Improve this question
0

6 Answers 6

Reset to default
71

I might understand the question incorrectly, but if you want to declare an array of a certain shape but with nothing inside, the following might be helpful:

Initialise empty array:

>>> a = np.zeros((0,3)) #or np.empty((0,3)) or np.array([]).reshape(0,3)
>>> a
array([], shape=(0, 3), dtype=float64)

Now you can use this array to append rows of similar shape to it. Remember that a numpy array is immutable, so a new array is created for each iteration:

>>> for i in range(3):
...     a = np.vstack([a, [i,i,i]])
...
>>> a
array([[ 0.,  0.,  0.],
       [ 1.,  1.,  1.],
       [ 2.,  2.,  2.]])

np.vstack and np.hstack is the most common method for combining numpy arrays, but coming from Matlab I prefer np.r_ and np.c_:

Concatenate 1d:

>>> a = np.zeros(0)
>>> for i in range(3):
...     a = np.r_[a, [i, i, i]]
...
>>> a
array([ 0.,  0.,  0.,  1.,  1.,  1.,  2.,  2.,  2.])

Concatenate rows:

>>> a = np.zeros((0,3))
>>> for i in range(3):
...     a = np.r_[a, [[i,i,i]]]
...
>>> a
array([[ 0.,  0.,  0.],
       [ 1.,  1.,  1.],
       [ 2.,  2.,  2.]])

Concatenate columns:

>>> a = np.zeros((3,0))
>>> for i in range(3):
...     a = np.c_[a, [[i],[i],[i]]]
...
>>> a
array([[ 0.,  1.,  2.],
       [ 0.,  1.,  2.],
       [ 0.,  1.,  2.]])
Improve this answer
Sign up to request clarification or add additional context in comments.

8 Comments

THANK YOU SIR, you are the first person who even understood what the OP wanted (seems pretty obvious to me), and you gave us what we actually wanted in the first place. In short, YES, of course there is a way to concatenate onto an empty array! Thanks again.
Oh, another way to declare an "empty" array would be a = np.zeros((0,3))
Nice, this answers a question that has bothered me for a while about the best way to do this. Thanks! This should really be changed to the accepted answer by the OP.
predictions = np.array([]).reshape(2,2) ValueError: cannot reshape array of size 0 into shape (2,2)
@CodePope sorry what I meant was, you are right in suggesting np.empty, since it is cleaner and prettier code than the whole reshape workaround. You are also correct in that it is more efficient, but the efficiency gain is tiny compared to how bad this append approach is to start with. You don't gain anything with np.empty here, really. You encouraged me to change my code to use np.zeros - i.m.o. the most readable / most known function for array creation (efficiency aside).
|
37

numpy.append is pretty different from list.append in python. I know that's thrown off a few programers new to numpy. numpy.append is more like concatenate, it makes a new array and fills it with the values from the old array and the new value(s) to be appended. For example:

import numpy

old = numpy.array([1, 2, 3, 4])
new = numpy.append(old, 5)
print old
# [1, 2, 3, 4]
print new
# [1, 2, 3, 4, 5]
new = numpy.append(new, [6, 7])
print new
# [1, 2, 3, 4, 5, 6, 7]

I think you might be able to achieve your goal by doing something like:

result = numpy.zeros((10,))
result[0:2] = [1, 2]

# Or
result = numpy.zeros((10, 2))
result[0, :] = [1, 2]

Update:

If you need to create a numpy array using loop, and you don't know ahead of time what the final size of the array will be, you can do something like:

import numpy as np

a = np.array([0., 1.])
b = np.array([2., 3.])

temp = []
while True:
    rnd = random.randint(0, 100)
    if rnd > 50:
        temp.append(a)
    else:
        temp.append(b)
    if rnd == 0:
         break

 result = np.array(temp)

In my example result will be an (N, 2) array, where N is the number of times the loop ran, but obviously you can adjust it to your needs.

new update

The error you're seeing has nothing to do with types, it has to do with the shape of the numpy arrays you're trying to concatenate. If you do np.append(a, b) the shapes of a and b need to match. If you append an (2, n) and (n,) you'll get a (3, n) array. Your code is trying to append a (1, 0) to a (2,). Those shapes don't match so you get an error.

Improve this answer

4 Comments

That doesn't help me. Cause I want to dynamically append numbers to my array!
I'm not sure what you mean by "dynamically`, maybe you're looking for a dynamic array? The best implementation of a dynamic array I've used in any language is a python list. Unfortunately numpy arrays are not dynamic arrays, but you can append to them by making a copy.
Yes thats exactly what I mean. But this error of Python as I can understand doesn't make that much of sense as I already said in my above comment cause it is type free! But thank you! I will use lists then.
@Naji Python is not type-free; it's dynamically typed. And many (most?) dynamic languages have some data structures that are immutable or otherwise have restrictions on what you can do with them.
3

This error arise from the fact that you are trying to define an object of shape (0,) as an object of shape (2,). If you append what you want without forcing it to be equal to result[0] there is no any issue:

b = np.append([result[0]], [1,2])

But when you define result[0] = b you are equating objects of different shapes, and you can not do this. What are you trying to do?

Improve this answer

5 Comments

That make sense, although it seems so lame that you cannot change a variable's type after you assigned it, considering the fact that python is type-free!
I do not know exactly what are you trying to do, but I think you may want to use a list instead a numpy array. Lists are more flexible.
What I am trying to do is to make an empty 2D array and fill it dynamically with the values I get which either belong to index=0 or index=1.
@Naji You can change a variable's type after you've assigned it by just assigning to to a different value. You generally can't change a value's type after you've created it. With numpy arrays in particular, you have the added wrinkle of using a data structure implemented in C for performance reasons.
np.arrays are best thought of as fixed size containers. While they can be built from Python lists, they aren't designed for growth.
3

Here's the result of running your code in Ipython. Note that result is a (2,0) array, 2 rows, 0 columns, 0 elements. The append produces a (2,) array. result[0] is (0,) array. Your error message has to do with trying to assign that 2 item array into a size 0 slot. Since result is dtype=float64, only scalars can be assigned to its elements.

In [65]: result=np.asarray([np.asarray([]),np.asarray([])])

In [66]: result
Out[66]: array([], shape=(2, 0), dtype=float64)

In [67]: result[0]
Out[67]: array([], dtype=float64)

In [68]: np.append(result[0],[1,2])
Out[68]: array([ 1.,  2.])

np.array is not a Python list. All elements of an array are the same type (as specified by the dtype). Notice also that result is not an array of arrays.

Result could also have been built as

ll = [[],[]]
result = np.array(ll)

while

ll[0] = [1,2]
# ll = [[1,2],[]]

the same is not true for result.

np.zeros((2,0)) also produces your result.

Actually there's another quirk to result.

result[0] = 1

does not change the values of result. It accepts the assignment, but since it has 0 columns, there is no place to put the 1. This assignment would work in result was created as np.zeros((2,1)). But that still can't accept a list.

But if result has 2 columns, then you can assign a 2 element list to one of its rows.

result = np.zeros((2,2))
result[0] # == [0,0]
result[0] = [1,2]

What exactly do you want result to look like after the append operation?

Improve this answer

1 Comment

Vote up. But I think what you already wrote is covered in the other answers. Thanks anyways
2

numpy.append always copies the array before appending the new values. Your code is equivalent to the following:

import numpy as np
result = np.zeros((2,0))
new_result = np.append([result[0]],[1,2])
result[0] = new_result # ERROR: has shape (2,0), new_result has shape (2,)

Perhaps you mean to do this?

import numpy as np
result = np.zeros((2,0))
result = np.append([result[0]],[1,2])
Improve this answer

2 Comments

Actually result has an element zero... But the point you suggested is a complete different way!
np.append is just a concatenate: return concatenate((arr, values), axis=axis)
1

SO thread 'Multiply two arrays element wise, where one of the arrays has arrays as elements' has an example of constructing an array from arrays. If the subarrays are the same size, numpy makes a 2d array. But if they differ in length, it makes an array with dtype=object, and the subarrays retain their identity.

Following that, you could do something like this:

In [5]: result=np.array([np.zeros((1)),np.zeros((2))])

In [6]: result
Out[6]: array([array([ 0.]), array([ 0.,  0.])], dtype=object)

In [7]: np.append([result[0]],[1,2])
Out[7]: array([ 0.,  1.,  2.])

In [8]: result[0]
Out[8]: array([ 0.])

In [9]: result[0]=np.append([result[0]],[1,2])

In [10]: result
Out[10]: array([array([ 0.,  1.,  2.]), array([ 0.,  0.])], dtype=object)

However, I don't offhand see what advantages this has over a pure Python list or lists. It does not work like a 2d array. For example I have to use result[0][1], not result[0,1]. If the subarrays are all the same length, I have to use np.array(result.tolist()) to produce a 2d array.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.