Print NumPy Matrix as Formatted Table with Headers in Python

To print your NumPy matrix as a formatted table with variable-length headers like team names and right-aligned numbers, grab the tabulate library—it’s dead simple and nails the exact alignment you want without loops or padding hacks. Install with pip install tabulate, then feed it your data, headers, and row labels: tabulate(data, headers=teams_list, showindex=teams_list, tablefmt="plain", colalign=("left", "right", "right", "right")). Boom—neat table output matching your style, headers intact, numbers hugging the right edge.

Contents

• Why Formatting NumPy Matrices as Tables Matters
• Tabulate: The Easiest Way to Print Your Table
• Using Pandas for NumPy Matrix Tables
• PrettyTable as a Lightweight Alternative
• Handling Variable Headers and Right Alignment
• Comparing Libraries for NumPy Table Output
• Sources
• Conclusion

Why Formatting NumPy Matrices as Tables Matters

Ever stared at a jumbled NumPy array dump and wished it looked like a proper table? You’re not alone—especially when headers like “Man Utd” or “T Hotspur” have different lengths, throwing off alignment. Your matrix data is straightforward integers, but console output? Messy without help.

The good news: Python libraries handle this effortlessly. No more fumbling with str.rjust() in loops or dicts that fall apart on uneven strings. We’ll walk through tabulate first (it matches your desired output closest), then pandas for data pros, and prettytable for no-frills cases. All work with your exact teams_list and data array. And yeah, we’ll fix that slight mismatch in your example numbers—tabulate prints what’s there, but alignment stays perfect.

Why these? Stack Overflow discussions and library docs rave about them for NumPy matrices turning into readable tables fast.

Tabulate: The Easiest Way to Print Your Table

Tabulate shines for this. Created by Sergey Astanin, it’s lightweight and formats NumPy arrays into plain tables, grids, or even Markdown—perfect for console output.

Here’s your code, tweaked for exact alignment:

import numpy as np
from tabulate import tabulate

teams_list = ["Man Utd", "Man City", "T Hotspur"]
data = np.array([[1, 2, 1],
 [0, 1, 0],
 [2, 4, 2]])

print(tabulate(data, headers=teams_list, showindex=teams_list,
 tablefmt="plain", colalign=("left", "right", "right", "right")))

Output (right-aligned numbers, left for labels/headers):

 Man Utd Man City T Hotspur
 Man Utd 1 2 1
 Man City 0 1 0
 T Hotspur 2 4 2

Spot on? Your desired output had slightly off numbers (like 1 0 0 instead of 1 2 1), but swap data to [[1,0,0],[1,1,0],[0,1,2]] if needed—it’ll align perfectly either way. colalign tuple: first “left” for row labels, then “right” for each column.

Install? pip install tabulate. Supports 30+ formats—try "simple" for light borders or "grid" for fancy ones. As Finxter notes, it’s NumPy-friendly out of the box.

Pro tip: Uneven data types? Tabulate handles floats too, padding smartly.

Using Pandas for NumPy Matrix Tables

No new library? Pandas is your built-in powerhouse if you’re already using it (or pip install pandas). Turn the array into a DataFrame with index and columns from teams_list.

import numpy as np
import pandas as pd

teams_list = ["Man Utd", "Man City", "T Hotspur"]
data = np.array([[1, 2, 1],
 [0, 1, 0],
 [2, 4, 2]])

df = pd.DataFrame(data, index=teams_list, columns=teams_list)
print(df.to_string(justify='right'))

Output:

 Man Utd Man City T Hotspur
Man Utd 1 2 1
Man City 0 1 0
T Hotspur 2 4 2

justify='right' aligns numbers perfectly. Want plain like your example? df.to_string(index=True, header=True, justify='right', border=0) strips extras.

Pandas docs confirm this constructor takes NumPy directly. GeeksforGeeks tutorial shows index/column setup. Bonus: Analyze your matrix later—sums, means, all there.

But heavier than tabulate? Yeah, if you don’t need DataFrames.

PrettyTable as a Lightweight Alternative

Fancy borders without pandas bulk? PrettyTable (from Stack Overflow recs).

from prettytable import PrettyTable
import numpy as np

teams_list = ["Man Utd", "Man City", "T Hotspur"]
data = np.array([[1, 2, 1],
 [0, 1, 0],
 [2, 4, 2]])

table = PrettyTable()
table.field_names = [""] + teams_list # Empty for row labels
for i, row in enumerate(data):
 table.add_row([teams_list[i]] + row.tolist())

# Align: 'l' left, 'r' right
table.align[""] = "l"
for col in teams_list:
 table.align[col] = "r"

print(table.get_string(border=False)) # Plain like your output

Gets close to plain text. border=False mimics tabulate’s “plain”. Install: pip install prettytable.

Great for scripts, but row-by-row adding feels loop-y compared to tabulate’s one-liner.

Handling Variable Headers and Right Alignment

Variable lengths like “T Hotspur” (9 chars) vs “Man City” (8)? Libraries auto-pad based on max width.

• Tabulate: stralign="left", numalign="right" per column.
• Pandas: justify='right' globally, or df.style.format(na_rep='', formatter=dict(zip(teams_list, ['{:>8}' for _ in teams_list]))).
• Edge case: Floats? Add floatfmt=".1f" in tabulate.

Your data’s integers align crisp. Bigger matrix? Scales fine—tabulate/pandas recalculate widths dynamically.

Question: What if headers have spaces or specials? Escape with quotes or use pandas’ columns=teams_list.

Comparing Libraries for NumPy Table Output

Tabulate wins for your use—light, precise. Pandas if you’re chaining to plots/stats. Skip built-ins like np.savetxt (tab-separated, no headers easy).

From sources, DataFrame from NumPy is standard.

Sources

1. tabulate · PyPI — Formatting library for tabular data with NumPy support and alignment options: https://pypi.org/project/tabulate/
2. NumPy: Pretty print tabular data - Stack Overflow — Community solutions using tabulate, prettytable for aligned NumPy output: https://stackoverflow.com/questions/9712085/numpy-pretty-print-tabular-data
3. 5 Best Ways to Convert a Python NumPy Array to a Table – Be on the Right Side of Change — Tutorials on tabulate, pandas, PrettyTable conversions: https://blog.finxter.com/5-best-ways-to-convert-a-python-numpy-array-to-a-table/
4. Creating a Pandas DataFrame from a Numpy array - Stack Overflow — Specifying index and headers for DataFrames from arrays: https://stackoverflow.com/questions/20763012/creating-a-pandas-dataframe-from-a-numpy-array-how-do-i-specify-the-index-colum
5. pandas.DataFrame — pandas 3.0.0 documentation — Official guide to DataFrame construction and string formatting: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html
6. Create a Pandas DataFrame from a Numpy array and specify the index column and column headers - GeeksforGeeks — Step-by-step NumPy to DataFrame with custom labels: https://www.geeksforgeeks.org/python/create-a-pandas-dataframe-from-a-numpy-array-and-specify-the-index-column-and-column-headers/

Conclusion

Tabulate delivers your formatted NumPy matrix table fastest—variable headers aligned, numbers right-justified, no fuss. Pandas steps up for bigger data workflows, while PrettyTable fits quick scripts. Ditch loops; these libraries make Python tables pro-level. Experiment with your data, tweak formats, and you’ll never squint at arrays again. Got larger matrices or exports? Start with tabulate’s docs.