Table Printer Project - Automate the Boring Stuff Chapter 6

Question

The project outline:

Write a function named printTable() that takes a list of lists of strings and displays it in a well-organized table with each column right-justified. Assume that all the inner lists will contain the same number of strings.

My code:

def demo():
    tableData = [['apples', 'oranges', 'cherries', 'banana'],
                ['Alice', 'Bob', 'Carol', 'David',],
                ['dogs', 'cats', 'moose', 'goose']]
    return tableData
    
def printTable(tableData):
    colWidths = [0] * len(tableData)
    for i in range(len(tableData)):
        colWidths[i] = len(max(tableData[i], key=len))
    for x in range(len(tableData[0])):
        for y in range(len(tableData)):
            print(tableData[y][x].rjust(colWidths[y]), end=' ')
        print(end='\n')

printTable(demo())

This took me a while to get my head around. I ended up using max() which the book hasn't covered yet but otherwise I think this is what the author had in mind.

Ways to make it better?

Answer 1

One rarely needs to iterate over collections via indexes. Iterate over the thing itself (the list, tuple, or dict), not the indexes-of-the-thing.

# No.
for i in range(len(table)):
    col = table[i]
    ...

# Yes.
for col in table:
    ...

# Yes (if you also need the indexes).
for i, col in enumerate(table):
    ...

Functions should return data, not print. Your book is giving bad direction by encouraging students to think about functions as printing utilities. Printing is a trivial operation and has no bearing on the interesting parts of this exercise -- namely computing the column widths and transposing the data. The function you write should take data as input (the column-oriented table data) and should return data (width-padded, row-oriented table data). The function below illustrates one way to achieve that. Much more important than the specific code is the general principle: write functions that take data and return data, not functions that have side effects (like printing). Among other advantages, a function like this can be easily subjected to automated testing.

def padded_table(table):
    widths = [
        max(len(cell) for cell in col)
        for col in table
    ]
    return [
        [cell.rjust(w) for cell, w in zip(row, widths)]
        for row in zip(*table)                          # Transpose the table.
    ]

Do the printing elsewhere. After writing a sensible data-centric function, the printing is completely uninteresting.

def main():
    table = [
        ['apples', 'oranges', 'cherries', 'banana'],
        ['Alice', 'Bob', 'Carol', 'David',],
        ['dogs', 'cats', 'moose', 'goose'],
    ]
    for row in padded_table(table):
        print(' '.join(row))          # Super boring!

if __name__ == '__main__':
    main()