How to convert a dictionary of lists to a list of lists in Python

This is my OLD blog. I've copied this post over to my NEW blog at:

http://www.saltycrane.com/blog/2007/12/how-to-convert-dictionary-of-lists-to/

You should be redirected in 2 seconds.

UPDATE: See my new post, Tabular data structure conversion in Python for an updated method which handles non-rectangular data.

The functions below convert a rectangular dictionary of lists to a list of lists. Each list in the dictionary must be the same length. Additionally, a list of keys is required as an input argument to specify the desired ordering of the columns in the returned list of lists. If this were not specified, the order of the columns would be unknown since items in a dictionary are unordered.

The converted list of lists can contain either a list of rows or a list of columns. The first two functions create a lists of rows; the last two create a list of columns. (I consider each list in the dict of lists as a column, and all items for a given index a row.)

I also compare the imperative/ procedural approach to the declarative/ functional approach. I like the declarative/functional approach because it is so concise, and, I believe, a little faster as well.

#!/usr/bin/python

# IMPERATIVE/PROCEDURAL APPROACH
def byrow_imper(dol, keylist):
    """Converts a dictionary of lists to a list of lists using the
    values of the dictionaries. Each list must be the same length.
       dol: dictionary of lists
       keylist: list of keys, ordered as desired
       Returns: a list of lists where the inner lists are rows. 
         i.e. returns a list of rows. """
    lol = []
    for i in xrange(len(dol[keylist[0]])):
        row = []
        for key in keylist:
            row.append(dol[key][i])
        lol.append(row)
    return lol

# DECLARATIVE/FUNCTIONAL APPROACH
def byrow_decl(dol, keylist):
    """Converts a dictionary of lists to a list of lists using the
    values of the dictionaries. Each list must be the same length.
       dol: dictionary of lists
       keylist: list of keys, ordered as desired
       Returns: a list of lists where the inner lists are rows. 
         i.e. returns a list of rows. """
    return [[dol[key][i] for key in keylist] 
            for i in xrange(len(dol[keylist[0]]))]

# IMPERATIVE/PROCEDURAL APPROACH
def bycol_imper(dol, keylist):
    """Converts a dictionary of lists to a list of lists using the
    values of the dictionaries. Each list must be the same length.
       dol: dictionary of lists
       keylist: list of keys, ordered as desired
       Returns: a list of lists where the inner lists are columns. 
         i.e. returns a list of columns. """
    lol = []
    for key in keylist:
        col = []
        for item in dol[key]:
            col.append(item)
        lol.append(col)
    return lol

# DECLARATIVE/FUNCTIONAL APPROACH
def bycol_decl(dol, keylist):
    """Converts a dictionary of lists to a list of lists using the
    values of the dictionaries. Each list must be the same length.
       dol: dictionary of lists
       keylist: list of keys, ordered as desired
       Returns: a list of lists where the inner lists are columns. 
         i.e. returns a list of columns. """
    return [[item for item in dol[key]] for key in keylist]

# TEST
if __name__ == "__main__": 
    dol = {
        'a': ['a1', 'a2', 'a3'],   # column a
        'b': ['b1', 'b2', 'b3'],   # column b
        'c': ['c1', 'c2', 'c3'],   # column c
        }
    keylist = ['a', 'b', 'c']
    print byrow_imper(dol, keylist)
    print byrow_decl(dol, keylist)
    print bycol_imper(dol, keylist)
    print bycol_decl(dol, keylist)

Results:

[['a1', 'b1', 'c1'], ['a2', 'b2', 'c2'], ['a3', 'b3', 'c3']]
[['a1', 'b1', 'c1'], ['a2', 'b2', 'c2'], ['a3', 'b3', 'c3']]
[['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3']]
[['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3']]