python-tabulate

在Python中美化打印表格数据，一个库和命令行工具。

该库的主要用例包括

• 轻松打印小表格：只需一个函数调用，格式化由数据本身引导
• 编写轻量级纯文本标记的表格数据：多种输出格式适合进一步编辑或转换
• 混合文本和数值数据的可读性表示：智能列对齐，可配置的数字格式化，按小数点对齐

安装

要安装Python库和命令行工具，运行

pip install tabulate

命令行工具将被安装为Linux上bin中的tabulate（例如/usr/bin）；或在Windows上您的Python安装中的Scripts中的tabulate.exe（例如C:\Python39\Scripts\tabulate.exe）。

您可以考虑只为当前用户安装库

pip install tabulate --user

在这种情况下，命令行工具将被安装到Linux上的~/.local/bin/tabulate和Windows上的%APPDATA%\Python\Scripts\tabulate.exe。

仅要在类Unix操作系统上安装库

TABULATE_INSTALL=lib-only pip install tabulate

在Windows上

set TABULATE_INSTALL=lib-only
pip install tabulate

构建状态

库使用

该模块提供了一个函数tabulate，它将列表或另一个表格数据类型作为第一个参数，并输出一个格式良好的纯文本表格

>>> from tabulate import tabulate

>>> table = [["Sun",696000,1989100000],["Earth",6371,5973.6],
...          ["Moon",1737,73.5],["Mars",3390,641.85]]
>>> print(tabulate(table))
-----  ------  -------------
Sun    696000     1.9891e+09
Earth    6371  5973.6
Moon     1737    73.5
Mars     3390   641.85
-----  ------  -------------

支持以下表格数据类型

• 列表的列表或其他可迭代可迭代的可迭代对象
• 列表或其他字典的可迭代对象（键作为列）
• 可迭代的字典（键作为列）
• 数据类的列表（Python 3.7+仅限，字段名称作为列）
• 二维NumPy数组
• NumPy记录数组（名称作为列）
• pandas.DataFrame

Tabulate 是一个 Python3 库。

表头

名为 headers 的第二个可选参数定义了一个要使用的列表头列表

>>> print(tabulate(table, headers=["Planet","R (km)", "mass (x 10^29 kg)"]))
Planet      R (km)    mass (x 10^29 kg)
--------  --------  -------------------
Sun         696000           1.9891e+09
Earth         6371        5973.6
Moon          1737          73.5
Mars          3390         641.85

如果 headers="firstrow"，则使用数据的第 1 行

>>> print(tabulate([["Name","Age"],["Alice",24],["Bob",19]],
...                headers="firstrow"))
Name      Age
------  -----
Alice      24
Bob        19

如果 headers="keys"，则使用字典/数据帧的键或列索引。它也适用于 NumPy 记录数组和字典或命名元组的列表

>>> print(tabulate({"Name": ["Alice", "Bob"],
...                 "Age": [24, 19]}, headers="keys"))
  Age  Name
-----  ------
   24  Alice
   19  Bob

行索引

默认情况下，只有 pandas.DataFrame 表有额外的名为行索引的列。要将类似的列添加到任何其他类型的表，请将 showindex="always" 或 showindex=True 参数传递给 tabulate()。要抑制所有类型数据的行索引，请传递 showindex="never" 或 showindex=False。要添加自定义行索引列，请传递 showindex=rowIDs，其中 rowIDs 是某个可迭代对象

>>> print(tabulate([["F",24],["M",19]], showindex="always"))
-  -  --
0  F  24
1  M  19
-  -  --

表格格式

在纯文本中格式化表格有多种方法。名为 tablefmt 的第三个可选参数定义了表格的格式

支持的表格格式包括

• "plain"
• "simple"
• "github"
• "grid"
• "simple_grid"
• "rounded_grid"
• "heavy_grid"
• "mixed_grid"
• "double_grid"
• "fancy_grid"
• "outline"
• "simple_outline"
• "rounded_outline"
• "heavy_outline"
• "mixed_outline"
• "double_outline"
• "fancy_outline"
• "pipe"
• "orgtbl"
• "asciidoc"
• "jira"
• "presto"
• "pretty"
• "psql"
• "rst"
• "mediawiki"
• "moinmoin"
• "youtrack"
• "html"
• "unsafehtml"
• "latex"
• "latex_raw"
• "latex_booktabs"
• "latex_longtable"
• "textile"
• "tsv"

