Automate the Boring Stuff Chapter 6 Table Printer Almost Done

Here you go young padawan:

tableData=[['apples', 'oranges', 'cherries', 'banana'],
    ['Alice', 'Bob', 'Carol', 'David'],
    ['dogs', 'cats', 'moose', 'goose']]
maxlen = 0
for fruit,name,animal in zip(tableData[0], tableData[1], tableData[2]):
    maxlen = max(len(fruit) + len (name) + len (animal), maxlen)
for fruit,name,animal in zip(tableData[0], tableData[1], tableData[2]):
    length = len(fruit) + len (name) + len (animal) 
    print ((' ' * (maxlen - length)) + fruit, name, animal)

Looping to determine maxlen is probably not optimal, copypasting was just the quickest thing that came to my mind.

First join elements, then find the longest one and then you can use %*s to write lines. More in comments in code.

tableData=[['apples', 'oranges', 'cherries', 'banana'],
        ['Alice', 'Bob', 'Carol', 'David'],
        ['dogs', 'cats', 'moose', 'goose']]

longest = 0 # to find the longest line
lines = [] # to keep lines 

for elements in zip(tableData[0], tableData[1], tableData[2]):

    # join elements in line - like 'apples' + ' ' + 'Alice' + ' ' + 'dogs'
    line = ' '.join(elements) 

    # add line to the list
    lines.append(line) 

    #print(line) # you can print it to see what you get

    # find the longest line
    length = len(line)
    if length > longest:
        longest = length

#print('the longest:', longest)

longest += 1 # to get one space more at left side

# print lines using `%*s`
# if `longest` is 21 then it will works as `%21s`
for line in lines:
    print('%*s' % (longest, line))

I was having exactly the opposite problem: I had already figured out how to determine the parameter for right-justification, and how to right-justify the items. Yet I had difficulty printing several items in one single line. I tried the “end=”” but the output still looked strange. Eventually I tried to concatenate the items to be printed in one line and call the print function one more time in the loop. And it worked.

It took me hours to do this simple exercise but it was definitely worth it!:) It feels really good looking back at how all the incremental improvements finally made the code work!

Here is my code. Hopefully it will help.

tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose', 'goose']]

def printTable(tableData):
    colWidths = [0] * len(tableData)
    for i in range(len(tableData)):
        for j in range(len(tableData[i])):
            if colWidths[i] <= len(tableData[i][j]):
                colWidths[i] = len(tableData[i][j])
            else:
                colWidths[i] = colWidths[i]

    for j in range(len(tableData[i])):
        for i in range(len(tableData)):
            print(''.join(tableData[i][j].rjust(colWidths[i] + 1)), end = '')
            #the "+ 1" is used to allow for a space in between
            print()

printTable(tableData)

Btw, I was surprised that

for j in range(len(tableData[i])):
    for i in range(len(tableData)):

actually worked.

Shouldn’t one always use i before j in this case? It seemed counterintuitive to me yet when gave it a try anyway it miraculously worked.

#! python3
# Table Printer 1

tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose', 'goose']]

def printTable(data):
    colWidths = [0] * len(data)
    for y in range(len(data[0])):
        for x in range(len(data)):
            colWidths[x] = len(max(data[x], key = len))
            print(data[x][y].rjust(colWidths[x]), end = ' ')
        print()

printTable(tableData)


#! python3
# Table Printer 2

tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose', 'goose']]

def printTable(data):
    colWidths = [0] * len(data)
    for x in range(len(data)):
        for y in range(len(data[0])):
            if len(data[x][y]) > colWidths[x]:
                colWidths[x] = len(data[x][y])
    for y in range(len(data[0])):
        for x in range(len(data)):
            print(data[x][y].rjust(colWidths[x]), end = ' ')
        print()

printTable(tableData)

Here is a solution. It works even if no.of inner lists changes or no.of elements in inner list changes given all inner lists have the same no.of elements.

tableData = [
    ['apples', 'oranges', 'cherries', 'banana'],
    ['Alice', 'Bob', 'Carol', 'David'],
    ['dogs', 'cats', 'moose', 'goose']
]

col_widths = list()
for i, record in enumerate(tableData):
    col_widths.insert(i, max(len(item) for item in record))

for i in range(len(tableData[0])):
    print(' '.join(record[i].rjust(col_widths[j]) for j, record in enumerate(tableData)))

