Question

I have found a function that takes a list of lists and return a string.
However I have a hard time understanding exactly what it is doing? Please comment the code below:

def getAsTable(self, arrays):
    """ This method takes an array of arrays and returns string (which is really a table) 
    :param arrays: An array of arrays 
    :returns: string (this is really a table of the input)

    >>> [[a, b, b], [1, 2, 3], [4, 5, 6]]
    >>> a    b    c
    >>> 1    2    3
    >>> 4    5    6

    """
    def areAllEqual(lst):
        return not lst or [lst[0]] * len(lst) == lst

    if not areAllEqual(map(len, arrays)):
        return "Cannot print a table with unequal array lengths"

    verticalMaxLengths = [max(value) for value in map(lambda * x:x, *[map(len, a) for a in arrays])]
    spacedLines = []

    for array in arrays:
        spacedLine = ''
        for i, field in enumerate(array):
            diff = verticalMaxLengths[i] - len(field)
            spacedLine += field + ' ' * diff + '\t'
        spacedLines.append(spacedLine)

    return '\n  '.join(spacedLines)

Answer 1

A short explanation of map which saves me from having to litter the code below with comments:

The map function applies its first argument (usually a function, but it can be a class or any other callable thing too) to each value in the second argument and returns the resulting list. Think of it as transforming each element with the given function. Used with two arguments, it works like this:

def map(fct, iterable): return [fct(x) for x in iterable]

Used with three or more arguments, map assumes all arguments after the first one are iterables and iterates through them in parallel, passing the nth element of each iterable on to the function on the nth pass:

def p(a,b,c): print "a: %s, b:%s, c:%s"
map(p, "abc", "123", "456") #-> prints "a 1 4", then "b 2 5", then "c 3 6"

A commented version of your code:

def getAsTable(self, arrays):

    #helper function checking that all values contained in lst are equal
    def areAllEqual(lst):
        #return true for the empty list, or if a list of len times the first
        #element equals the original list
        return not lst or [lst[0]] * len(lst) == lst

    #check that the length of all lists contained in arrays is equal
    if not areAllEqual(map(len, arrays)):
        #return an error message if this is not the case
        #this should probably throw an exception instead...
        return "Cannot print a table with unequal array lengths"

    verticalMaxLengths = [max(value) for value in map(lambda * x:x, *[map(len, a) for a in arrays])]

Let’s split this line into its parts:

(1) [map(len, a) for a in arrays]

This maps len to every list in arrays – meaning you get a list of
lists of lengths of the elements. As an example, for the input [["a","b","c"], ["1","11","111"], ["n", "n^2", "n^10"]] the result would be [[1, 1, 1], [1, 2, 3], [1, 2, 4]].

(2) map(lambda *x:x, *(1))

The * unwraps the list obtained in (1), meaning each element is
passed to map as a separate argument. as described above, with
multiple arguments, map passes a to the function. the lambda
defined here just returns all of its arguments as a tuple.
continuing the example above, for input [[1, 1, 1], [1, 2, 3], [1, 2, 4]]
the result would be [(1, 1, 1), (1, 2, 2), (1, 3, 4)]
this basically results in a matrix transpose of the input

(3) [max(value) for value in (2)]

This calls max on all elements of the list returned in (2) (keep in mind the elements are tuples). For input [(1, 1, 1), (1, 2, 2), (1, 3, 4)] the result would be [1, 2, 4].

So, in the context here, the whole line takes the input array and computes the maximum length of the elements in each column.

The rest of the code:

    #initialize an empty list for the result
    spacedLines = []

    #iterate over all lists
    for array in arrays:
        #initialize the line as an empty string
        spacedLine = ''
        #iterate over the array - enumerate returns position (i) and value
        for i, field in enumerate(array):
            #calculate the difference of the values length to the max length
            #of all elements in the column
            diff = verticalMaxLengths[i] - len(field)
            #append the value, padded with diff times space to reach the
            #max length, and a tab afterwards
            spacedLine += field + ' ' * diff + '\t'
        #append the line to the list of lines
        spacedLines.append(spacedLine)

    #join the list of lines with a newline and return
    return '\n  '.join(spacedLines)