plain 表格不使用任何伪图形来绘制线条

>>> table = [["spam",42],["eggs",451],["bacon",0]]
>>> headers = ["item", "qty"]
>>> print(tabulate(table, headers, tablefmt="plain"))
item      qty
spam       42
eggs      451
bacon       0

simple 是默认格式（默认格式可能在未来的版本中更改）。它对应于 Pandoc Markdown 扩展 中的 simple_tables

>>> print(tabulate(table, headers, tablefmt="simple"))
item      qty
------  -----
spam       42
eggs      451
bacon       0

github 遵循 GitHub 风格 Markdown 的约定。它对应于没有对齐冒号的 pipe 格式

>>> print(tabulate(table, headers, tablefmt="github"))
| item   | qty   |
|--------|-------|
| spam   | 42    |
| eggs   | 451   |
| bacon  | 0     |

grid 类似于由 Emacs 的 table.el 包格式化的表格。它对应于 Pandoc Markdown 扩展中的 grid_tables

>>> print(tabulate(table, headers, tablefmt="grid"))
+--------+-------+
| item   |   qty |
+========+=======+
| spam   |    42 |
+--------+-------+
| eggs   |   451 |
+--------+-------+
| bacon  |     0 |
+--------+-------+

simple_grid 使用单行框绘制字符绘制网格

>>> print(tabulate(table, headers, tablefmt="simple_grid"))
┌────────┬───────┐
│ item   │   qty │
├────────┼───────┤
│ spam   │    42 │
├────────┼───────┤
│ eggs   │   451 │
├────────┼───────┤
│ bacon  │     0 │
└────────┴───────┘

rounded_grid 使用带圆角的单行框绘制字符绘制网格

>>> print(tabulate(table, headers, tablefmt="rounded_grid"))
╭────────┬───────╮
│ item   │   qty │
├────────┼───────┤
│ spam   │    42 │
├────────┼───────┤
│ eggs   │   451 │
├────────┼───────┤
│ bacon  │     0 │
╰────────┴───────╯

heavy_grid 使用粗体（粗）单行框绘制字符绘制网格

>>> print(tabulate(table, headers, tablefmt="heavy_grid"))
┏━━━━━━━━┳━━━━━━━┓
┃ item   ┃   qty ┃
┣━━━━━━━━╋━━━━━━━┫
┃ spam   ┃    42 ┃
┣━━━━━━━━╋━━━━━━━┫
┃ eggs   ┃   451 ┃
┣━━━━━━━━╋━━━━━━━┫
┃ bacon  ┃     0 ┃
┗━━━━━━━━┻━━━━━━━┛

mixed_grid 使用光（细）和粗（粗）线条的框绘制字符绘制网格

>>> print(tabulate(table, headers, tablefmt="mixed_grid"))
┍━━━━━━━━┯━━━━━━━┑
│ item   │   qty │
┝━━━━━━━━┿━━━━━━━┥
│ spam   │    42 │
├────────┼───────┤
│ eggs   │   451 │
├────────┼───────┤
│ bacon  │     0 │
┕━━━━━━━━┷━━━━━━━┙

double_grid 使用双线框绘制字符绘制网格

>>> print(tabulate(table, headers, tablefmt="double_grid"))
╔════════╦═══════╗
║ item   ║   qty ║
╠════════╬═══════╣
║ spam   ║    42 ║
╠════════╬═══════╣
║ eggs   ║   451 ║
╠════════╬═══════╣
║ bacon  ║     0 ║
╚════════╩═══════╝

fancy_grid 使用单线和双线框绘制字符的混合绘制网格

>>> print(tabulate(table, headers, tablefmt="fancy_grid"))
╒════════╤═══════╕
│ item   │   qty │
╞════════╪═══════╡
│ spam   │    42 │
├────────┼───────┤
│ eggs   │   451 │
├────────┼───────┤
│ bacon  │     0 │
╘════════╧═══════╛

outline 与 grid 格式相同，但不会在行之间绘制线条

>>> print(tabulate(table, headers, tablefmt="outline"))
+--------+-------+
| item   |   qty |
+========+=======+
| spam   |    42 |
| eggs   |   451 |
| bacon  |     0 |
+--------+-------+

simple_outline 与 simple_grid 格式相同，但不会在行之间绘制线条

>>> print(tabulate(table, headers, tablefmt="simple_outline"))
┌────────┬───────┐
│ item   │   qty │
├────────┼───────┤
│ spam   │    42 │
│ eggs   │   451 │
│ bacon  │     0 │
└────────┴───────┘

rounded_outline 与 rounded_grid 格式相同，但不会在行之间绘制线条

>>> print(tabulate(table, headers, tablefmt="rounded_outline"))
╭────────┬───────╮
│ item   │   qty │
├────────┼───────┤
│ spam   │    42 │
│ eggs   │   451 │
│ bacon  │     0 │
╰────────┴───────╯

heavy_outline 与 heavy_grid 格式相同，但不会在行之间绘制线条

>>> print(tabulate(table, headers, tablefmt="heavy_outline"))
┏━━━━━━━━┳━━━━━━━┓
┃ item   ┃   qty ┃
┣━━━━━━━━╋━━━━━━━┫
┃ spam   ┃    42 ┃
┃ eggs   ┃   451 ┃
┃ bacon  ┃     0 ┃
┗━━━━━━━━┻━━━━━━━┛

mixed_outline 与 mixed_grid 格式相同，但不会在行之间绘制线条

>>> print(tabulate(table, headers, tablefmt="mixed_outline"))
┍━━━━━━━━┯━━━━━━━┑
│ item   │   qty │
┝━━━━━━━━┿━━━━━━━┥
│ spam   │    42 │
│ eggs   │   451 │
│ bacon  │     0 │
┕━━━━━━━━┷━━━━━━━┙

double_outline 与 double_grid 格式相同，但不会在行之间绘制线条

>>> print(tabulate(table, headers, tablefmt="double_outline"))
╔════════╦═══════╗
║ item   ║   qty ║
╠════════╬═══════╣
║ spam   ║    42 ║
║ eggs   ║   451 ║
║ bacon  ║     0 ║
╚════════╩═══════╝

fancy_outline 与 fancy_grid 格式相同，但不会在行之间绘制线条

>>> print(tabulate(table, headers, tablefmt="fancy_outline"))
╒════════╤═══════╕
│ item   │   qty │
╞════════╪═══════╡
│ spam   │    42 │
│ eggs   │   451 │
│ bacon  │     0 │
╘════════╧═══════╛

presto 类似于 Presto 命令行工具格式化的表格

>>> print(tabulate(table, headers, tablefmt="presto"))
 item   |   qty
--------+-------
 spam   |    42
 eggs   |   451
 bacon  |     0

pretty 尝试接近由 PrettyTables 库生成的格式

>>> print(tabulate(table, headers, tablefmt="pretty"))
+-------+-----+
| item  | qty |
+-------+-----+
| spam  | 42  |
| eggs  | 451 |
| bacon |  0  |
+-------+-----+

psql 类似于 Postgres 的 psql 命令行工具格式化的表格

>>> print(tabulate(table, headers, tablefmt="psql"))
+--------+-------+
| item   |   qty |
|--------+-------|
| spam   |    42 |
| eggs   |   451 |
| bacon  |     0 |
+--------+-------+

pipe 遵循 PHP Markdown Extra 扩展的约定。它对应于 Pandoc 中的 pipe_tables。此格式使用冒号来指示列对齐

>>> print(tabulate(table, headers, tablefmt="pipe"))
| item   |   qty |
|:-------|------:|
| spam   |    42 |
| eggs   |   451 |
| bacon  |     0 |

asciidoc 以类似于 AsciiDoctor 格式的简单表格格式化数据

>>> print(tabulate(table, headers, tablefmt="asciidoc"))
[cols="8<,7>",options="header"]
|====
| item   |   qty
| spam   |    42
| eggs   |   451
| bacon  |     0
|====

orgtbl 遵循 Emacs org-mode 的规范，也可以在辅助的 orgtbl-mode 中进行编辑。因此得名。

>>> print(tabulate(table, headers, tablefmt="orgtbl"))
| item   |   qty |
|--------+-------|
| spam   |    42 |
| eggs   |   451 |
| bacon  |     0 |

jira 遵循 Atlassian Jira 标记语言规范。

>>> print(tabulate(table, headers, tablefmt="jira"))
|| item   ||   qty ||
| spam   |    42 |
| eggs   |   451 |
| bacon  |     0 |

rst 格式化数据类似于 reStructuredText 格式的简单表格。

