[] und {} vs list () und dict (), was ist besser?

Ich verstehe, dass beide im Wesentlichen dasselbe sind, aber was den Stil betrifft, welcher ist der bessere (pythonischere), um eine leere Liste oder ein leeres Diktat zu erstellen?

In Bezug auf die Geschwindigkeit ist es keine Konkurrenz für leere Listen / Diktate:

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

und für nicht leere:

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

Wenn Sie die Klammernotation verwenden, können Sie auch Listen- und Wörterbuchverständnisse verwenden, was Grund genug sein kann.

Meiner Meinung nach []und{} sind die pythonischsten und lesbarsten Möglichkeiten, leere Listen / Diktate zu erstellen.

Seien Sie jedoch vorsichtig set(), zum Beispiel:

this_set = {5}
some_other_set = {}

Kann verwirrend sein. Der erste erstellt eine Menge mit einem Element, der zweite erstellt ein leeres Diktat und keine Menge.

Die dict wörtliche könnte ein seine winzig bisschen schneller als Bytecode kürzer:

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

Gleiches gilt für die listvs[]

IMHO, mit list()und dict()lässt Ihr Python wie C. Ugh aussehen.

Im Falle eines Unterschieds zwischen [] und list () gibt es eine Gefahr, auf die ich noch niemanden hingewiesen habe. Wenn Sie ein Wörterbuch als Mitglied der Liste verwenden, führen die beiden zu völlig unterschiedlichen Ergebnissen:

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

list () und [] funktionieren unterschiedlich:

>>> def a(p=None):
...     print(id(p))
... 
>>> for r in range(3):
...     a([])
... 
139969725291904
139969725291904
139969725291904
>>> for r in range(3):
...     a(list())
... 
139969725367296
139969725367552
139969725367616

list () erstellt immer ein neues Objekt im Heap, aber [] kann die Speicherzelle aus vielen Gründen wiederverwenden.

Es gibt einen Unterschied im Verhalten zwischen [] und list (), wie das folgende Beispiel zeigt. Wir müssen list () verwenden, wenn wir die Liste der Zahlen zurückgeben möchten, sonst erhalten wir ein Kartenobjekt! Ich bin mir nicht sicher, wie ich es erklären soll.

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

Ein Kastenklammerpaar bezeichnet eines der Listenobjekte oder einen Indexindex, my_List [x].

Ein geschweiftes Klammerpaar bezeichnet ein Wörterbuchobjekt.

a_list = ['on', 'off', 1, 2]

a_dict = {on: 1, off: 2}

Es ist meistens eine Frage der Wahl. Es ist eine Frage der Präferenz.

Beachten Sie jedoch, dass Sie Folgendes nicht tun können, wenn Sie beispielsweise Zifferntasten haben:

mydict = dict(1="foo", 2="bar")

Du musst:

mydict = {"1":"foo", "2":"bar"}