#! python3
#table printer prints takes a list of lists of strings and displays it in a
#well-organized table with each column right-justified.

tableData = [['apples', 'oranges', 'cherries', 'banana'],
['Alice', 'Bob', 'Carol', 'David'],
['dogs', 'cats', 'moose', 'goose']]

def printTable(data):
    #in this section we are creating a list containing each column's width
    colWidths = [0] * len(data)
    for m in range(len(colWidths)):
        for n in range(len(data[0])):
            if colWidths[m] < len(data[m][n]):
               colWidths[m] =  len(data[m][n])
    #optionally you can also print colWidths for a better understanding 
    #print(colWidths) will output [8, 5, 5]

    #this section of the code helps arranging the list in a table format
    for u in range(len(data[0])):
        for v in range(len(data)):
            print(data[v][u].rjust(colWidths[v] + 1), end='')
        print()

printTable(tableData)

Based on the author’s hint:

“Hint: Your code will first have to find the longest string in each of the inner lists so that the whole column can be wide enough to fit all the strings. You can store the maximum width of each column as a list of integers. The printTable() function can begin with colWidths = [0] * len(tableData), which will create a list containing the same number of 0 values as the number of inner lists in tableData. That way, colWidths[0] can store the width of the longest string in tableData[0], colWidths[1] can store the width of the longest string in tableData[1], and so on. You can then find the largest value in the colWidths list to find out what integer width to pass to the rjust() string method.”

Here is my answer:

tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose', 'goose']]


def table_printer(tab_data):
    col_widths = [0] * len(tab_data)  # creates 3 lists based on the list length
    for j in range(len(tab_data[0])):  # finds a length of 4 items (aka rows)
        for i in range(len(tab_data)):  # finds a length of 3 items (aka columns)
            col_widths[i] = len((max(tab_data[i], key=len)))  # sets the column width to the maximum length of an item in the list
            a = tab_data[i][j]
            print(a.rjust(col_widths[i]), end=" ")  #  every time we print a column, we rjust it to the max width.
        print("n")


table_printer(tableData)

So this is what I ended up with..without too much internet help. That print line sucks however. I liked some of the above but wasn’t going to copycat.

tableData = [['apples','oranges','cherries','banana'],
             ['Alice','Bob','Carol','David'],
             ['dogs','cats','moose','goose']]

def printTable():
    colWidths=[0]*len(tableData)
    for i in range(len(tableData)):
        for x in range(len(tableData[i])):
            if colWidths[i]<len(tableData[i][x]):
                colWidths[i]=len(tableData[i][x])
    for x in range(len(tableData[i])):
        print(tableData[0][x].rjust(colWidths[0]+1) + tableData[1][x].rjust(colWidths[1]+1) + tableData[2][x].rjust(colWidths[2]+1))

printTable()

The print comes out correct, but I do not like how it doesn’t allow for a dynamic use. Back to the drawing board on the print line.

Here’s how I did it, using both the hint and only information used in the book so far.

This code works no matter how many sublists are within tableData, and no matter how many items are in each sublist.

I used a loop within a loop to achieve this, and print a space after each printed item. If it’s the last category item, then print a new line.

tableData = [['apples', 'oranges', 'cherries', 'banana','orange'],
             ['Alice', 'Bob', 'Carol', 'David','Phillip'],
             ['dogs', 'cats', 'moose', 'goose','anteater'],
             ['mitsubishi','honda','toyota','ford','range rover']]


def printTable(table):
    colWidths = [0] * len(table)
    for i in range(len(table)):
        for x in table[i]:
            if len(x) > colWidths[i]:
                colWidths[i] = len(x)
    print(colWidths)

    for i in range(len(table[0])):
        for x in range(len(table)):
            print(table[x][i].rjust(colWidths[x]),end = ' ')
            if x == len(table)-1:
                print('r')



printTable(tableData)


'''
table[0,0] + table [1,0] + table [2,0]
table[1,0] + table [1,1]

'''

tableData = [['apples', 'oranges', 'cherries', 'banana'],
         ['Alice', 'Bob', 'Carol', 'David'],
         ['dogs', 'cats', 'moose', 'goose']]



def printTable():
 #List colWidth contains the longest string in each of the inner lists
 colWidth=[0]*len(tableData)

 n=0
 #To find the longest string in each of the inner lists and store in 
  colWidth
 for li in tableData:
    num=0
    for j in li:
        if(num<len(j)):
            num=len(j)
    colWidth[n]=num
    n=n+1

