如何仅使用内置函数从 python 中的列表列表中生成格式良好的表

Question

I have a list of lists like:

a = [[1, 10, 0.1], [2, 10, 0.2], [3, 11, 0.25]]

For each list (a list of 3 fields), I want to separate the fields into separate variables and print with appropriate formatting, with column names, dollar signs, clean spacing, nicely lined up, etc. for example:

I tried using zip() but what was printed out won't work if I want to sort the price or amount. I'd be very grateful if anyone could help me with my question only using the built-in functions in Python.

Answer 1

There are lots of formatted output options in Python. Just pick one.

a = [[1, 10, 0.1], [2, 10, 0.2], [3, 11, 0.25]]

print( " ID  Amount  Rate")
for row in a:
    print( f"{row[0]:3d}   ${row[1]:3d}   {row[2]:4.2f}" )
for row in a:
    print( "{:3d}   ${:3d}   {:4.2f}".format(*row) )

Output:

 ID  Amount  Rate
  1   $ 10   0.10
  2   $ 10   0.20
  3   $ 11   0.25
  1   $ 10   0.10
  2   $ 10   0.20
  3   $ 11   0.25

Answer 2

not a built-in function but have you tried using pandas? takes care of allot of of that for you try:

normal_list = [[1, 10, 0.1], [2, 10, 0.2], [3, 11, 0.25]]

prettier_dataframe = pandas.DataFrame([[1, 10, 0.1], [2, 10, 0.2], [3, 11, 0.25]], columns = ["col1", "col2", "col3"], index = ["row1", "row2", "row3"])

print(prettier_dataframe)

Answer 3

If you want to outsource the formatting to have a clean usage like this or similar

for data in your_seq:
    print(data)

then you can consider using a class and design the output there. The advantage is a separation of formatting the data and the data itself. Here is one example with equal distributed length for each column using dataclass:

from dataclasses import dataclass


@dataclass
class Data:
    ID: int
    Amount: int
    Rate: float

    @property
    def column_length(self):
        return self.get_longest_column_length()

    @classmethod
    def get_longest_column_length(cls):
        return len(max(*vars(cls)["__annotations__"], key=len)) + 1

    @classmethod
    def print_headline(cls):
        length = cls.get_longest_column_length()
        for var in vars(cls)["__annotations__"].keys():
            print(f"{var:<{length}}", sep="", end="")
        print()

    def __repr__(self):
        return (
            f"{self.ID:<{self.column_length}}"
            f"$ {self.Amount:<{self.column_length - 2}}"
            f"{self.Rate:<{self.column_length}}"
        )

For the usage, you can directly create Data instances or transform the items of an existing list to Data instances like this:

a = [[1, 10, 0.1], [2, 10, 0.2], [3, 11, 0.25]]
data = map(lambda el: Data(*el), a)

Then you can do what I mentioned for the first code snippet:

Data.print_headline()
for date in data:
    print(date)

There is probably much space for optimization, here. And the low-level detail how to probably format your code is only moved away to the __repr__ method. So regarding this, there is not really something new in comparison to other answers. But you also mentioned

appropriate formatting, with column names, dollar signs, clean spacing, nicely lined up, etc.

, so I had the feeling that using a class could be helpful as a potential starting point for more sophisticated formatting problems and trying to go a bit into the direction of separation of concerns (formatting vs. data).

The output for your provided data is:

ID     Amount Rate   
1      $ 10   0.1    
2      $ 10   0.2    
3      $ 11   0.25   

Answer 4

okay, built-in functions only

a = [[1, 10, 0.1], [2, 10, 0.2], [3, 11, 0.25]]
col_names = ["col1", "col2", "col3"]
row_names = ["row1", "row2", "row3"]

print("       ", *(col +"   " for col in col_names))
for row in range(len(row_names)):
    row_data = (str(a[row][n])+"   "+(" "*(len(col_names[n])-len(str(a[row][n])))) for n in range(len(a[row])))
    print(row_names[row] ,"   ",*row_data)

it messy but heres a rundown,

the first print prints the column names followed by a few spaces fed by a generator of the col_names list (plus a few spaces at the beginning to make room for the row names)

the for loop is to make sure to catch each row

the row_data variable does the same thing as the generator at the beginning, but concatenates the data from list a with enough spaces to make up the difference between the length of the column names and the length of the data (so that the rows and columns line up)

then the second print function just prints that line out with the row name at the beginning