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

NumPy arrays have fixed sizes, so unless you know the size upfront you have to use something that can change sizes, like python lists.

import numpy as np

images = []

for item in dataset:
    for row in item["data"]:
        images.append(row["sub_data"]) # Add to list

images = np.array(images) # Convert list to np.array()

You can store them in a list:

data = list()
for i in arange(num):
    data.append(np.loadtxt("datafromafile%d.txt" % i))

Then you can access each array with:

>>> data[0] + data[1] # sum of the first and second numpy array

Here is the final code, np.fromiter() does the trick and allows to reduce the number of lines by using list comprehension

df = pd.read_excel(path)
print(df.columns)

It outputs ['x1', 'x2']

vars_outputs = ["x1", "x2", "ratio_x1_x2"]
missing_labels = {"ratio_x1_x2" : ["x1", "x2"]}

it = [df[missing_labels[var][0]].iloc[-1]/df[missing_labels[var][1]].iloc[-1] if var in missing_labels
        else df[var].iloc[-1] for var in vars_outputs]

t = np.fromiter(it, dtype = float)

There is no need to use a loop. You can use numpy.arange([start, ]stop, [step, ]) to generate a range of numbers.

In your case:

predicted_value = np.arange(9, 33)  # Note the 33 if you want 9..32

If you really want to use a loop, there is the option of using a list comprehension:

predicted_value = np.array([i for i in range(9, 33)])

Or an explicit loop, which would be most horrible:

predicted_value = np.empty(33 - 9)
for k, i in enumerate(range(9, 33)):
    predicted_value[k] = i

By the looks of your code you could have:

all_stats = np.max( data[:,:len(headers)], axis=1)

giving you the same results in a vectorized (faster) way.

While the people in the comments are right in that you are not persisting your data anywhere, your problem, I assume, is incorrect np.array construction. You should enclose all of the arguments in a list like this:

feature_table = np.array([currentline[0],currentline[3],currentline[4]])

And get rid of redundant [ and ] around the arguments.

See the official documentation for more examples. Basically all of the input data needs to be grouped/separated to be only 1 argument as Python will consider the other arguemnts as different positional arguments.

itertools would be very convenient for this. E.g.

(modified this answer, also addressing follow up questions)

Use with AIimport numpy as np
import itertools
n_list, m_list, rho_list = [100,1000], [2,10,100], [0.0,0.5,0.9]

f1, f2 = lambda mat: 1, lambda mat: 2 # change accordingly

def f(n, m, rho, f1, f2):
    distance_matrix = np.zeros((2, 2))
    ## replace accordingly
    return f1(distance_matrix), f2(distance_matrix)

ff = lambda n, m, rho: f(n, m, rho, f1, f2) 
values = np.array([[n, m, rho, *ff(n, m, rho)] for n, m, rho in itertools.product(n_list, m_list, rho_list)])

The *ff(...) is to unpack the tuple into two separate values.

By the looks of your code you could have:

all_stats = np.max( data[:,:len(headers)], axis=1)

giving you the same results in a vectorized (faster) way.

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],

A numpy array must be created with a fixed size. You can create a small one (e.g., one row) and then append rows one at a time, but that will be inefficient. There is no way to efficiently grow a numpy array gradually to an undetermined size. You need to decide ahead of time what size you want it to be, or accept that your code will be inefficient. Depending on the format of your data, you can possibly use something like numpy.loadtxt or various functions in pandas to read it in.

Do you want this?

a = [1,2,3];
b = [4,5,6];
c = [a,b];

c[1][1] # Gives you 5

To do it in a loop

for z in [a,b]:
    c.append(z)

# continue as usual......

Also, you don't really need numpy to do this. If you do, follow @Taha s answer above.

Check out this answer - basically what you want is

import numpy
numpy.arange(0.5, 0.5 + 795 * 0.5, 0.5)