#To find the largest value in the colWidths list to find out what integer 
 width to pass to the rjust() string method.
 c=0
 for i in colWidth:
    if(c<i):
        c=i

#To print the data
 for m in range(len(tableData[0])):
    for n in range(len(tableData)):
        print (tableData[n][m]).rjust(c),
    print('')

printTable()

tableData = [['apples', 'oranges', 'cherries', 'banana'],
            ['Alice', 'Bob', 'Carol', 'David'],
            ['dogs', 'cats', 'moose', 'goose']]

def printTable(list):
    len_list = []
    for i in range(len(list)):
        len_list.append(len(max(list[i], key=len)))
    for m in range(len(list[i])):
        for i in range(len(list)):
            print(list[i][m].rjust(len_list[i]+1), end = "")
        print() #to add a new line

printTable(tableData)

I think the easiest solution is to find the length of maximum size string in the whole list(inner and outter) and then set it as argument for right justification method (rjust()) then use loops for printing the list values according to the question.

tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose', 'goose']]


innerlen=0

for m in tableData:
    for n in m:
        if innerlen < len(n):
            innerlen = len(n)




for m in range(len(tableData[0])):
    for n in range(len(tableData)):
        print(tableData[n][m].rjust(innerlen),end="")

    print("")

Here is my approach to the exercise:

#!/usr/bin/env python3

tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose','goose']]

def printTable():
    colWidths = [0] * len(tableData)

    # find longest word in each list, convert to int
    # and add to colWidths var
    for i in range(len(tableData)):
        for l in tableData[i]:
            if len(l) >= colWidths[i]:
                colWidths[i] = len(l)
    # print and justify using the values from colWidths + 1
    for t in range(4):
        print(tableData[0][t].rjust(colWidths[0]+1) + 
              tableData[1][t].rjust(colWidths[1]+1) + 
              tableData[2][t].rjust(colWidths[2]+1))

printTable()

def print_table(tab):
    for j in range(len(tab[0])):
        for i in range(len(tab)):
            m = max([len(s) for s in tab[i]])
            print(tab[i][j].rjust(m), end=' ')
        print('')


tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose', 'goose']]

print_table(tableData)

Maybe not the best way, but here is my solution to the task:

def printtable(listlist):
    # variable stores the maximum length of the words in the lists
    lenghtCounter = 0  #8
    listCounter = 0  #3
    dict = {}

    for list in listlist:
        listCounter += 1
        wordcounter = 0  

        for pos in range(len(list)):
            wordcounter += 1

            for word in list[pos:len(list):len(list)]:
                dict.update({list[pos]: pos})

                # length counter will store the longest value
                if len(word) > lenghtCounter:
                    lenghtCounter = len(word)

    for i in range(wordcounter):
        line = []
        strline = ''

        for k, v in dict.items():
            if v == i:
                line.append(k)
                strline.join(k.ljust(lenghtCounter))

        for el in line:
            strline += el.ljust(lenghtCounter + 5)
        print(strline)

tableData = [
    ['apples', 'oranges', 'cherries', 'bananas'],
    ['Alice', 'Bob', 'Carol', 'David'],
    ['dogs', 'cats', 'moose', 'goose']
]

printtable(tableData)

tableData = [['apples', 'oranges', 'cherries', 'banana'],
        ['Alice', 'Bob', 'Carol', 'David'],
        ['dogs', 'cats', 'moose', 'goose']]



def find_max_length(item_list):
    #find the length of the "item_list" parameter
    colWidth = [0] * len(item_list)

     #an empty list created to hold a single inner list from the                             #"item_list" parameter
     not_so_emptylist = []

    i = 0
    maxlength = 0 #variable to hold max length of an item in the inner list  

    for i in range(len(item_list)):
        not_so_emptylist = item_list[i]
        for item in not_so_emptylist:
            if len(item) > maxlength:
                maxlength = len(item)
        colWidth[i] = maxlength
        maxlength = 0

    return colWidth 

#an empty list to pass colwidth to
width = []

def print_table_data(a_list):
    width = find_max_length(a_list)

    i = 0

    for i in range(4):
        print(a_list[0][i].rjust(width[0]) + ' ' + a_list[1][i].rjust(width[1]) + ' ' + a_list[2][i].rjust(width[2]))

print_table_data(a_list=tableData)

