Python 自动化无聊的东西第6章台式打印机几乎完成

在本节中，他们希望我们创建以下表格：

    apples Alice dogs
     oranges Bob cats
 cherries Carol moose
   banana David goose

它必须向右对齐，输入为tableData。这是我的密码：

tableData=[['apples', 'oranges', 'cherries', 'banana'],
        ['Alice', 'Bob', 'Carol', 'David'],
        ['dogs', 'cats', 'moose', 'goose']]
listlens=[]
tour=0
lists={}
for m in tableData:
    total=0
    tour+=1
    for n in m:
        total+=len(n)
        lists["list:",tour]=total
    print("list",tour,total)    

itemcount=list(lists.values())
sortedlen=(sorted(itemcount,reverse=True))
longest=sortedlen[0]

#print (lists['list:', 1])
#print (longest)


for m in range(len(tableData[0])):
    for n in range(len(tableData)):
        print (tableData[n][m],end=" ")
        n+=1
    print ("".rjust(lists['list:', 1],"-"))
    m+=1

我几乎完成了，除了一件事，我不能使它正确。这个输出是我到目前为止最接近的

apples Alice dogs ---------------------------
oranges Bob cats ---------------------------
cherries Carol moose ---------------------------
banana David goose ---------------------------

如果我将rjust放在内部for循环中，则输出会有很大不同：

apples-------------------------- Alice-------------------------- dogs-------------------------- 
oranges-------------------------- Bob-------------------------- cats-------------------------- 
cherries-------------------------- Carol-------------------------- moose-------------------------- 
banana-------------------------- David-------------------------- goose-------------------------- 

---

给你，年轻的学徒：

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)

---

循环确定maxlen可能不是最优的，复制粘贴是我想到的最快的方法。

这里有一种替代方法，也许你可以应用到你自己的代码中。我首先使用了

tableData

，并将其分类到字典中，以便更容易使用。在那之后，我找到了最长的字符列表。这让我们知道短名单应该走多远。最后，我打印出每个列表，根据与最长列表的差异，在较短列表前面添加空格

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

# empty dictonary for sorting the data
newTable = {0:[], 1:[], 2:[], 3:[]}

# iterate through each list in tableData
for li in tableData:
    for i in range(len(li)):
        # put each item of tableData into newTable by index
        newTable[i].append(li[i])

# determine the longest list by number of total characters
# for instance ['apples', 'Alice', 'dogs'] would be 15 characters
# we will start with longest being zero at the start
longest = 0
# iterate through newTable
# for example the first key:value will be 0:['apples', 'Alice', 'dogs']
# we only really care about the value (the list) in this case
for key, value in newTable.items():
    # determine the total characters in each list
    # so effectively len('applesAlicedogs') for the first list
    length = len(''.join(value))
    # if the length is the longest length so far,
    # make that equal longest
    if length > longest:
        longest = length

# we will loop through the newTable one last time
# printing spaces infront of each list equal to the difference
# between the length of the longest list and length of the current list
# this way it's all nice and tidy to the right
for key, value in newTable.items():
    print(' ' * (longest - len(''.join(value))) + ' '.join(value))

---

首先连接元素，然后找到最长的元素，然后可以使用

%*s

写入行。更多信息请参见代码中的注释

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))

---

我遇到了完全相反的问题：我已经知道了如何确定正确对齐的参数，以及如何正确对齐项目。然而，我很难在一行中打印出几个项目。我尝试了“end=”，但是输出看起来仍然很奇怪。最后，我尝试将要打印的项目连接在一行中，并在循环中再次调用print函数。它成功了

做这个简单的练习花了我几个小时，但绝对值得回顾所有增量改进最终是如何使代码工作的，感觉真的很好

这是我的密码。希望这会有所帮助

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)

实际上起了作用

---

在这种情况下，不应该在j之前使用i吗？这对我来说似乎是违反直觉的，但无论如何，当我尝试它时，它奇迹般地工作了。

