web-dev-qa-db-fra.com

[] et {} vs list () et dict (), quel est le meilleur?

Je comprends qu’il s’agit essentiellement de la même chose, mais en termes de style, quel est le meilleur (plus Pythonique) à utiliser pour créer une liste vide ou un dict?

pythonperformancelistdictionary
94
Noah McIlraith

En termes de rapidité, il n’ya pas de concurrence pour les listes vierges:

>>> from timeit import timeit
>>> timeit("[]")
0.040084982867934334
>>> timeit("list()")
0.17704233359267718
>>> timeit("{}")
0.033620194745424214
>>> timeit("dict()")
0.1821558326547077

et pour non vide:

>>> timeit("[1,2,3]")
0.24316302770330367
>>> timeit("list((1,2,3))")
0.44744206316727286
>>> timeit("list(foo)", setup="foo=(1,2,3)")
0.446036018543964
>>> timeit("{'a':1, 'b':2, 'c':3}")
0.20868602015059423
>>> timeit("dict(a=1, b=2, c=3)")
0.47635635255323905
>>> timeit("dict(bar)", setup="bar=[('a', 1), ('b', 2), ('c', 3)]")
0.9028228448029267

De plus, en utilisant la notation entre crochets, vous utilisez des listes et des dictionnaires, ce qui peut constituer une raison suffisante.

178
Greg Haskins

À mon avis, [] Et {} Sont les moyens les plus lisibles et pythoniques de créer des listes/dict vides.

Méfiez-vous cependant de set(), par exemple:

this_set = {5}
some_other_set = {}

Peut être déroutant. Le premier crée un ensemble avec un élément, le second crée un dict vide et pas un ensemble.

31
orlp

[] et {} sont meilleurs

list () est intrinsèquement plus lent que [] et dict () est intrinsèquement plus lent que {},

Parce que

  1. Il y a recherche de symbole (aucun moyen pour python de savoir à l'avance si vous n'avez pas simplement redéfini la liste pour qu'elle soit autre chose!),

  2. Il y a invocation de fonction,

  3. Ensuite, il doit vérifier si un argument itérable a été passé (pour pouvoir créer une liste avec des éléments)

Dans la plupart des cas, la différence de vitesse ne fera toutefois aucune différence pratique.

( source )

27
Somnath Muluk

Le dict littéral pourrait être un minuscule bit plus rapide, car son code intermédiaire est plus court:

In [1]: import dis
In [2]: a = lambda: {}
In [3]: b = lambda: dict()

In [4]: dis.dis(a)
  1           0 BUILD_MAP                0
              3 RETURN_VALUE

In [5]: dis.dis(b)
  1           0 LOAD_GLOBAL              0 (dict)
              3 CALL_FUNCTION            0
              6 RETURN_VALUE

Il en va de même pour le list vs []

14
ThiefMaster

IMHO, en utilisant list() et dict() rend votre Python ressembler à C. Ugh.

3
RichieHindle

Dans le cas d'une différence entre [] et list (), il y a un piège que je n'ai vu personne indiquer. Si vous utilisez un dictionnaire en tant que membre de la liste, les deux résultats seront totalement différents:

In [1]: foo_dict = {"1":"foo", "2":"bar"}

In [2]: [foo_dict]
Out [2]: [{'1': 'foo', '2': 'bar'}]

In [3]: list(foo_dict)
Out [3]: ['1', '2']
1
oxtay

il existe une différence de comportement entre [] et list (), comme le montre l'exemple ci-dessous. nous devons utiliser list () si nous voulons avoir la liste des nombres retournés, sinon nous obtenons un objet map! Je ne sais pas comment l'expliquer.

sth = [(1,2), (3,4),(5,6)]
sth2 = map(lambda x: x[1], sth) 
print(sth2) # print returns object <map object at 0x000001AB34C1D9B0>

sth2 = [map(lambda x: x[1], sth)]
print(sth2) # print returns object <map object at 0x000001AB34C1D9B0>
type(sth2) # list 
type(sth2[0]) # map

sth2 = list(map(lambda x: x[1], sth))
print(sth2) #[2, 4, 6]
type(sth2) # list
type(sth2[0]) # int
1
sebtac