Drilling Automation Chapter 6 The Desktop Printer is Almost Ready

Question

Drilling Automation Chapter 6 The Desktop Printer is Almost Ready

In this section, they want us to create this table:

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

It should be justified to the right, and input - tableData. Here is my code:

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

I am almost ready, except for one, I cannot do it right. This result is close to what I have come so far.

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

If I find r inside the inner loop, the output is very different:

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

+5

python python-3.x printing

Stanley Wilkins Dec 28 '15 at 5:28

source share

31 answers

.

, .

4/ / , "", . .

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

+3

Jean-Charles Hervé 12 . '18 15:14

:

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, , , copypasting - , .

+2

Arthur Havlicek 28 . '15 5:44

.

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

+2

kali omar 22 '18 13:51

, , %*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))

+1

furas 28 . '15 6:31

. , . , .

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

+1

pavan 10 . '16 13:47

, , , : '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)

+1

nemso 26 . '18 20:44

: , . , . "end =", . . .

, , !:) , , , !

. , .

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)

, ,

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

.

j ? , , .

0

Randy Gao 25 . '16 8:31

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

0

sanju stephen 09 . '16 2:58

:

". . , , . integer. printTable() colWidths = [0] * len (tableData), , 0 , tableData. , colWidths [0] Data [0], colWidths [1] Data [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)

0

Pete 06 . '17 20:17

, , ... . . , .

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

, , . .

0

Tossaire 06 . '17 20:19

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

def printTable(data):
    for j in range(len(data[0])):
        for i in range(len(data)):
            #This line finds the longest item for each list and its length  
            x = len(max(data[i], key=len))
            print(data[i][j].rjust(x), end=' ')
        print()

printTable(tableData)

0

Sam Mendes 06 . '17 12:46

, , .

, 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]

'''

0

gideon 06 . '17 20:24

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)

0

Bartosz Chojnacki 18 . '18 11:05

! (len (x)), , . , , :

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)

0

John 30 . '18 13:49

, , . , , .

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

"printTable". 3 3 de 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

- . , .

    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)

0

RiekOh 20 . '18 14:20

.

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)

0

user3763074 05 . '19 23:15

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

-1

Ayush Gupta 13 . '17 8:54

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)

-1

Okszana Begy 08 . '17 13:28

, - ( ), (rjust()), .

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

-1

Raunak Patni 12 . '17 16:32

:

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

-1

SirAleXbox 01 . '17 15:18

, , :

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)

-1

user9377387 18 . '18 16:08

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

def printTable(table):
    colWid=[0]*len(tableData)
    i=0
    for row in tableData:
        colWid[i]=len(max(row, key=len))
        i+=1



    print(colWid)

    wid=max(colWid)


    for m in range(len(tableData[0])):

        for n in range(len(tableData)):

            print (tableData[n][m].ljust(wid),end=' ')

        print()

printTable(tableData)

-1

Rohit Sanjay 06 '18 14:20

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)

-1

Abdulrasheed Agunbiade 07 '18 14:11

, , , " colWidths ". " 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)

-1

Arvind Thakur 21 '18 6:52

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)

-1

B B Bharadwaj 11 . '18 19:04

, -, . :

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)

-1

Djaro 31 . '18 13:16

:

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)

-1

JacobSiv Sep 26 '18 at 19:53

source share

This is the easiest way to achieve your 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)

-1

Waldobg Oct 28 '18 at 23:54

source share

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

-1

jamal bagwan Jan 01 '19 at 6:40

source share

vesche · Accepted Answer · 2015-12-28T05:53:27+0000

, , , . 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 all nice and tidy to the right
for key, value in newTable.items():
    print(' ' * (longest - len(''.join(value))) + ' '.join(value))

Drilling Automation Chapter 6 The Desktop Printer is Almost Ready

More articles: