将列表打印为表格数据

时间：2012-03-02 15:32:55

标签： python

我对Python很陌生，现在我正在努力为打印输出很好地格式化我的数据。

我有一个用于两个标题的列表，以及一个应该是表格内容的矩阵。像这样：

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

请注意，标题名称的长度不一定相同。但是，数据条目都是整数。

现在，我希望以表格格式表示这一点，如下所示：

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

我有预感，必须有一个数据结构，但我找不到它。我曾尝试使用字典并格式化打印，我尝试使用缩进的for循环，并尝试打印为字符串。

我确信必须有一个非常简单的方法来做到这一点，但由于缺乏经验，我可能会错过它。

17 个答案:

答案 0 :(得分：405)

为此目的，有一些轻巧而有用的python包：

<强> 1。制表：https://pypi.python.org/pypi/tabulate 

>>> from tabulate import tabulate
>>> print tabulate([['Alice', 24], ['Bob', 19]], headers=['Name', 'Age'])
Name      Age
------  -----
Alice      24
Bob        19

tabulate有许多选项来指定标题和表格格式。

>>> print tabulate([['Alice', 24], ['Bob', 19]], headers=['Name', 'Age'], tablefmt='orgtbl')
| Name   |   Age |
|--------+-------|
| Alice  |    24 |
| Bob    |    19 |

<强> 2。 PrettyTable ：https://pypi.python.org/pypi/PrettyTable 

>>> from prettytable import PrettyTable
>>> t = PrettyTable(['Name', 'Age'])
>>> t.add_row(['Alice', 24])
>>> t.add_row(['Bob', 19])
>>> print t
+-------+-----+
|  Name | Age |
+-------+-----+
| Alice |  24 |
|  Bob  |  19 |
+-------+-----+

PrettyTable有从csv，html，sql数据库读取数据的选项。您还可以选择数据子集，排序表和更改表格样式。

第3。 texttable ：https://pypi.python.org/pypi/texttable 

>>> from texttable import Texttable
>>> t = Texttable()
>>> t.add_rows([['Name', 'Age'], ['Alice', 24], ['Bob', 19]])
>>> print t.draw()
+-------+-----+
| Name  | Age |
+=======+=====+
| Alice | 24  |
+-------+-----+
| Bob   | 19  |
+-------+-----+

使用texttable可以控制水平/垂直对齐，边框样式和数据类型。

其他选择：

  • terminaltables从字符串列表列表中轻松绘制终端/控制台应用程序中的表。支持多行行。
  • asciitable Asciitable可以通过内置的扩展阅读器类读写各种ASCII表格格式。

答案 1 :(得分：156)

Python 2.7的一些特殊代码：

row_format ="{:>15}" * (len(teams_list) + 1)
print row_format.format("", *teams_list)
for team, row in zip(teams_list, data):
    print row_format.format(team, *row)

这取决于str.format()和Format Specification Mini-Language。

答案 2 :(得分：62)

>>> import pandas
>>> pandas.DataFrame(data, teams_list, teams_list)
           Man Utd  Man City  T Hotspur
Man Utd    1        2         1        
Man City   0        1         0        
T Hotspur  2        4         2

答案 3 :(得分：48)

Python实际上让这很容易。

像

这样的东西 
for i in range(10):
    print '%-12i%-12i' % (10 ** i, 20 ** i)

将具有输出

1           1           
10          20          
100         400         
1000        8000        
10000       160000      
100000      3200000     
1000000     64000000    
10000000    1280000000  
100000000   25600000000
1000000000  512000000000

字符串中的％本质上是一个转义字符，后面的字符告诉python数据应该具有什么样的格式。字符串外部和后面的％告诉python您打算使用前一个字符串作为格式字符串，并且应将以下数据放入指定的格式。

在这种情况下，我使用了“％-12i”两次。分解每个部分：

'-' (left align)
'12' (how much space to be given to this part of the output)
'i' (we are printing an integer)

来自文档：https://docs.python.org/2/library/stdtypes.html#string-formatting

答案 4 :(得分：19)

更新Sven Marnach在Python 3.4中的工作答案：

row_format ="{:>15}" * (len(teams_list) + 1)
print(row_format.format("", *teams_list))
for team, row in zip(teams_list, data):
    print(row_format.format(team, *row))

答案 5 :(得分：9)

当我这样做时，我喜欢控制表的格式化细节。特别是，我希望标题单元格具有与正文单元格不同的格式，并且表格列宽度只能与每个单元格所需的格式一样宽。这是我的解决方案：

def format_matrix(header, matrix,
                  top_format, left_format, cell_format, row_delim, col_delim):
    table = [[''] + header] + [[name] + row for name, row in zip(header, matrix)]
    table_format = [['{:^{}}'] + len(header) * [top_format]] \
                 + len(matrix) * [[left_format] + len(header) * [cell_format]]
    col_widths = [max(
                      len(format.format(cell, 0))
                      for format, cell in zip(col_format, col))
                  for col_format, col in zip(zip(*table_format), zip(*table))]
    return row_delim.join(
               col_delim.join(
                   format.format(cell, width)
                   for format, cell, width in zip(row_format, row, col_widths))
               for row_format, row in zip(table_format, table))

