5 Effective Ways to Print a List of Lists as a Table in Python

by

💡 Problem Formulation: When working with data in Python, developers often use lists of lists to represent tabular data. The challenge is to print these nested lists in a way that resembles a traditional table – with rows and columns – to improve readability. For instance, given the input [['Name', 'Age', 'City'], ['Alice', 30, 'New York'], ['Bob', 25, 'San Francisco']], the desired output would be a well-formatted table that clearly presents the data.

Method 1: Using the ‘join’ String Method and a Loop

For a simple table without any external dependencies, the ‘join’ string method combined with a loop can be utilized. This technique involves iterating over the list of lists and using string’s join method to concatenate the items with a given separator, typically tabs or spaces – creating a row string which is then printed.

Here’s an example:

table_data = [['Name', 'Age', 'City'], ['Alice', 30, 'New York'], ['Bob', 25, 'San Francisco']]
for row in table_data:
    print(' '.join(map(str,row)))

Output:

Name Age City
Alice 30 New York
Bob 25 San Francisco

This code snippet works by iterating over each sublist (row) in table_data, converting all elements to strings, and then joining them with a space. The resulting string represents a table row, which is then printed.

Method 2: Using the ‘prettytable’ Library

The ‘prettytable’ library is a Python library specifically designed for printing ASCII tables. It allows for the easy crafting of tabular data with various options for borders, alignment, and more. After installing with pip install prettytable, it provides a high-level API to control the table’s appearance.

Here’s an example:

from prettytable import PrettyTable

t = PrettyTable(['Name', 'Age', 'City'])
t.add_row(['Alice', 30, 'New York'])
t.add_row(['Bob', 25, 'San Francisco'])

print(t)

Output:

+-------+-----+---------------+
| Name  | Age | City          |
+-------+-----+---------------+
| Alice | 30  | New York      |
| Bob   | 25  | San Francisco |
+-------+-----+---------------+

This snippet begins by importing PrettyTable and creating a table instance with headers. Rows are added using the add_row() method. Printing the table object automatically formats the output as an ASCII table.

Method 3: Using pandas DataFrame

pandas is a powerful data manipulation library in Python, and it can also be used for displaying data in a table format. After loading the list of lists into a pandas DataFrame, it inherently provides a visually appealing table-style representation when printed.

Here’s an example:

import pandas as pd

data = [['Name', 'Age', 'City'], ['Alice', 30, 'New York'], ['Bob', 25, 'San Francisco']]
df = pd.DataFrame(data[1:], columns=data[0])

print(df)

Output:

    Name  Age           City
0  Alice   30        New York
1    Bob   25  San Francisco

In this code snippet, the pandas library is imported, and a DataFrame is created using the list of lists, with the first sublist as the column headers. Printing the DataFrame object presents the data in a neatly formatted table.

Method 4: Using tabulate Library

The tabulate library is another Python library dedicated to printing tabular data in a variety of formats including grid, fancy grid, plain, simple, and more. Its simple API makes it a good choice for quickly displaying tables directly from lists of lists.

Here’s an example:

from tabulate import tabulate

table = [["Name", "Age", "City"], ["Alice", 30, "New York"], ["Bob", 25, "San Francisco"]]
print(tabulate(table[1:], headers=table[0], tablefmt='grid'))

Output:

+-------+-----+---------------+
| Name  | Age | City          |
+-------+-----+---------------+
| Alice | 30  | New York      |
| Bob   | 25  | San Francisco |
+-------+-----+---------------+

After importing tabulate, the tabulate() function is called with the data, explicitly stating that the first sublist is the header and specifying the desired format as ‘grid’. The function then outputs the formatted table.

Bonus One-Liner Method 5: Using List Comprehension and ‘join’

For those who prefer a one-liner approach, a combination of list comprehension and the ‘join’ string method can compactly output the list of lists as a formatted table without any additional libraries.

Here’s an example:

data = [['Name', 'Age', 'City'], ['Alice', 30, 'New York'], ['Bob', 25, 'San Francisco']]
print('\n'.join(['\t'.join(map(str,row)) for row in data]))

Output:

Name    Age City
Alice   30  New York
Bob     25  San Francisco

This one-liner transforms each sublist into a tab-separated string using join(map(str,row)) within a list comprehension. These strings are then joined with newline characters to format it as a table, which is printed.

Summary/Discussion

  • Method 1: Join and Loop. Simple and requires no external dependencies. Limited formatting options and does not handle variable column width gracefully.
  • Method 2: prettytable Library. Specifically designed for tabular data representation. Offers extensive table styling capabilities. Requires installation of an external library.
  • Method 3: pandas DataFrame. Ideal for those already using pandas for data analysis. Provides a well-formatted output with minimum effort. Overkill for simple table printing tasks.
  • Method 4: tabulate Library. Easy to use with various table styles available. Like the prettytable, it requires an additional library installation.
  • Bonus Method 5: One-Liner with List Comprehension. Compact and doesn’t require external libraries. Limited formatting and may produce less readable code.