Did you had a look at numpy.ndindex? This could do the trick:

a = np.ndindex(6,6)

You could have some more information on Is there a Python equivalent of range(n) for multidimensional ranges?

In order to do this you would either need to use a datatype that's size can be mutated as I did in my other answer or you could also figure out how many images you have before defining the array. (As suggested by @P.Camilleri)

Here's an example of that:

# Count nuber of images
idx_count = 0
for item in dataset:
    idx_count += len(item['data'])

# Create an empty numpy array that's Nx3x3
images = np.empty((count, 3, 3))

# Populate numpy array with images
idx = 0
for item in dataset:
    for row in item["data"]:
        images[idx] = row["sub_data"]
        idx += 1

print(images)

This has the advantage that you only allocate the space once, as apposed to using a python list where it's first added to the list then copied to a numpy array.

However, this is at the cost of having to iterate over the data twice.

(Note: Two separate answers so they can be rated separately as I'm not sure which solution is better.)

Thanks @hpaulj, that might be very useful for me in future. I wasn't aware of the speed up using fromiter()

import timeit
setup = '''
import numpy as np
H, W = 400, 400
it = [(1 + 1 / (i + 0.5)) ** 2 for i in range(W) for j in range(H)]'''

fns = ['''
x = np.array([[(1 + 1 / (i + 0.5)) ** 2 for i in range(W)] for j in range(H)])
''', '''
x = np.fromiter(it, np.float)
x.reshape(H, W)
''']
for f in fns:
  print(timeit.timeit(f,setup=setup, number=100))
# gives me
# 6.905218548999983
# 0.5763416080008028

EDIT PS your for loop could be some kind of iterator like

it = [my_df[missing_labels[var][0]][-1]
        / my_df[missing_labels[var][1]][-1] if var in missing_labels
        else my_df[var][-1] for var in var_outputs]

As a oneliner it would be:

NUM = 50
data = [np.loadtxt("datafromafile%d.txt" % value) for value in np.arange(NUM)]

or

FILES = ['file1', 'file2', 'file3']
data = {key: np.loadtxt(key) for key in FILES}

as a dict with the filename as key.

You can do in the following way:

Use with AInp.array([[n,m,roh,1,2] for n in [100,1000] for m in [2,10,100] for roh in [0.0,0.5,0.9]])

Cheers.

The recommended way to do this is to preallocate before the loop and use slicing and indexing to insert

my_array = numpy.zeros(1,1000)
for i in xrange(1000):
    #for 1D array
    my_array[i] = functionToGetValue(i)
    #OR to fill an entire row
    my_array[i:] = functionToGetValue(i)
    #or to fill an entire column
    my_array[:,i] = functionToGetValue(i)

numpy does provide an array.resize() method, but this will be far slower due to the cost of reallocating memory inside a loop. If you must have flexibility, then I'm afraid the only way is to create an array from a list.

EDIT: If you are worried that you're allocating too much memory for your data, I'd use the method above to over-allocate and then when the loop is done, lop off the unused bits of the array using array.resize(). This will be far, far faster than constantly reallocating the array inside the loop.

EDIT: In response to @user248237's comment, assuming you know any one dimension of the array (for simplicity's sake):

my_array = numpy.array(10000, SOMECONSTANT)

for i in xrange(someVariable):
    if i >= my_array.shape[0]:
        my_array.resize((my_array.shape[0]*2, SOMECONSTANT))

    my_array[i:] = someFunction()

#lop off extra bits with resize() here

The general principle is "allocate more than you think you'll need, and if things change, resize the array as few times as possible". Doubling the size could be thought of as excessive, but in fact this is the method used by several data structures in several standard libraries in other languages (java.util.Vector does this by default for example. I think several implementations of std::vector in C++ do this as well).

A list comprehension could do that for you:

import numpy as np
results = np.array([[x, x**2] for x in range(100)])

That gives you an array of two columns:

Out[5]: 
array([[   0,    0],
       [   1,    1],
       [   2,    4],
       [   3,    9],
        ...

You've just commented that the function is more complex than just x**2 - one solution is simply to define it as a function, e.g.

import numpy as np

def func(x): # example functionality
    y = x**2
    y = y*2
    return y

results = np.array([[x, func(x)] for x in range(100)])

Out[13]: 
array([[    0,     0],
       [    1,     2],
       [    2,     8],
       [    3,    18],
       ...

Using numpy.linspace:

import numpy as np

res = np.linspace(0.5, 795*0.5, num=795)

array([   0.5,    1. ,    1.5,    2. ,    2.5,    3. ,    3.5,    4. ,
      ...
        396.5,  397. ,  397.5])

c[1] would give [[4 5 6]] to access to 5 you should c[1][0][1]

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

print c[1][0][1]

UPDATE

It's easier to do it this way:

import numpy as np
b=[4,5,6]
a=[1,2,3,9] #I added an element to clarify how to manage indexes in case u have diff sizes
c=np.array([a,b])

#j= sum(1 for x in c if isinstance(x, np.ndarray)) Another way to see how many item in the list

for j in range(len(c)): #Selecting the list (a,b ..)
    i=0
    while i<=len(c[j])-1: #Looping in the list
        print "index (",i,",",j,"):",c[j][i]
        i+=1

I understand you asked how to do this with nested loops, so apologies if you don't find this useful. I'd just thought I'd share how I normally do this:

b = np.arange(10).reshape(2,5)
print(b)

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

The way I usually do that is by creating a regular list, then append my stuff into it, and finally transform the list to a numpy array as follows :

Use with AIimport numpy as np
big_array = [] #  empty regular list
for i in range(5):
    arr = i*np.ones((2,4)) # for instance
    big_array.append(arr)
big_np_array = np.array(big_array)  # transformed to a numpy array

of course your final object takes twice the space in the memory at the creation step, but appending on python list is very fast, and creation using np.array() also.

np.append returns the concatenated array, and you're ignoring its return value. You should also consider using np.vstack instead, since that stacks row vectors into matrices (append can do it but it takes extra arguments).

However, running np.append or np.vstack in a loop is still not a very good idea as constructing the matrix will take quadratic time. It's better to preallocate an array and then fill it row by row using slicing. If you don't know how large it will need to be, consider iteratively doubling its size (see Wikipedia, Dynamic array) with np.resize.