Here, first of all we have to calculate the length of longest string in each of inner list, which we will store in the “colWidths” list. After that we will simply traverse through the “tableData” list. But while printing, we need to right justify each string by maximum column width (i.e. stored in colwidth) for that string so that symmetry can be maintained.Else is just printing.

tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose', 'goose']]

def printTable(t):
    colWidths=[0] * len(tableData)
    l=[]
    for j in range(len(t)):
        for i in t[j]:
            l+=[len(i)]
        colWidths[j]= max(l)
        l=[]
    print(colWidths)

    for j in range(len(t[0])):
        for i in range(len(t)):
            print(t[i][j].rjust(colWidths[i]),end=' ')
        print(end='n')

printTable(tableData)

that’s my method to solve this problem.

tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose', 'goose']]


def printTable(mylist):
  #getting the item who has the max length in the inner tables
  maxLength = 0
  for item in mylist:
    for i in item:
      if len(i) > maxLength:
        maxLength = len(i)
      else:
        maxLength = maxLength
  # make a seperated rjust for every item in the inner lists
  for item in mylist:
    for i in range(len(item)):
      item[i] = (item[i].rjust(maxLength))
  # convert list to dictionary data type it's more easier to deal with.
  myNewlist = {0: [], 1: [], 2: [], 3: []}
  for i in range(len(item)):
    for u in tableData:
      myNewlist[i].append(u[i])
  # print the out put :) 
  for key, value in myNewlist.items():
    print(''.join(value))


(printTable(tableData))

def table_print(tabledata):
    column=[0]*len(tabledata)
    for k in  range(len(tabledata)):
        column[k]=len(max(tabledata[k],key=len))

    for i in range(len(tabledata[0])):
        for j in range(len(tabledata)):
            print(tabledata[j][i].rjust(column[j]+1),end="")
        print()
    return
table_Data = [['app', 'oranges', 'cherries', 'banana'],
['Ale', 'Bob', 'Crol', 'Dad'],
['dogs', 'cats', 'moose', 'ge']]
table_print(table_Data)

This is how I did.

For the first part of the code I just used the hint they give to us.

In Chapter 4 / Practice Project / Character Picture Grid we’ve learned how to “rotate” and then print a list of lists. It was useful for the second part of my code.

#!/usr/bin/python3
# you can think of x and y as coordinates

tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose', 'goose']]

def printTable(table):
    # create a new list of 3 "0" values: one for each list in tableData
    colWidths = [0] * len(table)
    # search for the longest string in each list of tableData
    # and put the numbers of characters in the new list
    for y in range(len(table)):
        for x in table[y]:
            if colWidths[y] < len(x):
                colWidths[y] = len(x)

    # "rotate" and print the list of lists
    for x in range(len(table[0])) :
        for y in range(len(table)) :
            print(table[y][x].rjust(colWidths[y]), end = ' ')
        print()
        x += 1

printTable(tableData)

So many different solutions! The book teaches us to each range(len(x)) and I’ve read online that this is not a good way of getting indexes. A better suggested solution is enumerate which I used in my code, you can find more information here:

https://python-forum.io/Thread-Basic-Never-use-for-i-in-range-len-sequence

#! python3
# printTable.py - Displays a list in a well organized table

tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose', 'goose']]
columnWidth = [] # Creates a empty list

def printtable(printdata):
    for data in printdata:
        # Adds the length of the longest string to the columnWidth list
        columnWidth.append(len(max(data, key=len))) 
    # For loop to decide the determine the number of columns to cycle through
    for x, columnData in enumerate(printdata[0]): 
        # For loop for the number of rows to cycle through
        for y, rowData in enumerate(printdata): 
            # Print each row data with the correct justification
            print(printdata[y][x].rjust(columnWidth[y]), end=' ')
        # Create a new line before reiterating
        print('') 

printtable(tableData)

It’s fun to see how everyone does it differently but still gets the same result. I did it like this:

tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose', 'goose']]

def printTable(table):
    table_len = []
    max_of_table = []
    next_item = ''
    for i in range(len(table)):
        temp_len = []
        for k in range(len(table[i])):
            temp_len.append(len(table[i][k]))
        table_len.append(temp_len)
    for b in table_len:
        max_of_table.append(max(b))
    for a in range(len(table[0])):
        for s in range(len(table)):
            next_item = str(table[s][a])
            next_item = next_item.rjust(max_of_table[s])
            print(next_item, end=' ')
        print('')

