You could do something ugly as

for i in range(len(your_array)):
    for j in range(len(your_array[i])):
        print(your_array[i][j])

Have a look at itertools, especially itertools.product. You can compress the three loops into one with

import itertools

for x, y, z in itertools.product(*map(xrange, (x_dim, y_dim, z_dim)):
    ...

You can also create the cube this way:

cube = numpy.array(list(itertools.product((0,1), (0,1), (0,1))))
print cube
array([[0, 0, 0],
       [0, 0, 1],
       [0, 1, 0],
       [0, 1, 1],
       [1, 0, 0],
       [1, 0, 1],
       [1, 1, 0],
       [1, 1, 1]])

and add the offsets by a simple addition

print cube + (10,100,1000)
array([[  10,  100, 1000],
       [  10,  100, 1001],
       [  10,  101, 1000],
       [  10,  101, 1001],
       [  11,  100, 1000],
       [  11,  100, 1001],
       [  11,  101, 1000],
       [  11,  101, 1001]])

which would to translate to cube + (x,y,z) in your case. The very compact version of your code would be

import itertools, numpy

cube = numpy.array(list(itertools.product((0,1), (0,1), (0,1))))

x_dim = y_dim = z_dim = 10

for offset in itertools.product(*map(xrange, (x_dim, y_dim, z_dim))):
    work_with_cube(cube+offset)

Edit: itertools.product makes the product over the different arguments, i.e. itertools.product(a,b,c), so I have to pass map(xrange, ...) with as *map(...)

m = [[[i*j*k for k in range(10)] for j in range(6)] for i in range(4)]

itertools.product is nicer than nested loops, aesthetically speaking. But I don't think it will make your code that much faster. My testing suggests that iteration is not your bottleneck.

>>> bigdata = numpy.arange(256 * 256 * 256 * 3 * 3).reshape(256, 256, 256, 3, 3)
>>> %timeit numpy.linalg.eigvals(bigdata[100, 100, 100, :, :])
10000 loops, best of 3: 52.6 us per loop

So underestimating:

>>> .000052 * 256 * 256 * 256 / 60
14.540253866666665

That's 14 minutes minimum on my computer, which is pretty new. Let's see how long the loops take...

>>> def just_loops(N):
...     for i in xrange(N):
...         for j in xrange(N):
...             for k in xrange(N):
...                 pass
... 
>>> %timeit just_loops(256)
1 loops, best of 3: 350 ms per loop

Orders of magnitude smaller, as DSM said. Even the work of slicing the array alone is more substantial:

>>> def slice_loops(N, data):
...     for i in xrange(N):
...         for j in xrange(N):
...             for k in xrange(N):
...                 data[i, j, k, :, :]
... 
>>> %timeit slice_loops(256, bigdata)
1 loops, best of 3: 33.5 s per loop

You can use np.vstack but first you have to add a new dimension to features_from_one_file:

EDIT

As suggested @hpaulj, the best practice is to stack only once, so you need to collect all `features_from_one_file` in a list and then stack them:

import numpy as np

all_feats = []
for i in range(5):
    #create features    
    features_from_one_file = np.random.randn(96,64)
    #append Broadcasting first to have dimension 1x96x64
    all_feats.append(features_from_one_file[None,:] )

#stack all at once
features_allfiles = np.vstack(all_feats)

print(features_allfiles.shape)

wich outputs

(5, 96, 64)

Old propossal: stack by one (this is slower)

features_allfiles = np.empty([0,96,64])

for i in range(5):
    #new features
    features_from_one_file = np.random.randn(96,64)
    
    #vertical stack, [None,:] recast array adding new dimension first
    # you can also use features_from_one_file.reshape(1,96,64)
    features_allfiles = np.vstack([features_allfiles,
                                   features_from_one_file[None,:]])


print(features_allfiles.shape)

wich outputs

(5, 96, 64)

Numpy Functions:

Well in this case, since dct is a numpy function, it has the functionality built-in to apply it over a particular axis. Nearly all numpy functions operate on complete arrays or can be told to operate on a particular axis (row or column).

So just by leveraging the axis parameter for dct function:

dct( X, axis=2)

you will get an equivalent result:

>>> ( dct(X, axis=2) == np.array(map(dct, X)) ).all()
True

which is also >35 times faster than using the map function in our case of (625,4,4) matrix:

%timeit dct(X, axis=2)
1000 loops, best of 3: 157 µs per loop

%timeit np.array(map(dct, X))
100 loops, best of 3: 5.76 ms per loop    

General Python Functions:

In other cases, you can vectorize a python function using either np.vectorize or np.frompyfunc functions. For instance if you have a demo function that performs a scalar operation:

def foo(x): # gives an error if passed in an array
    return x**2

>>> X = np.arange(8, dtype=np.float32).reshape(-1,2,2)
>>> foo_arr = np.vectorize( foo)
>>> foo_arr(X)
array([[[  0.,   1.],
        [  4.,   9.]],

       [[ 16.,  25.],
        [ 36.,  49.]]])

Discussion here might also be helpful for you. As they say, vectorizing your non-numpy function doesn't actually make it any faster though.