这里有一个解决方案。如果所有内部列表的元素数量相同，则即使内部列表的数量发生变化或内部列表中的元素数量发生变化，它也可以工作

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)))

#！蟒蛇3
#table printer prints获取字符串列表并将其显示在
#组织良好的表格，每列右对齐。
tableData=[['苹果'、'橘子'、'樱桃'、'香蕉']，
[‘爱丽丝’、‘鲍勃’、‘卡罗尔’、‘大卫’]，
[‘狗’、‘猫’、‘驼鹿’、‘鹅’]]
def打印表（数据）：
#在本节中，我们将创建一个包含每列宽度的列表
colWidths=[0]*len（数据）
对于范围内的m（长度（冷宽））：
对于范围内的n（len（数据[0]）：
如果冷宽[m]

根据作者的提示：

“提示：您的代码首先必须在每个内部列表中找到最长的字符串，以便整列的宽度足以容纳所有字符串。您可以将每列的最大宽度存储为整数列表。printTable（）函数可以以colWidths=[0]*len（tableData）开头。”，它将创建一个包含与tableData中内部列表数量相同数量的0值的列表。这样，colWidths[0]可以存储tableData[0]中最长字符串的宽度，colWidths[1]可以存储tableData[1]中最长字符串的宽度，依此类推。然后，您可以在colWidths列表中找到最大值，以确定传递给rjust（）字符串方法的整数宽度。”

以下是我的答案：

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)

---

这就是我最后得到的…没有太多的网络帮助。然而，那条印刷线很烂。我喜欢上面的一些，但不打算模仿

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()

tableData=[[‘苹果’、‘橙子’、‘樱桃’、‘香蕉’]，
[“爱丽丝”、“鲍勃”、“卡罗尔”、“大卫”]，
[‘狗’、‘猫’、‘驼鹿’、‘鹅’]
def printTable（）：
colWidths=[0]*len（tableData）
对于范围内的i（len（tableData））：
对于范围内的x（len（tableData[i]）：
if colWidths[i]以下是我是如何做到的，使用了本书目前为止使用的提示和信息

无论tableData中有多少子列表，也不管每个子列表中有多少项，此代码都有效

我在一个循环中使用了一个循环来实现这一点，并在每个打印项目后打印一个空格。如果是最后一个类别项目，则打印新行

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=[['苹果'，'橙子'，'樱桃'，'香蕉']，
[‘爱丽丝’、‘鲍勃’、‘卡罗尔’、‘大卫’]，
[‘狗’、‘猫’、‘驼鹿’、‘鹅’]]
def printTable（）：
#List colWidth包含每个内部列表中最长的字符串
colWidth=[0]*len（tableData）
n=0
#在每个内部列表中查找最长的字符串并存储在
冷宽
对于tableData中的li：
num=0
李俊仁：
如果（num我认为最简单的解决方案是找到整个列表（内部和外部）中最大大小字符串的长度，然后将其设置为右对齐方法（rjustion（））的参数，然后根据问题使用循环打印列表值

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("")

tableData=[['苹果'，'橙子'，'樱桃'，'香蕉']，
[‘爱丽丝’、‘鲍勃’、‘卡罗尔’、‘大卫’]，
[‘狗’、‘猫’、‘驼鹿’、‘鹅’]]
innerlen=0
对于tableData中的m：
对于m中的n：
如果内透镜<透镜（n）：
内透镜=透镜（n）
对于范围内的m（len（tableData[0]）：
对于范围内的n（len（tableData））：
打印（tableData[n][m].rjust（innerlen），end=”“）
打印（“”）
以下是我的练习方法：

#!/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 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 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)

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("")

#!/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)

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)

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)

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)

#!/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)

#! 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)

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)

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

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

    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=' ')

printTable(tableData)

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)

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)

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)

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)

#! 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)