printTable(tableData)

I think this would be the answer if you follow the book. Tips and what you have learned so far included.

tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose', 'goose']]

Create the function ‘printTable’. First thing is getting the length of the 3 longest string in the 3 lists and putting the integer values in de list ‘colWidths’

def printTable(table):
    colWidths = [0] * len(table) # The tip from the book
    for i in range(len(table)):
        for s in range(len(table[i])):
            l = len(table[i][s]) # get the length of the individual strings
            if colWidths[i] < l: # check wich one is the longest
                colWidths[i] = l # save the value in the list

Next part of the function is getting the right column oirder from the items in the list. I’ve had some troubl;e with this part, but eventually i’ve got it.

    for x in range(len(table[0])):
        for y in range(len(table)):
            if y == len(table) - 1:
                print(table[y][x].rjust(colWidths[y], ' '))
            else:
                print(table[y][x].rjust(colWidths[y], ' '), end=' ')

execute the function:

printTable(tableData)

My solution:

tableData = [['apples', 'oranges', 'cherries', 'banana'],
         ['Alice', 'Bob', 'Carol', 'David'],
         ['dogs', 'cats', 'moose', 'goose']]


def printTable(table):
liste = 0
colWidths = [0] * len(tableData)
for lister in table:
    liste = liste +1
    longest =0
    for strenge in lister:
        if len(strenge) > longest:
            longest = len(strenge)
    colWidths.insert((liste-1),longest)

for i in range(len(lister)):
    print()
    for lister in table:
        print (lister[i].rjust(colWidths[0]),end='')

printTable(tableData)

I know it has been years, but i started reading the book couple of weeks ago and this is how figured out that one :’D

tableData = [['apples', 'oranges', 'cherries', 'banana'], 
             ['Alice', 'Bob', 'Carol', 'David'], 
             ['dogs', 'cats', 'moose', 'goose']]
n=0
x=''
colWidths=[0]*len(tableData)

for i in range(len(tableData)):
    for n in range(len(tableData[0])-1):
        if colWidths[i]<len(tableData[i][n])+1:
            colWidths[i]=len(tableData[i][n])+1

for n in range(len(tableData[n])):
    x=''
    for i in range(len(tableData)):
        x+=str(tableData[i][n]).rjust(colWidths[i])

    print(x)

This is the simplest way I found to satisfy the goal. Here is my code:

tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose', 'goose']]

def printTable(myTable):

    #each column is a different width, so colWidth is a list which contains the width of each column
    #this is also suggested in the problem itself
    colWidth=[0]*len(myTable)
    for x in range(len(myTable)):
        for item in myTable[x]:
            if len(item)>colWidth[x]:
                colWidth[x]=len(item)

    #printing the table is similar to the exercise at the end of Chapter 4
    for a in range (len(myTable[0])):
        for b in range (len(myTable)):
            print (str(myTable[b][a]).rjust(colWidth[b]), end = ' ')
        print('n')

printTable(tableData)

