Other supported formats are plain (no lines), simple (Pandoc simple tables), pipe (like tables in PHP Markdown Extra), orgtbl (like tables in Emacs' org-mode), rst (like simple tables in reStructuredText). grid and orgtbl are easily editable in Emacs.
Performance-wise, tabulate is slightly slower than asciitable, but much faster than PrettyTable and texttable.
P.S. I'm also a big fan of aligning numbers by a decimal column. So this is the default alignment for numbers if there are any (overridable).
这是我编写的一个快速但肮脏的小函数，用于显示只能通过 SOAP API 进行的 SQL 查询的结果。它需要输入一系列一个或多个namedtuples 作为表行。如果只有一条记录，则会以不同的方式打印出来。
它对我来说很方便，可以作为您的起点：
def pprinttable(rows):
if len(rows) > 1:
headers = rows[0]._fields
lens = []
for i in range(len(rows[0])):
lens.append(len(max([x[i] for x in rows] + [headers[i]],key=lambda x:len(str(x)))))
formats = []
hformats = []
for i in range(len(rows[0])):
if isinstance(rows[0][i], int):
formats.append("%%%dd" % lens[i])
else:
formats.append("%%-%ds" % lens[i])
hformats.append("%%-%ds" % lens[i])
pattern = " | ".join(formats)
hpattern = " | ".join(hformats)
separator = "-+-".join(['-' * n for n in lens])
print hpattern % tuple(headers)
print separator
_u = lambda t: t.decode('UTF-8', 'replace') if isinstance(t, str) else t
for line in rows:
print pattern % tuple(_u(t) for t in line)
elif len(rows) == 1:
row = rows[0]
hwidth = len(max(row._fields,key=lambda x: len(x)))
for i in range(len(row)):
print "%*s = %s" % (hwidth,row._fields[i],row[i])
>>> from collections import namedtuple
>>> Row = namedtuple('Row',['first','second','third'])
>>> data = Row(1,2,3)
>>> data
Row(first=1, second=2, third=3)
>>> pprinttable([data])
first = 1
second = 2
third = 3
>>> pprinttable([data,data])
first | second | third
------+--------+------
1 | 2 | 3
1 | 2 | 3
Here's a quick and dirty little function I wrote for displaying the results from SQL queries I can only make over a SOAP API. It expects an input of a sequence of one or more namedtuples as table rows. If there's only one record, it prints it out differently.
It is handy for me and could be a starting point for you:
def pprinttable(rows):
if len(rows) > 1:
headers = rows[0]._fields
lens = []
for i in range(len(rows[0])):
lens.append(len(max([x[i] for x in rows] + [headers[i]],key=lambda x:len(str(x)))))
formats = []
hformats = []
for i in range(len(rows[0])):
if isinstance(rows[0][i], int):
formats.append("%%%dd" % lens[i])
else:
formats.append("%%-%ds" % lens[i])
hformats.append("%%-%ds" % lens[i])
pattern = " | ".join(formats)
hpattern = " | ".join(hformats)
separator = "-+-".join(['-' * n for n in lens])
print hpattern % tuple(headers)
print separator
_u = lambda t: t.decode('UTF-8', 'replace') if isinstance(t, str) else t
for line in rows:
print pattern % tuple(_u(t) for t in line)
elif len(rows) == 1:
row = rows[0]
hwidth = len(max(row._fields,key=lambda x: len(x)))
for i in range(len(row)):
print "%*s = %s" % (hwidth,row._fields[i],row[i])
import subprocess
import tempfile
import html
def pprinttable(rows):
esc = lambda x: html.escape(str(x))
sour = "<table border=1>"
if len(rows) == 1:
for i in range(len(rows[0]._fields)):
sour += "<tr><th>%s<td>%s" % (esc(rows[0]._fields[i]), esc(rows[0][i]))
else:
sour += "<tr>" + "".join(["<th>%s" % esc(x) for x in rows[0]._fields])
sour += "".join(["<tr>%s" % "".join(["<td>%s" % esc(y) for y in x]) for x in rows])
with tempfile.NamedTemporaryFile(suffix=".html") as f:
f.write(sour.encode("utf-8"))
f.flush()
print(
subprocess
.Popen(["w3m","-dump",f.name], stdout=subprocess.PIPE)
.communicate()[0].decode("utf-8").strip()
)
from collections import namedtuple
Row = namedtuple('Row',['first','second','third'])
data1 = Row(1,2,3)
data2 = Row(4,5,6)
pprinttable([data1])
pprinttable([data1,data2])
Version using w3m designed to handle the types MattH's version accepts:
import subprocess
import tempfile
import html
def pprinttable(rows):
esc = lambda x: html.escape(str(x))
sour = "<table border=1>"
if len(rows) == 1:
for i in range(len(rows[0]._fields)):
sour += "<tr><th>%s<td>%s" % (esc(rows[0]._fields[i]), esc(rows[0][i]))
else:
sour += "<tr>" + "".join(["<th>%s" % esc(x) for x in rows[0]._fields])
sour += "".join(["<tr>%s" % "".join(["<td>%s" % esc(y) for y in x]) for x in rows])
with tempfile.NamedTemporaryFile(suffix=".html") as f:
f.write(sour.encode("utf-8"))
f.flush()
print(
subprocess
.Popen(["w3m","-dump",f.name], stdout=subprocess.PIPE)
.communicate()[0].decode("utf-8").strip()
)
from collections import namedtuple
Row = namedtuple('Row',['first','second','third'])
data1 = Row(1,2,3)
data2 = Row(4,5,6)
pprinttable([data1])
pprinttable([data1,data2])
It is a bit more readable IMHO (although it doesn't differentiate between single / multiple rows like @MattH's solutions does, nor does it use NamedTuples).
def make_table(columns, data):
"""Create an ASCII table and return it as a string.
Pass a list of strings to use as columns in the table and a list of
dicts. The strings in 'columns' will be used as the keys to the dicts in
'data.'
Not all column values have to be present in each data dict.
>>> print(make_table(["a", "b"], [{"a": "1", "b": "test"}]))
| a | b |
|----------|
| 1 | test |
"""
# Calculate how wide each cell needs to be
cell_widths = {}
for c in columns:
values = [str(d.get(c, "")) for d in data]
cell_widths[c] = len(max(values + [c]))
# Used for formatting rows of data
row_template = "|" + " {} |" * len(columns)
# CONSTRUCT THE TABLE
# The top row with the column titles
justified_column_heads = [c.ljust(cell_widths[c]) for c in columns]
header = row_template.format(*justified_column_heads)
# The second row contains separators
sep = "|" + "-" * (len(header) - 2) + "|"
# Rows of data
rows = []
for d in data:
fields = [str(d.get(c, "")).ljust(cell_widths[c]) for c in columns]
row = row_template.format(*fields)
rows.append(row)
return "\n".join([header, sep] + rows)
Here's my solution:
def make_table(columns, data):
"""Create an ASCII table and return it as a string.
Pass a list of strings to use as columns in the table and a list of
dicts. The strings in 'columns' will be used as the keys to the dicts in
'data.'
Not all column values have to be present in each data dict.
>>> print(make_table(["a", "b"], [{"a": "1", "b": "test"}]))
| a | b |
|----------|
| 1 | test |
"""
# Calculate how wide each cell needs to be
cell_widths = {}
for c in columns:
values = [str(d.get(c, "")) for d in data]
cell_widths[c] = len(max(values + [c]))
# Used for formatting rows of data
row_template = "|" + " {} |" * len(columns)
# CONSTRUCT THE TABLE
# The top row with the column titles
justified_column_heads = [c.ljust(cell_widths[c]) for c in columns]
header = row_template.format(*justified_column_heads)
# The second row contains separators
sep = "|" + "-" * (len(header) - 2) + "|"
# Rows of data
rows = []
for d in data:
fields = [str(d.get(c, "")).ljust(cell_widths[c]) for c in columns]
row = row_template.format(*fields)
rows.append(row)
return "\n".join([header, sep] + rows)
def tableit(dictlist):
lengths = [ max(map(lambda x:len(x.get(k)), dictlist) + [len(k)]) for k in dictlist[0].keys() ]
lenstr = " | ".join("{:<%s}" % m for m in lengths)
lenstr += "\n"
outmsg = lenstr.format(*dictlist[0].keys())
outmsg += "-" * (sum(lengths) + 3*len(lengths))
outmsg += "\n"
outmsg += "".join(
lenstr.format(*v) for v in [ item.values() for item in dictlist ]
)
return outmsg
This can be done with only builtin modules fairly compactly using list and string comprehensions. Accepts a list of dictionaries all of the same format...
def tableit(dictlist):
lengths = [ max(map(lambda x:len(x.get(k)), dictlist) + [len(k)]) for k in dictlist[0].keys() ]
lenstr = " | ".join("{:<%s}" % m for m in lengths)
lenstr += "\n"
outmsg = lenstr.format(*dictlist[0].keys())
outmsg += "-" * (sum(lengths) + 3*len(lengths))
outmsg += "\n"
outmsg += "".join(
lenstr.format(*v) for v in [ item.values() for item in dictlist ]
)
return outmsg
发布评论
评论（13）
我很久以前就读过这个问题，并完成了我自己的表格漂亮打印机的编写：
制表。我的用例是：
给定您的示例，网格可能是最重要的类似的输出格式：
其他支持的格式有
plain（无行）、simple（Pandoc 简单表格）、pipe（如 PHP Markdown Extra 中的表格） )、orgtbl（如 Emacs org-mode 中的表格）、rst（如 reStructuredText 中的简单表格）。grid和orgtbl可以在 Emacs 中轻松编辑。在性能方面，
tabulate比asciitable稍慢，但比PrettyTable和texttable快得多。PS 我也非常喜欢按小数对齐数字 列。因此，如果有的话，这是数字的默认对齐方式（可覆盖）。
I've read this question long time ago, and finished writing my own pretty-printer for tables:
tabulate.My use case is:
Given your example,
gridis probably the most similar output format:Other supported formats are
plain(no lines),simple(Pandoc simple tables),pipe(like tables in PHP Markdown Extra),orgtbl(like tables in Emacs' org-mode),rst(like simple tables in reStructuredText).gridandorgtblare easily editable in Emacs.Performance-wise,
tabulateis slightly slower thanasciitable, but much faster thanPrettyTableandtexttable.P.S. I'm also a big fan of aligning numbers by a decimal column. So this is the default alignment for numbers if there are any (overridable).
这是我编写的一个快速但肮脏的小函数，用于显示只能通过 SOAP API 进行的 SQL 查询的结果。它需要输入一系列一个或多个
namedtuples作为表行。如果只有一条记录，则会以不同的方式打印出来。它对我来说很方便，可以作为您的起点：
示例输出：
示例
Here's a quick and dirty little function I wrote for displaying the results from SQL queries I can only make over a SOAP API. It expects an input of a sequence of one or more
namedtuplesas table rows. If there's only one record, it prints it out differently.It is handy for me and could be a starting point for you:
Sample output:
Example
由于某种原因，当我在谷歌搜索中包含“docutils”时，我偶然发现了 texttable，这似乎是我在寻找什么。
For some reason when I included 'docutils' in my google searches I stumbled across texttable, which seems to be what I'm looking for.
我也为此写了自己的解决方案。我试图保持简单。
https://github.com/Robpol86/terminaltables
I too wrote my own solution to this. I tried to keep it simple.
https://github.com/Robpol86/terminaltables
为此，我刚刚发布了 termtables。例如，
默认
情况下，表格使用 Unicode 方框绘制字符 呈现，
术语表非常可配置；查看测试以获取更多示例。
I just released termtables for this purpose. For example, this
gets you
By default, the table is rendered with Unicode box-drawing characters,
termtables are very configurable; check out the tests for more examples.
如果您想要一个具有列和行跨度的表格，请尝试我的库 dashtable
其输出：
If you want a table with column and row spans, then try my library dashtable
Which outputs:
使用 w3m 的版本旨在处理 MattH 版本接受的类型：
结果：
Version using w3m designed to handle the types MattH's version accepts:
results in:
您可以尝试 BeautifulTable。它做你想做的事。这是文档中的一个示例
You can try BeautifulTable. It does what you want to do. Here's an example from it's documentation
示例：
输出：
Example:
Output:
我知道这个问题有点老了，但这是我的尝试：
https://gist.github.com /lonetwin/4721748
恕我直言，它更具可读性（尽管它不像 @MattH 的解决方案那样区分单行/多行，也不使用 NamedTuples）。
I know it the question is a bit old but here's my attempt at this:
https://gist.github.com/lonetwin/4721748
It is a bit more readable IMHO (although it doesn't differentiate between single / multiple rows like @MattH's solutions does, nor does it use NamedTuples).
这是我的解决方案：
Here's my solution:
我使用这个小实用函数。
输出
I use this small utility function.
output
这可以仅使用内置模块相当紧凑地使用列表和字符串理解来完成。接受格式相同的字典列表...
This can be done with only builtin modules fairly compactly using list and string comprehensions. Accepts a list of dictionaries all of the same format...