# NumPy: Pretty print tabular data

I would like to print NumPy tabular array data, so that it looks nice. R and database consoles seem to demonstrate good abilities to do this. However, NumPy’s built-in printing of tabular arrays looks like garbage:

``````import numpy as np
dat_dtype = {
'names' : ('column_one', 'col_two', 'column_3'),
'formats' : ('i', 'd', '|U12')}
dat = np.zeros(4, dat_dtype)
dat['column_one'] = range(4)
dat['col_two'] = 10**(-np.arange(4, dtype='d') - 4)
dat['column_3'] = 'ABCD'
dat['column_3'] = 'long string'

print(dat)
# [(0, 1.e-04, 'ABCD') (1, 1.e-05, 'ABCD') (2, 1.e-06, 'long string')
#  (3, 1.e-07, 'ABCD')]
``````

I would like something that looks more like what a database spits out, for example, postgres-style:

`````` column_one | col_two |  column_3
------------+---------+-------------
0 |  0.0001 | ABCD
1 |   1e-05 | ABCD
2 |   1e-08 | long string
3 |   1e-07 | ABCD
``````

Are there any good third-party Python libraries to format nice looking ASCII tables?

## Here is Solutions:

We have many solutions to this problem, But we recommend you to use the first solution because it is tested & true solution that will 100% work for you.

### Solution 1

I seem to be having good output with prettytable:

``````from prettytable import PrettyTable
x = PrettyTable(dat.dtype.names)
for row in dat:
# Change some column alignments; default was 'c'
x.align['column_one'] = 'r'
x.align['col_two'] = 'r'
x.align['column_3'] = 'l'
``````

And the output is not bad. There is even a `border` switch, among a few other options:

``````>>> print(x)
+------------+---------+-------------+
| column_one | col_two | column_3    |
+------------+---------+-------------+
|          0 |  0.0001 | ABCD        |
|          1 |   1e-05 | ABCD        |
|          2 |   1e-06 | long string |
|          3 |   1e-07 | ABCD        |
+------------+---------+-------------+
>>> print(x.get_string(border=False))
column_one  col_two  column_3
0   0.0001  ABCD
1    1e-05  ABCD
2    1e-06  long string
3    1e-07  ABCD
``````

### Solution 2

The `tabulate` package works nicely for Numpy arrays:

``````import numpy as np
from tabulate import tabulate

m = np.array([[1, 2, 3], [4, 5, 6]])
headers = ["col 1", "col 2", "col 3"]

# Generate the table in fancy format.
table = tabulate(m, headers, tablefmt="fancy_grid")

# Show it.
print(table)
``````

Output:

``````╒═════════╤═════════╤═════════╕
│   col 1 │   col 2 │   col 3 │
╞═════════╪═════════╪═════════╡
│       1 │       2 │       3 │
├─────────┼─────────┼─────────┤
│       4 │       5 │       6 │
╘═════════╧═════════╧═════════╛
``````

The package can be installed from PyPI using e.g.

``````\$ pip install tabulate
``````

### Solution 3

you can take advantage of array comprehension and use printf format strings:

``````for c1, c2, c3 in dat:
print "%2f | %8e | %s" % (c1, c2, c3)
``````

https://en.wikipedia.org/wiki/Printf_format_string
And you can get even more customized if you go up to version 2.7

### Solution 4

You might want to check out Pandas which has a lot of nice features for dealing with tabular data and seems to lay things out better when printing (It is designed be a python replacement for R):

http://pandas.pydata.org/

Note: Use and implement solution 1 because this method fully tested our system.
Thank you 🙂

All methods was sourced from stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0