Standard Python string formatting may suffice.

# assume that your data rows are tuples
template = "{0:8}|{1:10}|{2:15}|{3:7}|{4:10}" # column widths: 8, 10, 15, 7, 10
print template.format("CLASSID", "DEPT", "COURSE NUMBER", "AREA", "TITLE") # header
for rec in your_data_source: 
  print template.format(*rec)

Or

# assume that your data rows are dicts
template = "{CLASSID:8}|{DEPT:10}|{C_NUM:15}|{AREA:7}|{TITLE:10}" # same, but named
print template.format( # header
  CLASSID="CLASSID", DEPT="DEPT", C_NUM="COURSE NUMBER", 
  AREA="AREA", TITLE="TITLE"
) 
for rec in your_data_source: 
  print template.format(**rec)

Play with alignment, padding, and exact format specifiers to get best results.

You should be able to use the format method:

"Location: {0:20} Revision {1}".format(Location, Revision)

You will have to figure out the format length for each line depending on the length of the label. The User line will need a wider format width than the Location or District lines.

There are some light and useful python packages for this purpose:

1. tabulate

https://pypi.python.org/pypi/tabulate

from tabulate import tabulate
print(tabulate([['Alice', 24], ['Bob', 19]], headers=['Name', 'Age']))

Name      Age
------  -----
Alice      24
Bob        19

tabulate has many options to specify headers and table format.

print(tabulate(
    [['Alice', 24], ['Bob', 19]],
    headers=['Name', 'Age'],
    tablefmt='orgtbl'))

| Name   |   Age |
|--------+-------|
| Alice  |    24 |
| Bob    |    19 |

2. PrettyTable

https://pypi.python.org/pypi/PrettyTable

from prettytable import PrettyTable
t = PrettyTable(['Name', 'Age'])
t.add_row(['Alice', 24])
t.add_row(['Bob', 19])
print(t)

+-------+-----+
|  Name | Age |
+-------+-----+
| Alice |  24 |
|  Bob  |  19 |
+-------+-----+

PrettyTable has options to read data from csv, html, sql database. Also you are able to select subset of data, sort table and change table styles.

3. texttable

https://pypi.python.org/pypi/texttable

from texttable import Texttable
t = Texttable()
t.add_rows([['Name', 'Age'], ['Alice', 24], ['Bob', 19]])
print(t.draw())

+-------+-----+
| Name  | Age |
+=======+=====+
| Alice | 24  |
+-------+-----+
| Bob   | 19  |
+-------+-----+

with texttable you can control horizontal/vertical align, border style and data types.

4. termtables

https://github.com/nschloe/termtables

import termtables as tt

string = tt.to_string(
    [["Alice", 24], ["Bob", 19]],
    header=["Name", "Age"],
    style=tt.styles.ascii_thin_double,
    # alignment="ll",
    # padding=(0, 1),
)
print(string)

+-------+-----+
| Name  | Age |
+=======+=====+
| Alice | 24  |
+-------+-----+
| Bob   | 19  |
+-------+-----+

with texttable you can control horizontal/vertical align, border style and data types.

Other options

• terminaltables - Easily draw tables in terminal/console applications from a list of lists of strings. Supports multi-line rows.
• asciitable can read and write a wide range of ASCII table formats via built-in Extension Reader Classes.

I highly suggest you to convert your Table into a pandas Dataframe. If you do so, obtaining a tabular representation of your table is easy using to_markdown:

# Generating a test table in pandas
df  = pd.DataFrame({'Column_2': {'test': 'Craig', 'test2': 'Bob', 'test3': 'Bill'},
 'Column_3': {'test': False, 'test2': False, 'test3': False},
 'Column_4': {'test': '[]', 'test2': '[]', 'test3': '[]'},
 'Column_5': {'test': '<function Foo at 0x7f9f898a0e18>',
  'test2': '<function Bar at 0x7f9f881ae730>',
  'test3': '<function Baz at 0x7f9f881ae7b8>'}})
df.index.name = 'Column_1'

# Printing the table in a nice tabular way:
print(df.to_markdown())
| Column_1   | Column_2    | Column_3    | Column_4    | Column_5                         |
|:-----------|:------------|:------------|:------------|:---------------------------------|
| test       | Craig       | False       | []          | <function Foo at 0x7f9f898a0e18> |
| test2      | Bob         | False       | []          | <function Bar at 0x7f9f881ae730> |
| test3      | Bill        | False       | []          | <function Baz at 0x7f9f881ae7b8> |

In general, all table operations are supported by pandas, which is why it is not recommended to build your own Table structure (unless this is part of some learning course).

Here is a simple, self-contained example that shows how to format variable column widths:

data = '''\
234 127 34 23 45567
23 12 4 4 45
23456 2 1 444 567'''

# Split input data by row and then on spaces
rows = [ line.strip().split(' ') for line in data.split('\n') ]

# Reorganize data by columns
cols = zip(*rows)

# Compute column widths by taking maximum length of values per column
col_widths = [ max(len(value) for value in col) for col in cols ]

# Create a suitable format string
format = ' '.join(['%%%ds' % width for width in col_widths ])

# Print each row using the computed format
for row in rows:
  print format % tuple(row)

which outputs:

  234 127 34  23 45567
   23  12  4   4    45
23456   2  1 444   567

One possible solution is to rely on some package that has been designed for this purpose, like tabulate: Read more about it!

Keep in mind that you have to install this using e.g. pip install tabulate

from tabulate import tabulate

print tabulate([[00, 00, 00], [00, 00, 00], [00, 00, 00]], headers=['X Coordinate','Y Coordinate','Result'], tablefmt='orgtbl')

Or use your original table with this code:

alignment = len(max(table.split("\t")))+1
    
for line in table.strip().split("\n"):
    row ="{{:>{}}}".format(alignment) * len(line.strip().split("\t"))
    print row.format(*line.strip().split("\t"))