>>> from operator import itemgetter
>>> a = range(100)
>>> itemgetter(5,13,25)(a)
(5, 13, 25)

use operator.itemgetter:

from operator import itemgetter
array = range(1, 12)
indices = itemgetter(0, 3, 10)
print indices(array)
# (1, 4, 11)

Then present that tuple however you want..., eg:

print ' '.join(map(str, indices(array)))
# 1 4 11

First, note that indexing in Python begins at 0. So the indices you need will be [0, 2].

You can then use a list comprehension:

temp = ['a', 'b', 'c', 'd']
idx = [0, 2]

res = [temp[i] for i in idx]            # ['a', 'c']

With built-ins, you may find map performs better:

res = map(temp.__getitem__, idx)        # ['a', 'c']

Since you are using Python 2.7, this returns a list. For Python 3.x, you would need to pass the map object to list.

If you are looking to avoid a Python-level loop altogether, you may wish to use a 3rd party library such as NumPy:

import numpy as np

temp = np.array(['a', 'b', 'c', 'd'])
res = temp[idx]

# array(['a', 'c'], 
#       dtype='<U1')

res2 = np.delete(temp, idx)

# array(['b', 'd'], 
#       dtype='<U1')

This returns a NumPy array, which you can then be converted to a list via res.tolist().

The most direct way to do this with lists is to use a list comprehension:

c = [b[i] for i in index]

But, depending on exactly what your data looks like and what else you need to do with it, you could use numpy arrays - in which case:

c = b[index]

would do what you want, and would avoid the potential memory overhead for large slices - numpy arrays are stored more efficiently than lists, and slicing takes a view into the array rather than making a partial copy.

structure = [[{'w': [0.5372377247650572, 1.9111341091016385, -3.2165806256024116, -1.7154987465370053, 1.0917999534858416], 'o': 0.0004326739879156587, 'd': 3.586499431857422e-05}],[{'w': [7.298542669399767, -3.9021024252822105], 'o': 0.019860841402923542, 'd': 0.00105997759946847}, {'w': [-2.8024625186056764, -0.34819658506990847], 'o': 0.4135257109795849, 'd': -0.0016469874583619935}, {'w': [-6.018257518762189, 0.3317488378886934], 'o': 0.5815513019444986, 'd': -1.1787471334339458e-05}]]
d_values = [ x['d'] for row in structure for x in row ]

i = 0
j = 2
x_0[:,i:i+3,j:j+3]

produces a (5,3,3) array.

But what do you want to do with?

i=[0, 5, 3, 5, 3]
j=[2, 4, 0, 6, 6]

Do you want, for example, to produce a (5,3,3) array for each pair of values from i and j?

Or do you want to stack?

x_0[0,0:3,2:5]
x_0[1,5:8,4:7]
...

which could be produced with:

np.array([x0[kk,ii:ii+3,jj:jj+3] for kk,(ii,jj) in enumerate(zip(i,j))])

Here I collect 5 (3,3) arrays and join them into one. It may be possible to join the indexes, and do the indexing once, but that will require some fiddling, and may not improve the speed.

Before worrying about doing things efficiently, lets be clear about what you want to do. My guess is that you will need to iterate in one way or other over the values of i and j, and concatenate values. It doesn't matter much whether you concatenate and then index or index and then concatenate.

If x0=np.arange(500).reshape(5,10,10), the above expression produces:

array([[[  2,   3,   4],
        [ 12,  13,  14],
        [ 22,  23,  24]],

       [[154, 155, 156],
        [164, 165, 166],
        [174, 175, 176]],

       [[230, 231, 232],
        [240, 241, 242],
        [250, 251, 252]],

       [[356, 357, 358],
        [366, 367, 368],
        [376, 377, 378]],

       [[436, 437, 438],
        [446, 447, 448],
        [456, 457, 458]]])