>>> print(tabulate(table, headers, tablefmt="rst"))
======  =====
item      qty
======  =====
spam       42
eggs      451
bacon       0
======  =====

mediawiki 格式生成用于 Wikipedia 和其他基于 MediaWiki 的网站上的表格标记。

>>> print(tabulate(table, headers, tablefmt="mediawiki"))
{| class="wikitable" style="text-align: left;"
|+ <!-- caption -->
|-
! item   !! align="right"|   qty
|-
| spam   || align="right"|    42
|-
| eggs   || align="right"|   451
|-
| bacon  || align="right"|     0
|}

moinmoin 格式生成用于 MoinMoin 维基的表格标记。

>>> print(tabulate(table, headers, tablefmt="moinmoin"))
|| ''' item   ''' || ''' quantity   ''' ||
||  spam    ||  41.999      ||
||  eggs    ||  451         ||
||  bacon   ||              ||

youtrack 格式生成用于 Youtrack 工单的表格标记。

>>> print(tabulate(table, headers, tablefmt="youtrack"))
||  item    ||  quantity   ||
|   spam    |  41.999      |
|   eggs    |  451         |
|   bacon   |              |

textile 格式生成用于 Textile 格式的表格标记。

>>> print(tabulate(table, headers, tablefmt="textile"))
|_.  item   |_.   qty |
|<. spam    |>.    42 |
|<. eggs    |>.   451 |
|<. bacon   |>.     0 |

html 生成标准的 HTML 标记，作为经过 html.escape 的字符串，具有 .repr_html 方法，以便 Jupyter Lab 和 Notebook 显示 HTML，并具有 .str 属性，以便原始 HTML 保持可访问性。如果需要未转义的 HTML，可以使用 unsafehtml 表格格式。

>>> print(tabulate(table, headers, tablefmt="html"))
<table>
<tbody>
<tr><th>item  </th><th style="text-align: right;">  qty</th></tr>
<tr><td>spam  </td><td style="text-align: right;">   42</td></tr>
<tr><td>eggs  </td><td style="text-align: right;">  451</td></tr>
<tr><td>bacon </td><td style="text-align: right;">    0</td></tr>
</tbody>
</table>

latex 格式创建 LaTeX 标记的 tabular 环境，将特殊字符如 _ 或 \ 替换为其 LaTeX 对应项。

>>> print(tabulate(table, headers, tablefmt="latex"))
\begin{tabular}{lr}
\hline
 item   &   qty \\
\hline
 spam   &    42 \\
 eggs   &   451 \\
 bacon  &     0 \\
\hline
\end{tabular}

latex_raw 的行为类似于 latex，但不会转义 LaTeX 命令和特殊字符。

latex_booktabs 使用来自 booktabs 包的间距和样式创建 LaTeX 标记的 tabular 环境。

latex_longtable 使用 longtable 包创建可以跨越多页的表格。

列对齐

tabulate 在列对齐方面很智能。它会检测只包含数字的列，并按小数点对齐（如果它们看起来像是整数，则将其向右填充）。文本列向左填充。

您可以使用 numalign 和 stralign 命名参数覆盖默认对齐方式。可能的列对齐方式有：right、center、left、decimal（仅适用于数字）和 None（禁用对齐）。

按小数点对齐在您需要直观比较数字时效果最佳。

>>> print(tabulate([[1.2345],[123.45],[12.345],[12345],[1234.5]]))
----------
    1.2345
  123.45
   12.345
12345
 1234.5
----------

将其与更常见的右对齐进行比较。

>>> print(tabulate([[1.2345],[123.45],[12.345],[12345],[1234.5]], numalign="right"))
------
1.2345
123.45
12.345
 12345
1234.5
------

对于 tabulate，任何可以解析为数字的内容都是数字。即使以字符串表示的数字也会正确对齐。当从文件中读取包含文本和数字的混合表格时，此功能非常有用。

>>> import csv ; from StringIO import StringIO
>>> table = list(csv.reader(StringIO("spam, 42\neggs, 451\n")))
>>> table
[['spam', ' 42'], ['eggs', ' 451']]
>>> print(tabulate(table))
----  ----
spam    42
eggs   451
----  ----

要禁用此功能，请使用 disable_numparse=True。

>>> print(tabulate.tabulate([["Ver1", "18.0"], ["Ver2","19.2"]], tablefmt="simple", disable_numparse=True))
----  ----
Ver1  18.0
Ver2  19.2
----  ----

