Wie kann man eine Liste schöner drucken?

Question

Dies ist vergleichbar mit Wie man eine Liste in Python "schön" ausdruckt aber ich würde die Liste gerne noch schöner ausdrucken - ohne die Klammern, Apostrophe und Kommas, und noch besser in Spalten.

foolist = ['exiv2-devel', 'mingw-libs', 'tcltk-demos', 'fcgi', 'netcdf', 
    'pdcurses-devel',     'msvcrt', 'gdal-grass', 'iconv', 'qgis-devel', 
    'qgis1.1', 'php_mapscript']

evenNicerPrint(foolist)

Erwünschtes Ergebnis:

exiv2-devel       msvcrt        
mingw-libs        gdal-grass    
tcltk-demos       iconv         
fcgi              qgis-devel    
netcdf            qgis1.1       
pdcurses-devel    php_mapscript 

Danke!

Answer 1

Es gibt bereits viele Antworten, aber ich werde meine Lösung teilen, die zusätzlich zum Drucken der Liste in mehrere Spalten, es wählt auch die Anzahl der Spalten dynamisch, von der Terminalbreite und die längste Zeichenfolge auf der Liste.

import os
cols = os.popen('stty size', 'r').read().split()[1]

def print_multicol(my_list):
    max_len = len(max(my_list,key=len)) + 2
    ncols = (int(cols) -4 ) / max_len
    while my_list:
        n = 0
        while n < ncols:
            if len(my_list) > 0 :
                fstring = "{:<"+str(max_len)+"}"
                print fstring.format(my_list.pop(0)),
            n += 1
        print

a_list = "a ab abc abcd abcde b bc bcde bcdef c cde cdef cdfg d de defg"
a_list += "defgh e ef efg efghi efghij f fg fgh fghij fghijk"

print_multicol(a_list.split())

Answer 2

Als Erweiterung von @Aman folgt eine Funktion, die eine Liste von Zeichenketten annimmt und sie in Spalten basierend auf der Terminalgröße ausgibt.

import os
def column_display(input_list):
    '''
    Used to create a structured column display based on the users terminal size

    input_list : A list of string items which is desired to be displayed
    '''
    rows, columns = os.popen('stty size', 'r').read().split()
    terminal_space_eighth = int(columns)/8
    terminal_space_seventh = int(columns)/7
    terminal_space_sixth = int(columns)/6
    terminal_space_fifth = int(columns)/5
    terminal_space_quarter = int(columns)/4
    terminal_space_third = int(columns)/3
    terminal_space_half = int(columns)/2
    longest_string = max(input_list, key=len)
    longest_length = len(longest_string) + 1
    list_size = len(input_list)

    if longest_length > terminal_space_half:
         for string in input_list:
             print(string)
    elif terminal_space_eighth >= longest_length and list_size >= 8:
         for a,b,c,d,e,f,g,h in zip(input_list[::8],input_list[1::8],input_list[2::8], input_list[3::8], input_list[4::8], input_list[5::8], input_list[6::8], input_list[7::8]):
             column_space = '{:<%s}{:<%s}{:<%s}{:<%s}{:<%s}{:<%s}{:<%s}{:<}' % (longest_length, longest_length, longest_length, longest_length, longest_length, longest_length, longest_length )
             output = column_space.format(a,b,c,d,e,f,g,h)
             print(output)
    elif terminal_space_seventh >= longest_length and list_size >= 7:
        for a,b,c,d,e,f,g in zip(input_list[::7],input_list[1::7],input_list[2::7], input_list[3::7], input_list[4::7], input_list[5::7], input_list[6::7]):
             column_space = '{:<%s}{:<%s}{:<%s}{:<%s}{:<%s}{:<%s}{:<}' % (longest_length, longest_length, longest_length, longest_length, longest_length, longest_length)
             output = column_space.format(a,b,c,d,e,f,g)
             print(output)
    elif terminal_space_sixth >= longest_length and list_size >= 6:
         for a,b,c,d,e,f in zip(input_list[::6],input_list[1::6],input_list[2::6], input_list[3::6], input_list[4::6], input_list[5::6]):
             column_space = '{:<%s}{:<%s}{:<%s}{:<%s}{:<%s}{:<}' % (longest_length, longest_length, longest_length, longest_length, longest_length)
             output = column_space.format(a,b,c,d,e,f)
             print(output)
    elif terminal_space_fifth >= longest_length and list_size >= 5:
        for a,b,c,d,e in zip(input_list[::5],input_list[1::5],input_list[2::5], input_list[3::5], input_list[4::5]):
            column_space = '{:<%s}{:<%s}{:<%s}{:<%s}{:<}' % (longest_length, longest_length, longest_length, longest_length)
            output = column_space.format(a,b,c,d,e)
            print(output)
    elif terminal_space_quarter >= longest_length and list_size >= 4:
        for a,b,c,d in zip(input_list[::4],input_list[1::4],input_list[2::4], input_list[3::4]):
            column_space = '{:<%s}{:<%s}{:<%s}{:<}' % (longest_length, longest_length, longest_length)
            output = column_space.format(a,b,c,d)
            print(output)
    elif terminal_space_third >= longest_length and list_size >= 3:
        for a,b,c in zip(input_list[::3],input_list[1::3],input_list[2::3]):
            column_space = '{:<%s}{:<%s}{:<}' % (longest_length, longest_length)
            output = column_space.format(a,b,c)
            print(output)
    elif terminal_space_half >= longest_length and list_size >= 2:
        for a,b in zip(input_list[::2],input_list[1::2]):
            column_space = '{:<%s}{:<}' % longest_length
            output = column_space.format(a,b)
            print(output)

