5 Best Ways to Display Python CSV Data as a Table : Emily Rosemary Collins

5 Best Ways to Display Python CSV Data as a Table
by: Emily Rosemary Collins
blow post content copied from  Be on the Right Side of Change
click here to view original post

Rate this post

💡 Problem Formulation: You’ve got a CSV file that needs to be presented clearly and concisely as a table. Whether it’s for data analysis, sharing results, or simply visualizing content, the transformation of CSV data into a table format can be crucial. For this article, we assume you have a CSV file with several columns and rows and you want to display this data within a Python environment as a neatly formatted table.

Method 1: Using Pandas DataFrame

Pandas is an indispensable library in the Python data science ecosystem. It provides a DataFrame object, which is a two-dimensional labeled data structure with columns of potentially different types. This makes it excellent for representing CSV files as tables. The pd.read_csv() function quickly loads the CSV into a DataFrame that can then be easily manipulated and displayed.

Here’s an example:

import pandas as pd

data = pd.read_csv('example.csv')

The output typically resembles a neatly formatted table, depending on the contents of ‘example.csv’.

This code snippet reads a CSV file into a DataFrame, which inherently understands tabular data. We then print out the DataFrame, which Pandas formats as a table automatically in the console.

Method 2: Using Python’s CSV Module

Python’s built-in CSV module can also be used for CSV file manipulation and display. It contains a reader function that can be used to iterate through rows in the CSV file and print them as a table. While this approach requires more coding than using Pandas, it is a built-in module and doesn’t require an additional installation.

Here’s an example:

import csv

with open('example.csv', newline='') as csvfile:
    data = csv.reader(csvfile)
    for row in data:
        print(' | '.join(row))

The output will have the CSV row elements separated by ‘ | ‘, appearing as a rudimentary table.

The code uses the CSV module to read each row from the CSV file and joins the elements with a ‘ | ‘ character to visually represent the rows as a table-like structure.

Method 3: Using Tabulate

The Tabulate library provides an easy way to render a list of dictionaries or a list of lists as a table. It’s great for when you need to print table data to the console in a human-readable format. Installation is easy via pip, and it supports various table formats like grid, fancy grid, and more.

Here’s an example:

from tabulate import tabulate

data = [['Name', 'Age', 'City'],
        ['Alice', 24, 'New York'],
        ['Bob', 29, 'San Francisco']]

print(tabulate(data, headers='firstrow', tablefmt='grid'))

The output will display a neatly formatted grid-like table with headers.

This snippet creates a list of lists where the first list represents the headers of the table. We then feed this data into the tabulate() function which outputs a table-formatted string.

Method 4: Using SQLite in-memory

If your task involves more complex query operations, you might want to make use of an in-memory SQLite database. The csv data can be imported into a database table, and then using SQL queries, we can retrieve and display the data in a tabular format. Although it’s an overkill for simple tasks, it’s extremely powerful for larger datasets and complex queries.

Here’s an example:

import sqlite3
import pandas as pd

data = pd.read_csv('example.csv')
conn = sqlite3.connect(':memory:')
data.to_sql('my_table', conn, index=False)

cur = conn.cursor()
cur.execute('SELECT * FROM my_table')
rows = cur.fetchall()

for row in rows:

This code will load the CSV file into a SQLite in-memory database and then fetch all rows from the table to print them.

The code snippet demonstrates how to read CSV data into a Pandas DataFrame, transfer it to an SQLite in-memory database, and then retrieve and print each row. This can be useful for performing SQL operations on the data.

Bonus One-Liner Method 5: Using PrettyTable

PrettyTable is a simple Python library designed to make it quick and easy to represent tabular data in visually appealing ASCII tables. It can turn a list of lists or another tabular data source into a well-formatted table with just a couple of lines.

Here’s an example:

from prettytable import PrettyTable

table = PrettyTable(["Name", "Age", "City"])
table.add_row(["Alice", 24, "New York"])
table.add_row(["Bob", 29, "San Francisco"])


The output will be a simple table with the specified rows and columns.

With just a few lines, this code snippet creates a PrettyTable object, adds rows to it, and prints a formatted ASCII table. It’s an incredibly straightforward method for generating simple tables.


  • Method 1: Pandas DataFrame. Widely used for data analysis. Provides powerful data manipulation options. May not be ideal for lightweight applications due to its extensive library size.
  • Method 2: Python’s CSV Module. Comes baked into Python’s standard library. Good for simple CSV reading and writing operations without external dependencies. Less functional than Pandas.
  • Method 3: Tabulate. Easy to use for quickly rendering tables in a variety of formats. Lightweight and supports a wide range of table styles. Not as feature-rich as Pandas.
  • Method 4: SQLite in-memory. Great for applying SQL operations on data. Overkill for simple table formatting needs. Offers the power and complexity of a relational database.
  • Method 5: PrettyTable. Extremely simple and ideal for creating nice-looking ASCII tables. Limited functionality for data manipulation beyond what is available through basic table operations.

March 02, 2024 at 03:41AM
Click here for more details...

The original post is available in Be on the Right Side of Change by Emily Rosemary Collins
this post has been published as it is through automation. Automation script brings all the top bloggers post under a single umbrella.
The purpose of this blog, Follow the top Salesforce bloggers and collect all blogs in a single place through automation.