自定义列对齐

tabulate 允许自定义列对齐以覆盖上述对齐。colalign 参数可以是 stralign 命名参数的列表或元组。可能的列对齐方式有：right、center、left、decimal（仅适用于数字）和 None（禁用对齐）。省略对齐方式将使用默认对齐方式。例如

>>> print(tabulate([["one", "two"], ["three", "four"]], colalign=("right",))
-----  ----
  one  two
three  four
-----  ----

数字格式化

tabulate 允许定义应用于十进制数字所有列的自定义数字格式。使用 floatfmt 命名参数。

>>> print(tabulate([["pi",3.141593],["e",2.718282]], floatfmt=".4f"))
--  ------
pi  3.1416
e   2.7183
--  ------

floatfmt 参数可以是格式字符串的列表或元组，每个列一个，在这种情况下，每个列可以有不同的数字格式。

>>> print(tabulate([[0.12345, 0.12345, 0.12345]], floatfmt=(".1f", ".3f")))
---  -----  -------
0.1  0.123  0.12345
---  -----  -------

intfmt 对整数的工作方式类似。

>>> print(tabulate([["a",1000],["b",90000]], intfmt=","))
-  ------
a   1,000
b  90,000
-  ------

文本格式化

默认情况下，tabulate 会从文本列中删除前导和尾随空格。要禁用空格删除，请设置全局模块级标志 PRESERVE_WHITESPACE。

import tabulate
tabulate.PRESERVE_WHITESPACE = True

宽字符（全宽 CJK）符号

为了正确对齐包含宽字符（通常是从中文、日文或韩文语言的全宽符号）的表格，用户应安装 wcwidth 库。要与其一起安装 tabulate

pip install tabulate[widechars]

如果已经安装了 wcwidth 库，则自动启用宽字符支持。要禁用宽字符支持而不卸载 wcwidth，请设置全局模块级标志 WIDE_CHARS_MODE

import tabulate
tabulate.WIDE_CHARS_MODE = False

多行单元格

大多数表格格式支持多行单元格文本（包含换行符的文本）。换行符被视为换行符。

支持数据行和标题行的多行单元格。

不会插入进一步的自动换行。当然，某些输出格式（如 LaTeX 或 HTML）可以自行处理单元格内容的自动格式化，但对于那些不能处理的格式，输入单元格文本中的换行符是单元格文本中换行的唯一方法。

请注意，某些输出格式（例如简单或纯文本）不表示行分隔符，因此此类格式中多行单元格的表示可能对读者来说是模糊的。

以下格式化输出示例使用以下带有多行单元格的表格，以及带有多行单元格的标题

>>> table = [["eggs",451],["more\nspam",42]]
>>> headers = ["item\nname", "qty"]

plain 表格

>>> print(tabulate(table, headers, tablefmt="plain"))
item      qty
name
eggs      451
more       42
spam

simple 表格

>>> print(tabulate(table, headers, tablefmt="simple"))
item      qty
name
------  -----
eggs      451
more       42
spam

grid 表格

>>> print(tabulate(table, headers, tablefmt="grid"))
+--------+-------+
| item   |   qty |
| name   |       |
+========+=======+
| eggs   |   451 |
+--------+-------+
| more   |    42 |
| spam   |       |
+--------+-------+

fancy_grid 表格

>>> print(tabulate(table, headers, tablefmt="fancy_grid"))
╒════════╤═══════╕
│ item   │   qty │
│ name   │       │
╞════════╪═══════╡
│ eggs   │   451 │
├────────┼───────┤
│ more   │    42 │
│ spam   │       │
╘════════╧═══════╛

pipe 表格

>>> print(tabulate(table, headers, tablefmt="pipe"))
| item   |   qty |
| name   |       |
|:-------|------:|
| eggs   |   451 |
| more   |    42 |
| spam   |       |

orgtbl 表格

>>> print(tabulate(table, headers, tablefmt="orgtbl"))
| item   |   qty |
| name   |       |
|--------+-------|
| eggs   |   451 |
| more   |    42 |
| spam   |       |

jira 表格

>>> print(tabulate(table, headers, tablefmt="jira"))
| item   |   qty |
| name   |       |
|:-------|------:|
| eggs   |   451 |
| more   |    42 |
| spam   |       |

presto 表格

>>> print(tabulate(table, headers, tablefmt="presto"))
 item   |   qty
 name   |
--------+-------
 eggs   |   451
 more   |    42
 spam   |

pretty 表格

>>> print(tabulate(table, headers, tablefmt="pretty"))
+------+-----+
| item | qty |
| name |     |
+------+-----+
| eggs | 451 |
| more | 42  |
| spam |     |
+------+-----+

psql 表格

>>> print(tabulate(table, headers, tablefmt="psql"))
+--------+-------+
| item   |   qty |
| name   |       |
|--------+-------|
| eggs   |   451 |
| more   |    42 |
| spam   |       |
+--------+-------+

rst 表格

>>> print(tabulate(table, headers, tablefmt="rst"))
======  =====
item      qty
name
======  =====
eggs      451
more       42
spam
======  =====

其他表格格式不支持多行单元格。

自动多行

虽然 tabulate 支持显式提供多行条目的数据，但它还提供了一些帮助内部管理此工作的支持。

maxcolwidths 参数是一个列表，其中每个条目指定其相应列的最大宽度。任何超出此宽度的单元格将自动换行。要为所有列分配相同的最大宽度，可以使用单个整型比例尺。

对于不需要提供显式最大值的任何列，请使用 None，因此不会进行自动多行换行。

换行使用 Python 标准库中的 textwrap.wrap 函数，除了宽度以外的默认参数。

此示例演示了自动多行换行的用法，尽管通常被换行的行可能会长得多。

>>> print(tabulate([["John Smith", "Middle Manager"]], headers=["Name", "Title"], tablefmt="grid", maxcolwidths=[None, 8]))
+------------+---------+
| Name       | Title   |
+============+=========+
| John Smith | Middle  |
|            | Manager |
+------------+---------+

添加分隔线

可能希望添加一个或多个分隔线以突出表格中的不同部分。

分隔线将与指定格式器定义的同一类型的线相同，作为 linebetweenrows、linebelowheader、linebelow、lineabove 或未为格式器定义时为简单空行。

>>> from tabulate import tabulate, SEPARATING_LINE

table = [["Earth",6371],
         ["Mars",3390],
         SEPARATING_LINE,
         ["Moon",1737]]
print(tabulate(table, tablefmt="simple"))
-----  ----
Earth  6371
Mars   3390
-----  ----
Moon   1737
-----  ----

ANSI 支持

ANSI 转义码是非打印的字节序列，通常用于终端操作，如设置颜色输出或修改光标位置。由于多字节 ANSI 序列本质上是非打印的，它们仍然可能向字符串中引入不需要的额外长度。例如

>>> len('\033[31mthis text is red\033[0m')  # printable length is 16
25

为了处理这种情况，首先删除所有 ANSI 转义序列后计算字符串长度。这确保了实际可打印长度用于列宽度，而不是字节长度。然而，在最终的、可打印的表格中，ANSI 转义序列不会被删除，以保留原始样式。

某些终端支持一种特殊的 ANSI 转义序列分组，旨在以类似于浏览器中显示的方式显示超链接。这些处理方式与之前所述相同：在计算字符串长度之前删除非打印的 ANSI 转义序列。唯一的区别是，列宽度将基于 URL 文本 的长度，而不是 URL 本身（终端将显示此文本）。例如

>>> len('\x1b]8;;https://example.com\x1b\\example\x1b]8;;\x1b\\')  # display length is 7, showing 'example'
45

命令行工具的使用

Usage: tabulate [options] [FILE ...]

FILE                      a filename of the file with tabular data;
                          if "-" or missing, read data from stdin.

Options:

-h, --help                show this message
-1, --header              use the first row of data as a table header
-o FILE, --output FILE    print table to FILE (default: stdout)
-s REGEXP, --sep REGEXP   use a custom column separator (default: whitespace)
-F FPFMT, --float FPFMT   floating point number format (default: g)
-I INTFMT, --int INTFMT   integer point number format (default: "")
-f FMT, --format FMT      set output table format; supported formats:
                          plain, simple, github, grid, fancy_grid, pipe,
                          orgtbl, rst, mediawiki, html, latex, latex_raw,
                          latex_booktabs, latex_longtable, tsv
                          (default: simple)

性能考虑

如小数点对齐和尝试解析所有内容为数字等特性暗示了 tabulate

• 必须“猜测”如何打印特定的表格数据类型
• 需要将整个表格保留在内存中
• 必须“转置”表格两次
• 它的工作量可能比看起来要多得多

可能不适合序列化非常大的表格（但谁会这么做呢？）或在性能敏感的应用中打印表格。“tabulate”的速度比简单地用制表符、逗号或其他分隔符连接值慢两个数量级。

同时，“tabulate”与其他表格美化和打印工具相当。对于包含混合文本和数字数据的10x10表格（列表的列表），“tabulate”似乎比“asciitable”慢，比“PrettyTable”和“texttable”快。以下微型基准测试是在Python 3.9.13和Windows 10上运行的

=================================  ==========  ===========
Table formatter                      time, μs    rel. time
=================================  ==========  ===========
csv to StringIO                          12.5          1.0
join with tabs and newlines              14.6          1.2
asciitable (0.8.0)                      192.0         15.4
tabulate (0.9.0)                        483.5         38.7
tabulate (0.9.0, WIDE_CHARS_MODE)       637.6         51.1
PrettyTable (3.4.1)                    1080.6         86.6
texttable (1.6.4)                      1390.3        111.4
=================================  ==========  ===========

版本历史

完整的版本历史可以在变更日志中找到。

如何贡献

贡献应包括测试和他们提出的更改的解释。文档（示例、docstrings、README.md）应相应更新。

此项目使用pytest测试框架和tox来自动化不同环境中的测试。将测试添加到test/文件夹中的某个文件。

要测试所有支持的Python版本，请确保已安装所有Python解释器、pytest和tox，然后在项目源代码树的根目录中运行tox。

在Linux上，tox期望找到类似python3.7、python3.8等可执行文件。在Windows上，它分别查找C:\Python37\python.exe、C:\Python38\python.exe等。

安装所有所需的Python解释器版本的一种方法是通过使用pyenv。然后可以轻松地安装所有版本，如下所示

 pyenv install 3.7.12
 pyenv install 3.8.12
 ...

别忘了更改你的PATH，以便tox知道如何找到所有已安装的版本。例如

 export PATH="${PATH}:${HOME}/.pyenv/shims"

要测试某些Python环境，请使用-e选项。例如，要仅针对Python 3.7和Python 3.10进行测试，请在项目源代码树的根目录中运行

tox -e py37,py310

要启用NumPy和Pandas测试，运行

tox -e py37-extra,py310-extra

（这可能是第一次运行需要很长时间，因为NumPy和Pandas将需要在新的虚拟环境中安装）

修复代码格式

tox -e lint

查看tox.ini文件以了解如何使用它来测试单个Python版本。

贡献者

Sergey Astanin、Pau Tallada Crespí、Erwin Marsi、Mik Kocikowski、Bill Ryder、Zach Dwiel、Frederik Rietdijk、Philipp Bogensberger、Greg (匿名)、Stefan Tatschner、Emiel van Miltenburg、Brandon Bennett、Amjith Ramanujam、Jan Schulz、Simon Percivall、Javier Santacruz López-Cepero、Sam Denton、Alexey Ziyangirov、acaird、Cesar Sanchez、naught101、John Vandenberg、Zack Dever、Christian Clauss、Benjamin Maier、Andy MacKinlay、Thomas Roten、Jue Wang、Joe King、Samuel Phan、Nick Satterly、Daniel Robbins、Dmitry B、Lars Butler、Andreas Maier、Dick Marinus、Sébastien Celles、Yago González、Andrew Gaul、Wim Glenn、Jean Michel Rouly、Tim Gates、John Vandenberg、Sorin Sbarnea、Wes Turner、Andrew Tija、Marco Gorelli、Sean McGinnis、danja100、endolith、Dominic Davis-Foster、pavlocat、Daniel Aslau、paulc、Felix Yan、Shane Loretz、Frank Busse、Harsh Singh、Derek Weitzel、Vladimir Vrzić、서승우 (chrd5273)、Georgy Frolov、Christian Cwienk、Bart Broere、Vilhelm Prytz、Alexander Gažo、Hugo van Kemenade、jamescooke、Matt Warner、Jérôme Provensal、Kevin Deldycke、Kian-Meng Ang、Kevin Patterson、Shodhan Save、cleoold、KOLANICH、Vijaya Krishna Kasula、Furcy Pin、Christian Fibich、Shaun Duncan、Dimitri Papadopoulos。