Zur Erläuterung: Es gibt verschiedene Möglichkeiten.

Erste wird die Anzahl der Spalten für das Terminal des aktuellen Benutzers mit os.popen ermittelt.

Zweite wird die Anzahl der Spalten halbiert und auf ein Achtel erhöht. Damit wird die längste Zeichenkette in der Liste verglichen, um die Anzahl der dafür am besten geeigneten Spalten zu ermitteln.

Dritte ist die längste Zeichenkette der Liste, die mit der eingebauten Python-Funktion max() gezogen wurde.

Forth wird die Länge der längsten Zeichenkette genommen und dann um eins aufgefüllt. Die Länge der Liste wird ebenfalls übernommen, so dass bei einer Liste mit weniger als 8 Einträgen nur die Anzahl der vorhandenen Einträge aufgeführt wird.

Fünfte wird die längste Zeichenkettenlänge mit jedem der terminalen Leerzeichen von einer bis acht Spalten verglichen. Wenn die Spalte größer oder gleich der Länge ist, kann sie verwendet werden. Wenn zum Beispiel die längste Zeichenkette 10 ist und die Spalten geteilt durch acht (terminal_space_eighth) 8 sind, aber die Spalten geteilt durch sieben (terminal_space_seventh) 12 sind, gibt es sieben Spalten. Es werden sieben sein, weil die längste Zeichenkette in 12 Zeichen passt, aber nicht in 8 Zeichen.

Es ist auch erwähnenswert, dass die Länge der Liste berücksichtigt wird, um zu verhindern, dass mehr Spalten als Listenelemente erstellt werden.

Sechste ist eine Erweiterung der Erklärung von @Aman : https://stackoverflow.com/a/1524132/11002603

Indizierung Für dieses Beispiel soll i die Zahl sein, die durch die Größe des Terminals bestimmt wird. input_list[::i] Dies wählt das Element bei i aus. Durch Hinzufügen einer Zahl am Anfang wie input_list[1::i] verschiebt den Startpunkt (denken Sie daran, dass Python 0 als gültige Zahl betrachtet, weshalb sie anfangs nicht verwendet wird).

Zipping

Zip wird verwendet, um ein Tupel mit Elementen einer Liste zu erstellen. Die Ausgabeliste sieht zum Beispiel wie folgt aus

zip([string1,string2,string3], [string4,string5, string6], [string7,string8,string9])
output : [(string1,string4,string7), (string2,string5, string8), (string3,string6,string9)]

