Gibt es in Python eine elegante Möglichkeit, eine Liste in einem benutzerdefinierten Format ohne explizites Looping zu drucken?

Question

Ich weiß, Sie

tun können

print str(myList) 

[1, 2, 3] 

zu erhalten und Sie können tun

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

0: 1 
1: 2 
2: 3  

zu bekommen, aber ist es eine Möglichkeit, ähnlich wie Der Erste um ein ähnliches Ergebnis zu erhalten?

Mit meiner begrenzten Kenntnis von Python (und etwas Hilfe von der Dokumentation), mein bestes ist:

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

Es ist nicht viel weniger ausführlich, aber zumindest ich eine benutzerdefinierte Zeichenfolge in einer (Verbindung) Anweisung erhalten . Können Sie es besser machen?

Answer 1

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

Hinweis: Sie müssen nur diese Liste Verständnis verstehen oder einen Generator Ausdruck iterieren ist explizite Looping.

Answer 2

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

Answer 3

Ein anderer:

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

Noch eine andere Form:

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

Diese Methode ist schön, da die einzelnen Elemente in durch enumerate erzeugt Tupeln modifiziert werden können, wie:

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

Natürlich vergessen Sie nicht, dass Sie ein Stück von diesem wie so bekommen kann:

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

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

Für n = 500:

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

Für n = 5000:

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

Oh, ich sehe jetzt: nur die Lösung 3 mit map() passt zum Titel der Frage.

Answer 5

>>> from itertools import starmap 

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

Dies verwendet itertools.starmap, die wie map ist, außer es * s das Argument in der Funktion. Die Funktion ist in diesem Fall '{}: {}'.format.

Ich würde das Verständnis von SilentGhost bevorzugen, aber starmap ist eine nette Funktion zu wissen.

Answer 6

In Python 3s Druckfunktion:

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

Ausgang:

My list: 
- 1 
- 2 
- 3 

Con: Die sep muss eine Zeichenfolge sein, so dass Sie es nicht ändern können, basierend auf welchem ​​Element Sie‘ erneut drucken. Und Sie brauchen eine Art von Header, um dies zu tun (darüber war 'My list:').

Pro: Sie müssen keine join() eine Liste in einem String-Objekt, die für größere Listen von Vorteil sein könnte. Und das Ganze ist sehr präzise und lesbar.

Answer 7

von diesem Start:

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

Sie können der join durch \n vorbei als Separator zu print

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

Nun, Sie map verwenden konnte sehen, loszuwerden, aber Sie brauchen um die Formatzeichenkette zu ändern (yuck!)

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

oder 2 Sequenzen an map übergeben. Ein separater Zähler und nicht mehr zählen lst

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