print format_matrix(['Man Utd', 'Man City', 'T Hotspur', 'Really Long Column'],
                    [[1, 2, 1, -1], [0, 1, 0, 5], [2, 4, 2, 2], [0, 1, 0, 6]],
                    '{:^{}}', '{:<{}}', '{:>{}.3f}', '\n', ' | ')

这是输出：

                   | Man Utd | Man City | T Hotspur | Really Long Column
Man Utd            |   1.000 |    2.000 |     1.000 |             -1.000
Man City           |   0.000 |    1.000 |     0.000 |              5.000
T Hotspur          |   2.000 |    4.000 |     2.000 |              2.000
Really Long Column |   0.000 |    1.000 |     0.000 |              6.000

答案 6 :(得分：8)

我认为this正是您所寻找的。

这是一个简单的模块，它只计算表条目所需的最大宽度，然后只使用rjust和ljust来完成数据的打印。

如果您希望左侧标题右对齐，只需更改此调用：

 print >> out, row[0].ljust(col_paddings[0] + 1),

从第53行开始：

 print >> out, row[0].rjust(col_paddings[0] + 1),

答案 7 :(得分：5)

Pure Python 3 

def print_table(data, cols, wide):
    '''Prints formatted data on columns of given width.'''
    n, r = divmod(len(data), cols)
    pat = '{{:{}}}'.format(wide)
    line = '\n'.join(pat * cols for _ in range(n))
    last_line = pat * r
    print(line.format(*data))
    print(last_line.format(*data[n*cols:]))

data = [str(i) for i in range(27)]
print_table(data, 6, 12)

将打印

0           1           2           3           4           5           
6           7           8           9           10          11          
12          13          14          15          16          17          
18          19          20          21          22          23          
24          25          26

答案 8 :(得分：5)

就用它

from beautifultable import BeautifulTable

table = BeautifulTable()
table.column_headers = ["", "Man Utd","Man City","T Hotspur"]
table.append_row(['Man Utd',  1,  2,  3])
table.append_row(['Man City', 7, 4,  1])
table.append_row(['T Hotspur', 3, 2,  2])
print(table)

因此，您将得到一张如此整洁的桌子，仅此而已。 enter image description here

答案 9 :(得分：2)

我会尝试遍历列表并使用CSV格式化程序来表示您想要的数据。

您可以指定制表符，逗号或任何其他字符作为分隔符。

否则，只需遍历列表并在每个元素后面打印“\ t”

http://docs.python.org/library/csv.html

答案 10 :(得分：2)

一种简单的方法是遍历所有列，测量它们的宽度，为该最大宽度创建一个row_template，然后打印行。 这不是您要查找的内容，因为在这种情况下，您首先必须将标题放在表中，但我认为这可能对某人有用其他。

table = [
    ["", "Man Utd", "Man City", "T Hotspur"],
    ["Man Utd", 1, 0, 0],
    ["Man City", 1, 1, 0],
    ["T Hotspur", 0, 1, 2],
]
def print_table(table):
    longest_cols = [
        (max([len(str(row[i])) for row in table]) + 3)
        for i in range(len(table[0]))
    ]
    row_format = "".join(["{:>" + str(longest_col) + "}" for longest_col in longest_cols])
    for row in table:
        print(row_format.format(*row))

您可以这样使用它：

>>> print_table(table)

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

答案 11 :(得分：2)

以下函数将使用Python 3（也可能是Python 2）创建请求的表（带或不带numpy）。我选择设置每列的宽度以匹配最长的团队名称的宽度。如果您想为每列使用团队名称的长度，则可以对其进行修改，但是会更加复杂。

注意：对于Python 2中的直接等效项，可以从itertools中将zip替换为izip。

def print_results_table(data, teams_list):
    str_l = max(len(t) for t in teams_list)
    print(" ".join(['{:>{length}s}'.format(t, length = str_l) for t in [" "] + teams_list]))
    for t, row in zip(teams_list, data):
        print(" ".join(['{:>{length}s}'.format(str(x), length = str_l) for x in [t] + row]))

teams_list = ["Man Utd", "Man City", "T Hotspur"]
data = [[1, 2, 1],
        [0, 1, 0],
        [2, 4, 2]]

print_results_table(data, teams_list)

这将产生下表：

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

如果要使用竖线分隔符，可以将" ".join替换为" | ".join。

参考文献：

答案 12 :(得分：1)

我发现这只是在寻找一种输出简单列的方法。 如果您只需要简单的列，则可以使用以下方法：

print("Titlex\tTitley\tTitlez")
for x, y, z in data:
    print(x, "\t", y, "\t", z)

编辑：我试图尽可能简单，从而手动执行某些操作，而不使用团队列表。概括一下OP的实际问题：

#Column headers
print("", end="\t")
for team in teams_list:
    print(" ", team, end="")
print()
# rows
for team, row in enumerate(data):
    teamlabel = teams_list[team]
    while len(teamlabel) < 9:
        teamlabel = " " + teamlabel
    print(teamlabel, end="\t")
    for entry in row:
        print(entry, end="\t")
    print()

