En Python, ¿existe una forma elegante de imprimir una lista en un formato personalizado sin un bucle explícito?

Se que puedes hacer

print str(myList) 

Llegar

 [1, 2, 3] 

y tu puedes hacer

 i = 0 for entry in myList: print str(i) + ":", entry i += 1 

Llegar

 0: 1 1: 2 2: 3 

¿Pero hay una manera similar a la primera para obtener un resultado similar a la anterior?

Con mi conocimiento limitado de Python (y algo de ayuda de la documentación), lo mejor es:

 print '\n'.join([str(n) + ": " + str(entry) for (n, entry) in zip(range(0,len(myList)), myList)]) 

No es mucho menos detallado, pero al menos obtengo una cadena personalizada en una statement (compuesta). ¿Puedes hacerlo mejor?

 >>> lst = [1, 2, 3] >>> print('\n'.join('{}: {}'.format(*k) for k in enumerate(lst))) 0: 1 1: 2 2: 3 

Nota: solo necesita comprender que la comprensión de la lista o la iteración sobre una expresión generadora es un bucle explícito.

En la función de impresión python 3s:

 lst = [1, 2, 3] print('My list:', *lst, sep='\n- ') 

Salida:

 My list: - 1 - 2 - 3 

Contras : el sep debe ser una cadena, por lo que no puede modificarlo según el elemento que esté imprimiendo. Y necesitas un tipo de encabezado para hacer esto (arriba estaba 'My list:' ).

Pro : no tiene que join() una lista en un objeto de cadena, lo que podría ser ventajoso para listas más grandes. Y todo es bastante conciso y legible.

 l = [1, 2, 3] print '\n'.join(['%i: %s' % (n, l[n]) for n in xrange(len(l))]) 

A partir de esto:

 >>> lst = [1, 2, 3] >>> print('\n'.join('{}: {}'.format(*k) for k in enumerate(lst))) 0: 1 1: 2 2: 3 

Puede deshacerse de la join pasando \n como separador para print

 >>> print(*('{}: {}'.format(*k) for k in enumerate(lst)), sep="\n") 0: 1 1: 2 2: 3 

Ahora ves que puedes usar el map , pero necesitarás cambiar la cadena de formato (¡qué asco!)

 >>> print(*(map('{0[0]}: {0[1]}'.format, enumerate(lst))), sep="\n") 0: 1 1: 2 2: 3 

o pasar 2 secuencias para map . Un contador separado y ya no enumerar lst

 >>> from itertools import count >>> print(*(map('{}: {}'.format, count(), lst)), sep="\n") 0: 1 1: 2 2: 3 
 >>> from itertools import starmap >>> lst = [1, 2, 3] >>> print('\n'.join(starmap('{}: {}'.format, enumerate(lst)))) 0: 1 1: 2 2: 3 

Esto usa itertools.starmap , que es como un map , excepto que * s el argumento en la función. La función en este caso es '{}: {}'.format .

Preferiría la comprensión de SilentGhost, pero starmap es una buena función para conocer.

Otro:

 >>> lst=[10,11,12] >>> fmt="%i: %i" >>> for d in enumerate(lst): ... print(fmt%d) ... 0: 10 1: 11 2: 12 

Otra forma más:

 >>> for i,j in enumerate(lst): print "%i: %i"%(i,j) 

Ese método es bueno ya que los elementos individuales en las tuplas producidas por enumeración pueden modificarse como:

 >>> for i,j in enumerate([3,4,5],1): print "%i^%i: %i "%(i,j,i**j) ... 1^3: 1 2^4: 16 3^5: 243 

Por supuesto, no olvides que puedes obtener una porción de esto así:

 >>> for i,j in list(enumerate(lst))[1:2]: print "%i: %i"%(i,j) ... 1: 11 
 from time import clock from random import sample n = 500 myList = sample(xrange(10000),n) #print myList A,B,C,D = [],[],[],[] for i in xrange(100): t0 = clock() ecr =( '\n'.join('{}: {}'.format(*k) for k in enumerate(myList)) ) A.append(clock()-t0) t0 = clock() ecr = '\n'.join(str(n) + ": " + str(entry) for (n, entry) in zip(range(0,len(myList)), myList)) B.append(clock()-t0) t0 = clock() ecr = '\n'.join(map(lambda x: '%s: %s' % x, enumerate(myList))) C.append(clock()-t0) t0 = clock() ecr = '\n'.join('%s: %s' % x for x in enumerate(myList)) D.append(clock()-t0) print '\n'.join(('t1 = '+str(min(A))+' '+'{:.1%}.'.format(min(A)/min(D)), 't2 = '+str(min(B))+' '+'{:.1%}.'.format(min(B)/min(D)), 't3 = '+str(min(C))+' '+'{:.1%}.'.format(min(C)/min(D)), 't4 = '+str(min(D))+' '+'{:.1%}.'.format(min(D)/min(D)))) 

Para n = 500:

 150.8%. 142.7%. 110.8%. 100.0%. 

Para n = 5000:

 153.5%. 176.2%. 109.7%. 100.0%. 

Oh, ya veo: solo la solución 3 con map () encaja con el título de la pregunta.

Eche un vistazo a pprint . El módulo pprint proporciona la capacidad de “imprimir bastante” estructuras de datos de Python arbitrarias en una forma que se puede usar como entrada para el intérprete. Si las estructuras con formato incluyen objetos que no son tipos fundamentales de Python, es posible que la representación no se pueda cargar. Este puede ser el caso si se incluyen objetos como archivos, sockets o clases, así como muchos otros objetos que no se pueden representar como literales de Python.

 >>> import pprint >>> stuff = ['spam', 'eggs', 'lumberjack', 'knights', 'ni'] >>> stuff.insert(0, stuff[:]) >>> pp = pprint.PrettyPrinter(indent=4) >>> pp.pprint(stuff) [ ['spam', 'eggs', 'lumberjack', 'knights', 'ni'], 'spam', 'eggs', 'lumberjack', 'knights', 'ni'] >>> pp = pprint.PrettyPrinter(width=41, compact=True) >>> pp.pprint(stuff) [['spam', 'eggs', 'lumberjack', 'knights', 'ni'], 'spam', 'eggs', 'lumberjack', 'knights', 'ni'] >>> tup = ('spam', ('eggs', ('lumberjack', ('knights', ('ni', ('dead', ... ('parrot', ('fresh fruit',)))))))) >>> pp = pprint.PrettyPrinter(depth=6) >>> pp.pprint(tup) ('spam', ('eggs', ('lumberjack', ('knights', ('ni', ('dead', (...)))))))