PostScript du 11/12/2019: Dans le commentaire, vous avez signalé une erreur de mesure du temps. Nous revalidons actuellement avec le bon code.
TL;DR
--[]la notation est plus avantageuse en temps d'exécution
list () et [].Python a la philosophie «Il devrait y avoir une - et de préférence une seule - façon évidente de le faire.», Mais il y a deux façons d'écrire une liste, qui est l'une des structures de données les plus fréquemment utilisées. Est-ce contre cette philosophie? Y a-t-il une différence qui permet des définitions différentes? J'étais inquiet.
StackOverflow avait une question similaire en 2015.
One's a function call, and one's a literal:
Eh bien, list () est une fonction et [] est un littéral.
Eh bien, je ne sais pas.
For the sake of completion, another thing to note is that list((a,b,c)) will return [a,b,c], whereas [(a,b,c)] will not unpack the tuple. This can be useful when you want to convert a tuple to a list. The reverse works too, tuple([a,b,c]) returns (a,b,c).
En effet, le comportement des taples est différent. Cette différence de comportement montre-t-elle qu'il s'agit d'un littéral avec la fonction ci-dessus?
Quora a également posé une question similaire en 2016.
The end result is the same whether you use [ ] or list() and same for { } vs. dict(). There is a difference in performance, though. [ ] and { } are more performant than the alternatives, list() and dict(), mainly because using list() and dict() involves the overhead of symbol lookup and function invocation.
In my opinion, using [ ] and { } is more pythonic. In addition, this notation allows you to take advantage of list/dictionary comprehension.
Au fait, même dans le type dictionnaire, il y a deux façons de le définir avec dict () et {}.
La notation littérale est-elle plus pythonique (comme Python)? Je ne comprends toujours pas du tout Python.
J'ai trouvé que certains d'entre eux se comportent différemment, mais lequel devrait être utilisé dans des situations où ils se comportent de la même manière? Puisqu'il y a une différence dans l'appel entre la fonction et le littéral, j'ai essayé de le vérifier avec le code qui crée l'objet 100 fois chacun.
list.py
#-*- using:utf-8 -*-
import time
if __name__ == '__main__':
start = time.time()
for i in range(0,100):
exec("list_%d = %s" % (i, []))
elapsed_time1 = time.time() - start
print ("elapsed_time:{0}".format(elapsed_time1) + "[sec]")
start = time.time()
for j in range(100,200):
exec("list_%d = %s" % (j, list()))
elapsed_time2 = time.time() - start
print ("elapsed_time:{0}".format(elapsed_time2) + "[sec]")
~~ Je vois, il y a une différence significative dans le temps d'exécution!
À propos, la signification du temps d'exécution dans le littéral [] était également reconnue lorsque le nombre de boucles était défini sur 1000 et 10000. ~~
Comme mentionné ci-dessus, si vous prenez un taple comme argument au moment de la génération, chacun se comportera différemment, Que se passe-t-il après la création de l'objet?
python
>>> l1 = []
>>> l1.append((1,2,3))
>>> print(l1)
[(1, 2, 3)]
>>> l2 = list()
>>> l2.append((1,2,3))
>>> print(l2)
[(1, 2, 3)]
Il ne semble y avoir aucune différence de comportement une fois qu'il est créé comme objet de liste. Je pense que ce domaine est Python ou orienté objet ... Je ne comprends pas orienté objet.
Q. Cela peut-il être fait? Ne peux pas? A. L'une ou l'autre notation peut être exécutée.
Recommended Posts