胜利：

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

但是，这似乎不再比其他答案更简单，也许好处是它不需要更多的导入。但是@campkeith的答案已经满足了这一要求，并且更加健壮，因为它可以处理更广泛的标签长度​​。

答案 13 :(得分：1)

对于简单的情况，您可以使用现代字符串格式 (simplified Sven's answer)：
f'{column1_value:15} {column2_value}'：

table = {
    'Amplitude': [round(amplitude, 3), 'm³/h'],
    'MAE': [round(mae, 2), 'm³/h'],
    'MAPE': [round(mape, 2), '%'],
}

for metric, value in table.items():
    print(f'{metric:14} : {value[0]:>6.3f} {value[1]}')

输出：

Amplitude      :  1.438 m³/h
MAE            :  0.171 m³/h
MAPE           : 27.740 %

来源：https://docs.python.org/3/tutorial/inputoutput.html#formatted-string-literals

答案 14 :(得分：0)

我知道我参加晚会很晚，但是我为此建立了一个图书馆，我认为这真的可以帮上忙。这非常简单，这就是为什么我认为您应该使用它。它称为 TableIT 。

基本使用

要使用它，请先按照GitHub Page上的下载说明进行操作。

然后将其导入：

import TableIt

然后创建一个列表列表，其中每个内部列表都是一行：

table = [
    [4, 3, "Hi"],
    [2, 1, 808890312093],
    [5, "Hi", "Bye"]
]

然后您要做的就是打印它：

TableIt.printTable(table)

这是您得到的输出：

+--------------------------------------------+
| 4            | 3            | Hi           |
| 2            | 1            | 808890312093 |
| 5            | Hi           | Bye          |
+--------------------------------------------+

字段名称

如果需要，您可以使用字段名称（如果您不使用字段名称，则不必说useFieldNames = False，因为默认情况下已将其设置为）： 


TableIt.printTable(table, useFieldNames=True)

从中您将得到：

+--------------------------------------------+
| 4            | 3            | Hi           |
+--------------+--------------+--------------+
| 2            | 1            | 808890312093 |
| 5            | Hi           | Bye          |
+--------------------------------------------+

还有其他用途，例如，您可以这样做：

import TableIt

myList = [
    ["Name", "Email"],
    ["Richard", "richard@fakeemail.com"],
    ["Tasha", "tash@fakeemail.com"]
]

TableIt.print(myList, useFieldNames=True)

从那开始：

+-----------------------------------------------+
| Name                  | Email                 |
+-----------------------+-----------------------+
| Richard               | richard@fakeemail.com |
| Tasha                 | tash@fakeemail.com    |
+-----------------------------------------------+

或者您可以这样做：

import TableIt

myList = [
    ["", "a", "b"],
    ["x", "a + x", "a + b"],
    ["z", "a + z", "z + b"]
]

TableIt.printTable(myList, useFieldNames=True)

然后您将得到：

+-----------------------+
|       | a     | b     |
+-------+-------+-------+
| x     | a + x | a + b |
| z     | a + z | z + b |
+-----------------------+

颜色

您还可以使用颜色。

您可以通过使用颜色选项（默认情况下，设置为无）并指定RGB值来使用颜色。

使用上面的示例：

import TableIt

myList = [
    ["", "a", "b"],
    ["x", "a + x", "a + b"],
    ["z", "a + z", "z + b"]
]

TableIt.printTable(myList, useFieldNames=True, color=(26, 156, 171))

那么您将得到：

enter image description here

请注意，打印颜色可能对您不起作用，但它的工作原理与打印彩色文本的其他库完全相同。我已经测试过，每种颜色都能正常工作。如果使用默认的34m ANSI转义序列，蓝色也不会弄乱（如果您不知道那是什么也没关系）。无论如何，这全都来自于每种颜色都是RGB值而不是系统默认值的事实。

更多信息

有关更多信息，请检查GitHub Page

答案 15 :(得分：0)

使用terminaltables

创建一个简单表

打开终端或命令提示符，然后运行pip install terminaltables 您可以按以下方式打印和python列表

from terminaltables import AsciiTable

l = [
  ['Head', 'Head'],
  ['R1 C1', 'R1 C2'],
  ['R2 C1', 'R2 C2'],
  ['R3 C1', 'R3 C2']
]

table = AsciiTable(l)

print(table.table)

他们还有其他很棒的桌子，别忘了签出。只是谷歌他们的图书馆。

希望对您有帮助：100：！

答案 16 :(得分：0)

我有一个更好的，可以节省很多空间。

table = [
    ['number1', 'x', 'name'],
    ["4x", "3", "Hi"],
    ["2", "1", "808890312093"],
    ["5", "Hi", "Bye"]
]
column_max_width = [max(len(row[column_index]) for row in table) for column_index in range(len(table[0]))]
row_format = ["{:>"+str(width)+"}" for width in column_max_width]
for row in table:
    print("|".join([print_format.format(value) for print_format, value in zip(row_format, row)]))

输出：

number1| x|        name
     4x| 3|          Hi
      2| 1|808890312093
      5|Hi|         Bye
相关问题
最新问题