В Python существует ли элегантный способ распечатки списка в пользовательском формате без явного цикла?

Я знаю, что вы можете сделать

print str(myList)

чтобы получить

[1, 2, 3]

и вы можете сделать

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

чтобы получить

0: 1  
1: 2  
2: 3

Но есть ли способ, похожий на первый, получить результат, похожий на последний?

С моим ограниченным знанием Python (и некоторой помощью из документации), мое лучшее:

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

Это не намного меньше подробностей, но, по крайней мере, я получаю пользовательскую строку в одном (составном) выражении. Вы можете сделать лучше?

Ответ 1

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

Примечание. Вам просто нужно понять, что понимание списка или итерация по выражению генератора есть явный цикл.

Ответ 2

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

Ответ 3

>>> from itertools import starmap

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

В этом случае используется itertools.starmap, что похоже на map, кроме аргумента * в функцию. Функция в этом случае '{}: {}'.format.

Я предпочел бы понимание SilentGhost, но starmap - хорошая функция, о которой нужно знать.

Ответ 4

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))))

При n = 500:

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

При n = 5000:

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

О, теперь я вижу: только решение 3 с map() соответствует заголовку вопроса.

Ответ 5

В функции печати python 3s:

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

Вывод:

My list:
- 1
- 2
- 3

Кон: sep должен быть строкой, поэтому вы не можете изменять ее на основе того, какой элемент вы печатаете. И для этого вам нужен заголовок (над ним было 'My list:').

Pro: вам не нужно join() список в строковый объект, что может быть полезно для больших списков. И все это довольно кратким и читаемым.

Ответ 6

Начиная с этого:

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

Вы можете избавиться от join, передав \n в качестве разделителя на print

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

Теперь вы видите, что можете использовать map, но вам нужно будет изменить строку формата (yuck!)

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

или передать 2 последовательности в map. Отдельный счетчик и больше не перечисляет lst

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

Ответ 7

Другой:

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

Еще одна форма:

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

Этот метод хорош, так как отдельные элементы в кортежах, создаваемые enumerate, могут быть изменены, например:

>>> 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

Конечно, не забывайте, что вы можете получить фрагмент из этого так:

>>> for i,j in list(enumerate(lst))[1:2]: print "%i: %i"%(i,j)
... 
1: 11