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

I have a project were I need to do something very similar. You can implement dynamic resizing in your loop, but python's list type is actually implemented as a dynamic array so you might as well take advantage of the tools that are already available to you. You can do something like this:

delta_Array = np.array([0.01,0.02,0.03, 0.04, 0.05, 0.06,0.07, 0.08, 0.09, 0.10])
theta_Matrix = []

for i in range(N):
     t = Ridge(Xtrain, ytrain, .3)
     theta_Matrix.append(t)
theta_Matrix = np.array(theta_Matrix)

I should mention that if you already know the size you expect for theta_Matrix, you'll get the best performance by doing something like:

delta_Array = np.array([0.01,0.02,0.03, 0.04, 0.05, 0.06,0.07, 0.08, 0.09, 0.10])
theta_Matrix = np.zeros((N, 8))

for i in range(N):
     t = Ridge(Xtrain, ytrain, .3)
     theta_Matrix[i] = t

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

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

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.