# table printer
def printtable(tabledata,columnwidth):
    for y in range(4):
        print()
        for x in range(len(tabledata)):
            print(tabledata[x][y].rjust(columnwidth),end='')
    tabledata=[['apples','oranges','cherries','banana'],. 
     ['Alice','Bob','Carol','David'],
     ['dogs','cats','moose','goose']]
    n=len(tabledata[0][0]
    for y in range(4):
        for x in range(len(tabledata)):
            if len(tabledata[0][0])>=len(tabledata[x][y]):
               False
           else:
               n=len(tabledata[x][y])
    printtable(tabledata,n)

My solution below.

tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose', 'goose']]

def printTable(tableData):

    finalList = []

    for i in range (0, 4):

        #iterate through each list in tableData    
        for lists in tableData:             

            #value of longest string in each list       
            longestValue = len(max(lists, key=len))

            #add each value list0[0], list1[0], etc. to finalList...             
            #width = longestValue  
            finalList += lists[i].rjust(longestValue) + "  "

            #skip to new line at end of sequence
            finalList += 'n'   

    #join list into a string for output    
    s = ''
    finalList = s.join(finalList) 

    #return final list as a formatted string
    print(finalList)                                            

printTable(tableData)

To be more dynamic, I have written the script in Python 3.

tableData = [['apples', 'oranges', 'cherries', 'banana', 'dragonfruit'],
             ['Alice', 'Bob', 'Carol', 'David', 'Steve'],
             ['dogs', 'cats', 'moose', 'goose', 'lioness']]

"""
     apples Alice    dogs
    oranges   Bob    cats
   cherries Carol   moose
     banana David   goose
dragonfruit Steve lioness
"""

results = []
final = []
list_length = 0
elements_length = 0
long_str = {}


def printTable(tableData, list_length):

    # Get the max elements which exists inside list of list
    for elements in tableData:
        if list_length != len(elements):
            list_length = len(elements)

    # To create keys to store the maximum length of string in the list of ist
    for i, names in enumerate(tableData):
        col = 'col'
        col = col + str(i+1)
        max_length = 0
        for name in names:
            if len(name) > max_length:
                max_length = len(name)
                long_str[col] = max_length
            else:
                pass

    # To gather the elements across multiple lists based on their index value
    for iteration in range(list_length):
        initial_list = []
        for element in tableData:
            initial_list.append(element[iteration])
        results.insert(iteration, initial_list)

    # To right adjust all the elements in the list of list
    for i, result in enumerate(results):
        indent_list = []
        for index in range(len(result)):
            col_no = 'col' + str(index+1)
            indent_list.append(result[index].rjust(long_str[col_no]))
        final.insert(i, indent_list)

    # To get the string like output
    for final_element in final:
        print(' '.join(final_element))

printTable(tableData, list_length)

So, I know this is an old answer but some people are starting to learn python just now, and this book is amazing! Here is my answer, I think it’s a bit simpler than what other’s wrote:

#! Python 3
#Table printer

tableData = [['apples', 'oranges', 'cherries', 'banana'],
['Alice', 'Bob', 'Carol', 'David'],
['dogs', 'cats', 'moose', 'goose']]

def Tableprinter(tableData):
    listademax=[]
    for i in range(len(tableData)):
        listademax.append(len(max(tableData[i],key=len)))
    elmax=int(max(listademax))
    for m in range(len(tableData[0])):
        for n in range(len(tableData)):
            print(tableData[n][m].rjust(elmax),end=' ')
        print()

Tableprinter(tableData)

This is how I did it, not sure if it’s the best answer but the most upvoted answer doesn’t work properly:

tableData = [['apples', 'oranges', 'cherries', 'banana'],
         ['Alice', 'Bob', 'Carol', 'David'],
         ['dogs', 'cats', 'moose', 'goose']]


def printTable(table):
    colWidths = [0] * len(table)

    for i in range(len(table)): #for each list
        for j in range(len(table[i])): #for each word in the list
            if(len(table[i][j]) > colWidths[i]): #if longest word
                colWidths[i] = len(table[i][j]) #store new max len

    for n in range(len(table[0])): # for len of each list (same size in spec)
        for m in range(len(table)):
            print(table[m][n].rjust(colWidths[m]), end=" ") # print each column 
        print('', end='n')
    

printTable(tableData)

W = 3
H = 4
def printTable(table):
    colWidth = []
    for i in range(W):
        r =[]
        for j in range(H):
            count = len(table[i][j])
            r.append(count)
        colWidth.append(r)
    right = []
    for i in range(len(colWidth)):
        m = max(colWidth[i])
        right.append(m)
    for j in range(H):
        for i in range(W):
            print(table[i][j].rjust(right[i]), end = ' ')
        print()
tableData = [['apples', 'oranges', 'cherries', 'banana'],
         ['Alice', 'Bob', 'Carol', 'David'],
         ['dogs', 'cats', 'moose', 'goose']]
printTable(tableData)
    

First I went through the length of the list. Then take the first first items from each list. Then pasted together and used .ljust() to order
C = 0, starts at the beginning of the list and scrols through with c += 1.

'''
_summary_
'''

tableData = [['apples', 'oranges', 'cherries', 'bananaes', ],
             ['alice', 'bob', 'carol', 'david'],
             ['dogs', 'cats', 'moose', 'goose']]


def nicePrint(aTable):
    '''
    _Make a nice print
    aTable - insert list data
    '''
    c = 0  # start of the list

    for x in range(len(aTable)):  # Get the lenght of the list
        for l in aTable:  # scroll trhough the list
            # getting the fist items from every list and print it
            print(l[c].ljust(10), end='')
        c += 1
        print()  # seperate lists


nicePrint(tableData)  # insirt list data