Gemeinsam nutzen Je nach Anzahl der Spalten werden die Buchstaben nur zur Darstellung einer Aufteilung verwendet. Wenn also zum Beispiel nur 5 Spalten in das Terminal passen, wird Folgendes verwendet

for a,b,c,d,e in zip(input_list[::5],input_list[1::5],input_list[2::5], input_list[3::5], input_list[4::5]):

Dabei werden die beim Zippen erzeugten Tupel als Variablen a, b, c, d und e gespeichert, so dass wir sie in der Schleife aufrufen können.

Der Spaltenraum wird dann für die Formatierung von a, b, c, d und e in die jeweiligen Spalten verwendet, und hier wird die Länge jeder Spalte bestimmt. Die Länge basiert auf der oben ermittelten Länge der Zeichenfolge.

Answer 3

Ich musste jede der Spalten anpassen. Ich habe diesen Code implementiert

def print_sorted_list(data, columns):
    if data:
        gap = 2
        ljusts = {}
        for count, item in enumerate(sorted(data), 1):
            column = count % columns
            ljusts[column] = len(item) if (column not in ljusts) else max(ljusts[column], len(item))

        for count, item in enumerate(sorted(data), 1):
            print item.ljust(ljusts[count % columns] + gap),
            if (count % columns == 0) or (count == len(data)):
                print

Beispiel:

foolist = ['exiv2-devel', 'mingw-libs', 'tcltk-demos', 'fcgi', 'netcdf',
           'pdcurses-devel', 'msvcrt', 'gdal-grass', 'iconv', 'qgis-devel',
           'qgis1.1', 'php_mapscript', 'blablablablablablabla', 'fafafafafafa']
print_sorted_list(foolist, 4)

Ausgabe:

blablablablablablabla   exiv2-devel      fafafafafafa    fcgi        
gdal-grass              iconv            mingw-libs      msvcrt      
netcdf                  pdcurses-devel   php_mapscript   qgis-devel  
qgis1.1                 tcltk-demos

Answer 4

Hier ist ein einfacher Weg. Siehe die Inline-Kommentare zur Erklärung:

import shutil
import itertools
from functools import reduce

def split_list(lst, ncols):
    """Split list into rows"""
    return itertools.zip_longest(
        *[lst[i::ncols] for i in range(ncols)], fillvalue=""
    )
    # -- Alternatively --
    # import numpy as np
    # array = np.array(lst)
    # nrows = array.size / ncols + 1
    # return np.array_split(array, int(nrows))

def print_in_columns(lst):
    """Print a list in columns."""
    # Find maximum length of a string in colors_list
    colsize = reduce(lambda x, y: max(x, len(y)), lst, 0)
    # Terminal width
    maxcols = shutil.get_terminal_size()[0]
    ncols = maxcols / (colsize + 1)
    rows = split_list(lst, int(ncols))

    print(
        # Join rows
        "\n".join(
            (
                # Fill items left justified
                " ".join(item.ljust(colsize) for item in row)
                for row in rows
            )
        )
    )

Answer 5

Dieser druckt die Liste in separaten Spalten (die Reihenfolge bleibt erhalten)

from itertools import zip_longest

def ls(items, n_cols=2, pad=30):
    if len(items) == 0:
        return
    total = len(items)
    chunk_size = total // n_cols
    if chunk_size * n_cols < total:
        chunk_size += 1
    start = range(0, total, chunk_size)
    end = range(chunk_size, total + chunk_size, chunk_size)
    groups = (items[s:e] for s, e in zip(start, end))
    for group in zip_longest(*groups, fillvalue=''):
        template = (' ').join(['%%-%ds' % pad] * len(group))
        print(template % group)

Verwendung:

ls([1, 2, 3, 4, 5, 6, 7], n_cols=3, pad=10)

Ausgabe:

1          4          7         
2          5                    
3          6                    

Beachten Sie, dass bei einer unzureichenden Anzahl von Einträgen Spalten fehlen können, da die Spalten zuerst gefüllt werden.

ls([1, 2, 3, 4, 5], n_cols=4)

Ausgabe:

1          3          5         
2          4