Alinea columnas de números (salida de impresión en formato de tabla)

Question

tengo datos (números) guardados en el formato siguiente (ejemplo):

234 127 34 23 45567 
23 12 4 4 45 
23456 2 1 444 567 
... 

¿Hay algún método pitón vías para alinear los números y obténgalos como

234 127 34 23 45567 
    23 12 4 4  45 
23456 2 1 444 567 

(No puedo predecir el tamaño de la columna).

Answer 1

Aquí es un ejemplo simple, autónomo que muestra cómo dar formato ancho de las columnas variables:

data = '''\ 
234 127 34 23 45567 
23 12 4 4 45 
23456 2 1 444 567''' 

# Split input data by row and then on spaces 
rows = [ line.strip().split(' ') for line in data.split('\n') ] 

# Reorganize data by columns 
cols = zip(*rows) 

# Compute column widths by taking maximum length of values per column 
col_widths = [ max(len(value) for value in col) for col in cols ] 

# Create a suitable format string 
format = ' '.join(['%%%ds' % width for width in col_widths ]) 

# Print each row using the computed format 
for row in rows: 
    print format % tuple(row) 

que SALIDAS:

234 127 34 23 45567 
    23 12 4 4 45 
23456 2 1 444 567 

Answer 2

probar este buen ejemplo bien documentado http://code.activestate.com/recipes/267662-table-indentation/

Answer 3

necesita alguna manera de encontrar el tamaño de la columna, tal vez mediante la lectura de todos los datos y la búsqueda de la máxima anchura.

>>> line='234 127 34 23 45567' 
>>> line.split() 
['234', '127', '34', '23', '45567'] 
>>> max(map(len, line.split())) 
5 

Repita en todas las líneas, para buscar el tamaño de columna (por ejemplo, 5). La construcción de una línea formateada con percent formatting es sencilla.

>>> colsize = 5 
>>> ' '.join(('%*s' % (colsize, i) for i in line.split())) 
' 234 127 34 23 45567' 
>>> 

Answer 4

#!/usr/bin/env python 

class ALIGN: 
    LEFT, RIGHT = '-', '' 

class Column(list): 
    def __init__(self, name, data, align=ALIGN.RIGHT): 
     list.__init__(self, data) 
     self.name = name 
     width = max(len(str(x)) for x in data + [name]) 
     self.format = ' %%%s%ds ' % (align, width) 

class Table: 
    def __init__(self, *columns): 
     self.columns = columns 
     self.length = max(len(x) for x in columns) 
    def get_row(self, i=None): 
     for x in self.columns: 
      if i is None: 
       yield x.format % x.name 
      else: 
       yield x.format % x[i] 
    def get_rows(self): 
     yield ' '.join(self.get_row(None)) 
     for i in range(0, self.length): 
      yield ' '.join(self.get_row(i)) 

    def __str__(self): 
     return '\n'.join(self.get_rows()) 

Para su ejemplo:

if __name__ == '__main__': 
    print Table(
     Column("", [234, 32, 23456]), 
     Column("", [127, 12, 2]), 
     Column("", [34, 4, 1]), 
     Column("", [23, 4, 444]), 
     Column("", [45567, 45, 567]) 
    ) 

Será rendimiento:

234 127 34 23 45567 
    32 12 4  4  45 
23456  2 1 444  567 

Adaptado de http://code.activestate.com/recipes/577202-render-tables-for-text-interface/

Answer 5

>>> rows = """234 127 34 23 45567 
... 23 12 4 4 45 
... 23456 2 1 444 567""" 

convertir primero las filas en una matriz 2D (lista de listas)

>>> arr=[x.split() for x in rows.split("\n")] 

ahora calcular el espacio necesitará cada campo para encajar en

>>> widths = [max(map(len,(f[i] for f in tab))) for i in range(len(arr[0]))] 

y la almohadilla de cada elemento para encajar en ese espacio

>>> [[k.rjust(widths[i]) for i,k in enumerate(j)] for j in arr] 
[[' 234', '127', '34', ' 23', '45567'], [' 23', ' 12', ' 4', ' 4', ' 45'], ['23456', ' 2', ' 1', '444', ' 567']] 

finalmente unirse a la matriz vuelta a una cadena

>>> print "\n".join(" ".join(k.rjust(widths[i]) for i,k in enumerate(j)) for j in arr) 
    234 127 34 23 45567 
    23 12 4 4  45 
23456 2 1 444 567 

Answer 6

Entero en frente de la d es en qué columna comenzarán los números enteros después del número anterior de para que pueda alinearlos de la manera que considere adecuada

print("{0:4d} {1:4d} {2:4d} {3:4d} {4:4d}".format(234, 127, 34, 23, 45567))

repita si es necesario

Answer 7

respuesta de Kevin Jacobs modificado para permitir a variable number of integers on each row:

def align(data, delimiter = '\t', is_left_align = True): 
    rows = [row.strip().split(delimiter) for row in data.split('\n')] 
    cols = map(lambda *row: [str(field) or '' for field in row], *rows) 
    widths = [max(len(field) for field in col) for col in cols] 
    format = ['%%%s%ds' % ('-' if is_left_align else '', width) for width in widths] 
    return '\n'.join([delimiter.join(format[:len(row)]) % tuple(row) for row in rows]) 

data = '''\ 
234 127 34 23 45567 
23 12 4 4 45 
23456 2 1 444 567''' 
print(align(data, ' ', False))