The numpy array you are defining is not the right shape for the loop you are using. b = np.array([]) gives you an array of shape (0,)

You can use something like np.zeros to define your 2D array.

import numpy as np
b = np.zeros((3,6))
for i in range(2):
    for j in range(5):
        b[i][j]=i+j
print(b)

The output will be

[[0. 1. 2. 3. 4. 0.]
 [1. 2. 3. 4. 5. 0.]
 [0. 0. 0. 0. 0. 0.]]

Another option is to make a 2D list, fill it up in for loops, and convert to numpy array later

import numpy as np

#2D array
b = [ [0 for _ in range(6)] for _ in range(3)]

#Fill up array with for loops
for i in range(2):
    for j in range(5):
        b[i][j]=i+j

#Convert to numpy array
print(np.array(b))

The output will be

[[0 1 2 3 4 0]
 [1 2 3 4 5 0]
 [0 0 0 0 0 0]]

The numpy array you are defining is not the right shape for the loop you are using. b = np.array([]) gives you an array of shape (0,)

You can use something like np.zeros to define your 2D array.

import numpy as np
b = np.zeros((3,6))
for i in range(2):
    for j in range(5):
        b[i][j]=i+j
print(b)

The output will be

[[0. 1. 2. 3. 4. 0.]
 [1. 2. 3. 4. 5. 0.]
 [0. 0. 0. 0. 0. 0.]]

Another option is to make a 2D list, fill it up in for loops, and convert to numpy array later

import numpy as np

#2D array
b = [ [0 for _ in range(6)] for _ in range(3)]

#Fill up array with for loops
for i in range(2):
    for j in range(5):
        b[i][j]=i+j

#Convert to numpy array
print(np.array(b))

The output will be

[[0 1 2 3 4 0]
 [1 2 3 4 5 0]
 [0 0 0 0 0 0]]

You can try this:

import numpy as np
listvals = []
for i in range(10):
    listvals.append((xc, yc))
mat_vals = np.vstack(listvals)

This will output an ndarray like this:

[[ 2  0]
 [ 3  1]
 [ 4  2]
 [ 5  3]
 [ 6  4]
 [ 7  5]
 [ 8  6]
 [ 9  7]
 [10  8]
 [11  9]]

Or this maybe is better:

import numpy as np
list_xc = []
list_yc = []
for i in np.arange(10): 
    list_xc.append(xc)
    list_yc.append(yc)
mat_xc = np.asarray(list_xc)
mat_yc = np.asarray(list_yc)
mat_f = np.column_stack((mat_xc, mat_yc))

First lets focus on the append operation,

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

np.append( a, b )

produces

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

What you might want is

np.append( [a], [b], 0 )

which produces

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

Note that here a 0 appears in the third parameter to specify the axis for the append operation.

Regarding the error, the index h, tells numpy to append to the 'h'-th element. That's probably not what you intended. Also, the index is not correct since 'h' is always one more than the number of elements in the array at the point where the call occurs.

Create the 2D array up front, and fill the rows while looping:

my_array = numpy.empty((len(huge_list_of_lists), row_length))
for i, x in enumerate(huge_list_of_lists):
    my_array[i] = create_row(x)

where create_row() returns a list or 1D NumPy array of length row_length.

Depending on what create_row() does, there might be even better approaches that avoid the Python loop altogether.

This works:

a = [[1, 2, 3], [4, 5, 6]]
nd_a = np.array(a)

So this should work too:

nd_a = np.array([[x for x in y] for y in a])

Start with an empty list:

output_arr = []

Append within the loop:

for _ in range(5):
    output_arr.append([1, 1])

Outside the loop, just call np.array:

X = np.array(output_arr)

You could preallocate the array before assigning the respective values:

a = np.empty(shape=(25, 2), dtype=int)
for x in range(1, 6):
    for y in range(1, 6):
        index = (x-1)*5+(y-1)
        a[index] = x, y

You can perform your calculation in a vectorised fashion:

x = np.array([1,2,3,4,5])
y = np.array([5,6,7,8,9])

res = 50*x + 20*y[:, None]

array([[150, 200, 250, 300, 350],
       [170, 220, 270, 320, 370],
       [190, 240, 290, 340, 390],
       [210, 260, 310, 360, 410],
       [230, 280, 330, 380, 430]])

Here, the indexer [:, None] change the shape of y from (1,) to (5, 1). Broadcasting then allows creation of a 2d array result.

You can expect a performance improvement versus a method based on list comprehension, although you may only notice this for larger input arrays:

%timeit 50*x + 20*y[:, None]                                          # 10.1 µs
%timeit np.array([x_*50+y_*20 for y_ in y for x_ in x]).reshape(5,5)  # 30.2 µs

First you have to install numpy using

$ pip install numpy

Then the following should work

import numpy as np    
n = 100
matrix = np.zeros((n,2)) # Pre-allocate matrix
for i in range(1,n):
    matrix[i,:] = [3*i, i**2]

A faster alternative:

col1 = np.arange(3,3*n,3)
col2 = np.arange(1,n)
matrix = np.hstack((col1.reshape(n-1,1), col2.reshape(n-1,1)))

Even faster, as Divakar suggested

I = np.arange(n)
matrix = np.column_stack((3*I, I**2))

np.column_stack can do the trick:

>>> a = np.array(range(100))
>>> b = np.column_stack((a, a**a))
>>> b
array([[                   0,                    1],
       [                   1,                    1],
       [                   2,                    4],
       [                   3,                   27],
       [                   4,                  256],
       [                   5,                 3125],
       [                   6,                46656],
       [                   7,               823543],
       [                   8,             16777216],
       [                   9,            387420489],
       [                  10,          10000000000],
       [                  11,         285311670611],
       [                  12,        8916100448256],
       [                  13,      302875106592253],