Question

我知道你可以做到

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

它不是那么冗长，但至少我在一个（复合）语句中得到一个自定义字符串。你能做得更好吗？

Answer 1

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

注意：您只需要了解列表理解或迭代生成器表达式是显式循环。

Answer 2

在python 3s中打印函数：

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

输出：

My list:
- 1
- 2
- 3

Con ：sep必须是字符串，因此您无法根据要打印的元素对其进行修改。你需要一种标题才能做到这一点（上面是'My list:'）。

Pro ：您不必join()列出一个字符串对象，这对于较大的列表可能更有利。整个过程非常简洁易读。

Answer 3

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

Answer 4

从这开始：

>>> 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，但你需要更改格式字符串（哎呀！）

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

Answer 5

>>> 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是一个很好的功能。

Answer 6

另：

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

Answer 7

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

哦，我现在看到：只有带有map（）的解决方案3符合问题的标题。

Answer 8

看看pprint，pprint模块提供了一种以可以用作解释器输入的形式“漂亮地打印”任意Python数据结构的功能。如果格式化的结构包含不是基本Python类型的对象，则表示可能无法加载。如果包括文件，套接字或类之类的对象以及许多其他无法用Python文字表示的对象，则可能是这种情况。

def myCommand = "mvn -q -Dexec.executable=echo -Dexec.args=\"${project.version}\" --non-recursive exec:exec"

在Python中，是否有一种优雅的方式以自定义格式打印列表而无需显式循环？

8 个答案: