it-swarm-eu.dev

En Python, existe-t-il un moyen élégant d'imprimer une liste dans un format personnalisé sans boucle explicite?

Je sais que tu peux faire

print str(myList)

obtenir

[1, 2, 3]

et vous pouvez faire

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

obtenir

0: 1  
1: 2  
2: 3    

Mais existe-t-il un moyen similaire au premier pour obtenir un résultat similaire au dernier?

Avec ma connaissance limitée de Python (et un peu d'aide de la documentation), mon meilleur est:

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

Ce n'est pas beaucoup moins verbeux, mais au moins j'obtiens une chaîne personnalisée dans une instruction (composée). Pouvez-vous faire mieux?

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

Remarque: il vous suffit de comprendre cette liste de compréhension ou d'itération sur une expression de générateur is boucle explicite.

99
SilentGhost

Dans python 3s:

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

Sortie:

My list:
- 1
- 2
- 3

Con: le sep doit être une chaîne, vous ne pouvez donc pas le modifier en fonction de l'élément que vous imprimez. Et vous avez besoin d'une sorte d'en-tête pour ce faire (au-dessus, c'était 'My list:').

Pro: Vous n'avez pas besoin de join() une liste dans un objet chaîne, ce qui pourrait être avantageux pour des listes plus grandes. Et le tout est assez concis et lisible.

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

À partir de là:

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

Vous pouvez vous débarrasser de join en passant \n comme séparateur de print

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

Vous voyez maintenant que vous pouvez utiliser map, mais vous devrez changer la chaîne de format (beurk!)

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

ou passez 2 séquences à map. Un compteur séparé et ne plus énumérer lst

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

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

Cela utilise itertools.starmap, qui est comme map, sauf que *s l'argument dans la fonction. Dans ce cas, la fonction est '{}: {}'.format.

Je préférerais la compréhension de SilentGhost, mais starmap est une fonction agréable à connaître.

4
Thomas Ahle
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))))

Pour n = 500:

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

Pour n = 5000:

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

Oh, je vois maintenant: seule la solution 3 avec map () correspond au titre de la question.

3
eyquem

Un autre:

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

Encore une autre forme:

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

Cette méthode est agréable car les éléments individuels des tuples produits par énumération peuvent être modifiés tels que:

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

Bien sûr, n'oubliez pas que vous pouvez en obtenir une tranche comme ceci:

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

Jetez un oeil sur pprint , Le module pprint fournit une capacité de "jolie-impression" arbitraire Python structures de données sous une forme qui peut être utilisée comme entrée pour l'interpréteur . Si les structures formatées incluent des objets qui ne sont pas fondamentaux Python, la représentation peut ne pas être chargeable. Cela peut être le cas si des objets tels que des fichiers, des sockets ou des classes sont inclus, ainsi que de nombreux autres objets qui ne sont pas représentables comme Python littéraux.

>>> 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', (...)))))))
0
Adam