Question

I ran several times an application with different input parameters in order to collect execution times.

The input parameters are 6: v, n, m, b, p and c.

Conceptually I can think of my results as a multidimensional array, where any dimension is a different parameter: times[A][B][C][D][E][F] would contain the execution time of the simulation using parameters v=A, n=B, m=C, b=D, p=E and c=F.

I’d like to be able to fix some of these parameters and iterate over the others:

for A:
  for C:
    for F:
      times[A][0][C][0][0][F]

The input parameters values are sparse, so I should use dictionaries instead of lists.

I was thinking about using a dict of dict of dict of dict of dict of dict to do the whole thing, each execution time would be represented like this:

times = { A:{ B:{ C:{ D:{ E:{ F:{time} } } } } } }

but this solution doesn’t look elegant at all: building the whole structure and iterating over it is a pain.

Is there any better way to work with my data?

Answer 1

First, if you have to use a dictionary, why not just create a single dictionary, using tuples to index it? Second, use itertools.product to avoid troublesome nested loops:

>>> import itertools
>>> d = {}
>>> for tup in itertools.product(range(5), repeat=2):
...     d[tup] = tup
... 
>>> d
{(1, 3): (1, 3), (3, 0): (3, 0), (2, 1): (2, 1), (0, 3): (0, 3), (4, 0): (4, 0), 
 (1, 2): (1, 2), (3, 3): (3, 3), (4, 4): (4, 4), (2, 2): (2, 2), (4, 1): (4, 1), 
 (1, 1): (1, 1), (3, 2): (3, 2), (0, 0): (0, 0), (0, 4): (0, 4), (1, 4): (1, 4), 
 (2, 3): (2, 3), (4, 2): (4, 2), (1, 0): (1, 0), (0, 1): (0, 1), (3, 1): (3, 1), 
 (2, 4): (2, 4), (2, 0): (2, 0), (4, 3): (4, 3), (3, 4): (3, 4), (0, 2): (0, 2)}

However, there might be better ways to create a sparse array. scipy provides sparse matrices, but they are 2-d only, I believe.

Here are some other usage patterns you might find useful:

>>> for tup in itertools.product(range(5), repeat=2):
...     if tup[0] == tup[1]:
...         d[tup] = tup
... 
>>> d
{(3, 3): (3, 3), (0, 0): (0, 0), (1, 1): (1, 1), (4, 4): (4, 4), (2, 2): (2, 2)}

>>> for tup in itertools.product(range(5), range(2)):
...     print d.get(tup)
... 
(0, 0)
None
None
(1, 1)
None
None
None
None
None
None

To be less oblique, here’s how you would hold one variable constant: just pass a one-item sequence to itertools.product:

>>> for tup in itertools.product(range(3), [2], range(3)):
...     print tup
... 
(0, 2, 0)
(0, 2, 1)
(0, 2, 2)
(1, 2, 0)
(1, 2, 1)
(1, 2, 2)
(2, 2, 0)
(2, 2, 1)
(2, 2, 2)