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()

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.

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)

NumPy provides a 'fromiter' method:

def myfunc(n):
    for i in range(n):
        yield i**2


np.fromiter(myfunc(5), dtype=int)

which yields

array([ 0,  1,  4,  9, 16])

Check out this answer - basically what you want is

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

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

numpy.zeros

Return a new array of given shape and type, filled with zeros.

or

numpy.ones

Return a new array of given shape and type, filled with ones.

or

numpy.empty

Return a new array of given shape and type, without initializing entries.

However, the mentality in which we construct an array by appending elements to a list is not much used in numpy, because it's less efficient (numpy datatypes are much closer to the underlying C arrays). Instead, you should preallocate the array to the size that you need it to be, and then fill in the rows. You can use numpy.append if you must, though.

You could use the np.fromiter function and Python's built in itertools.product to create the array you need:

Note: I'm assuming you're using Python 2.x based on your print statements.

import itertools
import numpy as np

product = itertools.product(xrange(X, X + 1000*STEP_X, STEP_X),
                            [Y],
                            xrange(Z, Z + 1000*STEP_Z, STEP_Z))

targets = np.fromiter(product)

This should be faster because it uses iterators instead of creating and allocating an entire list.

UPDATE

Here are some style pointers and other minor improvements that I could see. Most of these recommendations stem from PEP8, the official Python style guide, so if you need a reference for my suggestions, you can head over there.

1. ALWAYS USE with. Whenever you deal with file access, use a with block as it is significantly less prone to user errors than using open() and close(). Luckily, you're code doesn't show the typical bug of not calling close() after an open(). However, its best to get into the habit of using with:

   with open('some_file.txt', 'r') as file: # Do stuff

2. Use underscores_in_names when naming variables and functions. For the most part you do this. However, your function names could be updated.

3. Function names should be verb-based as this style helps show that the function does something:

   # Currently...
   def XYZ2sRGB(...):
   
   # Better...
   def convert_to_RGB(...)
   

   A quick note: Typically I don't like using upper-case letters in anything except constants. However, because RGB is basically an acronym, capital letters seem appropriate.

4. Speaking about upper-case letters, convention says that only constants should be capitalized in Python. This is relatively significant because convention is the only way we can 'define' constants in Python as there is no syntactic way to do so.

5. Whitespace is your friend, however be careful not to overdo it. PEP8 actually calls extraneous whitespace a pet peeve. A few of the points mentioned in that section of PEP8 that are applicable are:

   # Bad                  # Good
   foo            = 1  |  foo = 1
   some_long_name = 0  |  some_long_name = 0
   --------------------+---------------------
   range (1000)        |  range(1000)
   --------------------+---------------------
   foo = ( x + 1 * 2 ) |  foo = (x + 1*2)
   

   The last example is really based on preference: simply use whitespace to group operations and operands together so that the calculation reads well.

6. Parenetheses aren't required in if statements (unless they group conditionals together). You can remove almost all of yours.

7. Use if ... elif ... when applicable. Take this group of statements:

   G = var_G * 255
   if (G > 255):
       G = 255
   if (G < 0):
       G = 0
   

   The second if will always be evaluated even if the first evaluated to True which means the second will evaluate to False. Because the two conditional are mutually exclusive, use and if-elif structure. Also, instead of basing your conditionals off of G (which requires a calculation beforehand) base your conditionals off of var_G:

   if var_G > 1:
       G = 255
   elif var_G < 0:
       G = 0
   else:
       G = var_G * 255
   

   This code only does the calculation if necessary and has the same number of possible comparisions (in the worst case).

8. Use str.format instead of string concatenation. While whether string formatting performs better than string concatenation is up in the air, its more conventional (and, in my opinion, MUCH cleaner) to use str.format:

   with open(str(filename), "a") as f:
       f.write('<path d="M{} {} \n'.format(x*1/2.54*72, y*1/2.54*72)) #moveto
       f.write('    m {},0 \n'.format(-radius))
       f.write('    a {} 0 1,0 {},0 \n'.format(radius, radius, radius*2))
       f.write('    a {} 0 1,0 {},0 \n'.format(radius, radius, -radius*2))
       f.write('    " fill = "rgb({},{},{})"/> \n'.format(R, G, B))
   

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.

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.