Czy jest jakaś różnica między używaniem literału dict a konstruktorem dict?

Za pomocą PyCharm zauważyłem, że oferuje konwersję dosłownego słownika :

d = {
    'one': '1',
    'two': '2',
}

w konstruktora nagrań :

d = dict(one='1', two='2')

Czy te różne podejścia różnią się w jakiś znaczący sposób?

(Pisząc to pytanie zauważyłem, że użycie dict()klucza numerycznego wydaje się niemożliwe ... d = {1: 'one', 2: 'two'}jest możliwe, ale oczywiście dict(1='one' ...)nie jest. Coś jeszcze?)

Myślę, że wskazałeś najbardziej oczywistą różnicę. Oprócz tego,

pierwszy nie musi wyszukiwać, dictco powinno nieco przyspieszyć

drugi patrzy dictw locals()czym globals()i odnajduje wbudowane, więc można przełączyć zachowań poprzez zdefiniowanie lokalnego o nazwie dictna przykład, choć nie mogę myśleć o gdziekolwiek to będzie dobry pomysł, oprócz być może podczas debugowania

Dosłowność jest znacznie szybsza, ponieważ wykorzystuje zoptymalizowane kody BUILD_MAP i STORE_MAP zamiast ogólnych CALL_FUNCTION:

> python2.7 -m timeit "d = dict(a=1, b=2, c=3, d=4, e=5)"
1000000 loops, best of 3: 0.958 usec per loop

> python2.7 -m timeit "d = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}"
1000000 loops, best of 3: 0.479 usec per loop

> python3.2 -m timeit "d = dict(a=1, b=2, c=3, d=4, e=5)"
1000000 loops, best of 3: 0.975 usec per loop

> python3.2 -m timeit "d = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}"
1000000 loops, best of 3: 0.409 usec per loop

Wyglądają prawie tak samo w Pythonie 3.2.

Jak wskazał gnibbler, pierwszy nie musi wyszukiwać dict, co powinno nieco przyspieszyć.

>>> def literal():
...   d = {'one': 1, 'two': 2}
...
>>> def constructor():
...   d = dict(one='1', two='2')
...
>>> import dis
>>> dis.dis(literal)
  2           0 BUILD_MAP                2
              3 LOAD_CONST               1 (1)
              6 LOAD_CONST               2 ('one')
              9 STORE_MAP
             10 LOAD_CONST               3 (2)
             13 LOAD_CONST               4 ('two')
             16 STORE_MAP
             17 STORE_FAST               0 (d)
             20 LOAD_CONST               0 (None)
             23 RETURN_VALUE
>>> dis.dis(constructor)
  2           0 LOAD_GLOBAL              0 (dict)
              3 LOAD_CONST               1 ('one')
              6 LOAD_CONST               2 ('1')
              9 LOAD_CONST               3 ('two')
             12 LOAD_CONST               4 ('2')
             15 CALL_FUNCTION          512
             18 STORE_FAST               0 (d)
             21 LOAD_CONST               0 (None)
             24 RETURN_VALUE

Te dwa podejścia dają identyczne słowniki, z wyjątkiem, jak zauważyłeś, gdzie zakłócają się reguły leksykalne Pythona.

Dosłowne słowniki są nieco bardziej oczywistymi słownikami i możesz stworzyć dowolny klucz, ale musisz podać nazwy kluczy. Z drugiej strony możesz użyć zmiennych dla kluczy, jeśli z jakiegoś powodu potrzebujesz:

a = "hello"
d = {
    a: 'hi'
    }

dict()Konstruktor daje większą elastyczność ze względu na różnorodność form wejścia przez nią działań. Na przykład możesz podać iterator par, który będzie traktował je jako pary klucz / wartość.

Nie mam pojęcia, dlaczego PyCharm zaoferowałby konwersję jednej formy na drugą.

Jedną dużą różnicą w przypadku Pythona 3.4 + pycharm jest to, że konstruktor dict () generuje komunikat „błąd składni”, jeśli liczba kluczy przekracza 256.

Wolę teraz używać literału dict.

Z samouczka Python 2.7:

Para nawiasów tworzy pusty słownik: {}. Umieszczenie rozdzielonej przecinkami listy par klucz: wartość w nawiasach klamrowych dodaje początkowe pary klucz: wartość do słownika; w ten sposób słowniki są zapisywane na wyjściu.

tel = {'jack': 4098, 'sape': 4139}
data = {k:v for k,v in zip(xrange(10), xrange(10,20))}

Podczas:

Konstruktor dict () buduje słowniki bezpośrednio z list par klucz-wartość przechowywanych jako krotki. Gdy pary tworzą wzór, zestawienia list mogą w zwięzły sposób określać listę klucz-wartość.

tel = dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]) {'sape': 4139, 'jack': 4098, 'guido': 4127}
data = dict((k,v) for k,v in zip(xrange(10), xrange(10,20)))

Gdy klucze są prostymi ciągami, czasem łatwiej jest określić pary za pomocą argumentów słów kluczowych:

dict(sape=4139, guido=4127, jack=4098)
>>>  {'sape': 4139, 'jack':4098, 'guido': 4127}

Zatem zarówno {}, jak i dict () tworzą słownik, ale zapewniają nieco inne sposoby inicjowania danych słownikowych.

Uważam, że dosłowny słownik d = {'one': '1'}jest znacznie bardziej czytelny, ponieważ definiujesz dane, zamiast przypisywać wartości i wysyłać je do dict()konstruktora.

Z drugiej strony widziałem, jak ludzie błędnie wpisują dosłowny słownik, ponieważ d = {'one', '1'}we współczesnym Pythonie 2.7+ stworzy zestaw.

Mimo to nadal wolę na wszelkie sposoby korzystać z zestawu literału, ponieważ myślę, że jest to bardziej czytelna, osobista preferencja.

literał dict () jest przydatny, gdy kopiujesz wklejanie wartości z czegoś innego (brak pytona) Na przykład z listy zmiennych środowiskowych. powiedzmy, jeśli masz plik bash

FOO='bar'
CABBAGE='good'

możesz łatwo wkleić następnie do dict()literału i dodać komentarze. Ułatwia także odwrotne kopiowanie do czegoś innego. Podczas gdy {'FOO': 'bar'}składnia jest dość unikalna dla Pythona i Jsona. Więc jeśli często używasz Jsona, możesz chcieć używać {}literałów z podwójnymi cudzysłowami.

Nie ma literału-dyktu do tworzenia klas dziedziczonych przez dyk, niestandardowych klas-dykt z dodatkowymi metodami. W takim przypadku należy użyć niestandardowego konstruktora klasy dict, na przykład:

class NestedDict(dict):

    # ... skipped

state_type_map = NestedDict(**{
    'owns': 'Another',
    'uses': 'Another',
})

Weź również pod uwagę fakt, że tokenów pasujących do operatorów nie można używać w składni konstruktora, tj. Klucze przerywane.

>>> dict(foo-bar=1)
File "<stdin>", line 1
SyntaxError: keyword can't be an expression

>>> {'foo-bar': 1}
{'foo-bar': 1}