If you restrict yourself to the Python standard library, then a list of lists is the closest construct:

arr = [[1,2],[3,4]]

gives a 2d-like array. The rows can be accessed as arr[i] for i in {0,..,len(arr}, but column access is difficult.

If you are willing to add a library dependency, the NumPy package is what you really want. You can create a fixed-length array from a list of lists using:

import numpy
arr = numpy.array([[1,2],[3,4]])

Column access is the same as for the list-of-lists, but column access is easy: arr[:,i] for i in {0,..,arr.shape[1]} (the number of columns).

In fact NumPy arrays can be n-dimensional.

Empty arrays can be created with

numpy.empty(shape)

where shape is a tuple of size in each dimension; shape=(1,3,2) gives a 3-d array with size 1 in the first dimension, size 3 in the second dimension and 2 in the 3rd dimension.

If you want to store objects in a NumPy array, you can do that as well:

 arr = numpy.empty((1,), dtype=numpy.object)
 arr[0] = 'abc'

For more info on the NumPy project, check out the NumPy homepage.

This works:

a = [[1, 2, 3], [4, 5, 6]]
nd_a = np.array(a)

So this should work too:

nd_a = np.array([[x for x in y] for y in a])

If your number of ranges is not too large you can create them by hand

 gm09 = xdata >= -0.9
 gm06 = xdata >= -0.6
 g0   = xdata >= 0
 ranges = [xdata[gm09 & ~gm06], xdata[gm06 & ~g0]]
 result = [f(r) for r in ranges]

where f is your scipy function.

If your number of ranges is large, you can sort your data and then use searchsorted. Assuming you have the boundaries of blocks in the sorted array bnd:

xs = np.sort(xdata)
xbnd = np.searchsorted(xs, bnd)
ranges = [xs[l:r] for l, r in zip(xbnd[:-1], xbnd[1:])]
result = [f(r) for r in ranges]

Note that this differs from the first solution in that your ranges will be sorted.

If you need to preserve the original order you can use indirect sorting

order = np.argsort(xdata)
xbnd = np.searchsorted(xdata[order], bnd)
ordord = [np.sort(order[l:r]) for l, r in zip(xbnd[:-1], xbnd[1:])]
ranges = [xdata[oo] for oo in ordord]
result = [f(r) for r in ranges]

Note that to leverage the full power of numpy, you'd be much better off with a 3-dimensional numpy array. Breaking apart the 3-d array into a 2-d array with 1-d values may complicate your code and force you to use loops instead of built-in numpy functions.

It may be worth investing the time to refactor your code to use the superior 3-d numpy arrays.

However, if that's not an option, then:

import numpy as np
storageMatrix=np.empty((4,9),dtype='object')

By setting the dtype to 'object', we are telling numpy to allow each element of storageMatrix to be an arbitrary Python object.

Now you must initialize each element of the numpy array to be an 1-d numpy array:

storageMatrix[column,row]=np.arange(4096)

And then you can access the array elements like this:

storageMatrix[column,row][0] = 1
storageMatrix[column,row][4092] = 2