Why not try something like this to transpose the columns:

x = []

for d in xrange(0,66):
    x.append(data[:,d])

Unless it's absolutely essential that there is a separate data structure for each item, although I don't know why you would need separate data strucures...

EDIT: If not here's something that should work precisely the way you described:

for d in xrange(1,68):
    exec 'x%s = data[:,%s]' %(d,d-1)

In the first one you add the arrays of length 10 to the bigger array. So you need to create two arrays.

array1 = []
array2 = []
for j in range(20):
    for i in range(10):
        array1.append(0)
    array2.append(array1)
    array1 = []
print array2

This is equivalent to

array2=[[0 for j in range(10)] for i in range(20)]

Appending elements while looping using append() is correct and it's a built-in method within Python lists.

However you can have the same result:

Using list comprehension:

result_t = [k for k in range(1,6)]
print(result_t)
>>> [1, 2, 3, 4, 5]

Using + operator:

result_t = []
for k in range(1,6):
    result_t += [k]

print(result_t)
>>> [1, 2, 3, 4, 5]

Using special method __iadd__:

result_t = []
for k in range(1,6):
    result_t.__iadd__([k])

print(result_t)
>>> [1, 2, 3, 4, 5]

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

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 get a metar_dat array that is mostly 0 because it is the one you created at the last k iteration. It was len(stat_id) long (in the 1st dimensions) but you only inserted data for the last k. You threw away the results for the earlier k.

I would suggest collecting the data in a dictionary, rather than object array.

metar_dat = dict()  # dictionary rather than object array
for id in stat_id:
    # Bring all the data into one big array.
    data = np.column_stack([yr, month, day, time,temp, dwp])
    # should produce as (len(temp),6) integer array
    # or float is one or mo    for k in range(len(stat_id)):
    metar_dat[id] = data

If len(temp) varies for each id, you can't make a meaningful 3d array with shape (len(stat_id), len(temp), 7) - unless you pad every one to the same maximum length. When thinking about arrays, thing rectangles, not ragged lists.

A Python dictionary is a much better way of collecting information by some sort of unique id.

Object arrays let you generalize the concept of numeric arrays, but they don't give much added power compared to lists or dictionaries. You can't for example, add values across the 'id' dimension.

You need to describe what you hope to do with this data once you collect it. That will help guide our recommendations regarding the data representation.

There are other ways of defining the data structure for each id. It looked like yr, time, temp were equal length arrays. If they are all numbers they could be collected into an array with 6 columns. If it is important to keep some integer, while others are floats (or even strings) you could use a structured array.

Structured arrays are often produced by reading column data from a csv file. Some columns will have string data (ids) others integers or even dates, others float data. np.genfromtxt is a good tool for loading that sort of file.