dict 리터럴과 dict 생성자를 사용하는 것에는 차이가 있습니까?

PyCharm을 사용하여 dict 리터럴 을 변환하는 것이 좋습니다 .

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

에 DICT 생성자 :

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

이러한 다양한 접근 방식이 중요한 방식으로 다릅니 까?

(이 질문을 쓰는 동안 dict()숫자 키를 지정하는 것이 불가능한 것 같습니다. .. d = {1: 'one', 2: 'two'}가능하지만 분명히 dict(1='one' ...)불가능합니다. 다른 것은 없습니까?)

나는 당신이 가장 분명한 차이점을 지적했다고 생각합니다. 그 외에도,

첫 번째는 dict조금 더 빨라야하는 조회 할 필요가 없습니다.

두 번째 외모까지 dict에서 locals()다음 globals()당신이라는 지역 정의에 의해 동작을 전환 할 수 있도록하고, 발견 내장은, dict난 아무데도 생각할 수 있지만 예 :이 때 디버깅 어쩌면 떨어져 좋은 아이디어 일 것입니다

리터럴은 일반 CALL_FUNCTION 대신 최적화 된 BUILD_MAP 및 STORE_MAP opcode를 사용하므로 훨씬 빠릅니다.

> 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

그들은 파이썬 3.2에서 거의 동일하게 보입니다.

gnibbler가 지적했듯이 첫 번째는 조회 할 필요가 없으므로 dict조금 더 빨라야합니다.

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

이 두 가지 접근법은 앞서 언급했듯이 파이썬의 어휘 규칙이 방해하는 경우를 제외하고는 동일한 사전을 생성합니다.

사전 리터럴은 좀 더 분명한 사전이며, 모든 종류의 키를 만들 수 있지만 키 이름을 인용해야합니다. 반면에 어떤 이유로 필요한 경우 키에 변수를 사용할 수 있습니다.

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

dict()생성자 때문에 걸리는 입력 형태의 다양한 당신에게 더 많은 유연성을 제공합니다. 예를 들어, 반복자 쌍을 제공 할 수 있으며이를 키 / 값 쌍으로 취급합니다.

PyCharm이 한 양식을 다른 양식으로 변환하도록 제안하는 이유를 모르겠습니다.

python 3.4 + pycharm의 큰 차이점은 키 수가 256을 초과하면 dict () 생성자가 "구문 오류"메시지를 생성한다는 것입니다.

나는 dict 리터럴을 사용하는 것을 선호합니다.

파이썬 2.7 튜토리얼에서 :

한 쌍의 중괄호는 {} 빈 사전을 작성합니다. 괄호 안에 쉼표로 구분 된 키 : 값 쌍 목록을 배치하면 사전에 초기 키 : 값 쌍이 추가됩니다. 이것은 또한 사전이 출력에 쓰여지는 방식입니다.

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

동안:

dict () 생성자는 튜플로 저장된 키-값 쌍 목록에서 직접 사전을 빌드합니다. 쌍이 패턴을 형성 할 때 목록 이해는 키-값 목록을 간결하게 지정할 수 있습니다.

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

키가 간단한 문자열 인 경우 키워드 인수를 사용하여 쌍을 지정하는 것이 더 쉬운 경우가 있습니다.

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

따라서 {}와 dict ()는 사전을 생성하지만 약간 다른 사전 데이터 초기화 방법을 제공합니다.

dict 리터럴 d = {'one': '1'}이 물건 값을 할당하고 데이터를 보내는 대신 훨씬 더 읽기 쉬운 정의 데이터를 찾습니다 .dict() 생성자 .

반면에 사람들이 dict 리터럴을 잘못 입력하는 것을 보았습니다. d = {'one', '1'} 이 현대 파이썬 2.7 이상에서 세트를 만들 .

그럼에도 불구하고 나는 여전히 리터럴을 사용하는 것을 선호합니다. 왜냐하면 더 읽기 쉽고 개인적인 취향을 생각하기 때문입니다.

dict () 리터럴은 다른 값을 붙여 넣을 때 (파이썬 없음) 환경 변수 목록과 같이 좋습니다. bash 파일이 있다면

FOO='bar'
CABBAGE='good'

dict()리터럴에 쉽게 붙여넣고 주석을 추가 할 수 있습니다 . 또한 반대의 작업을 더 쉽게하고 다른 것으로 복사합니다. 반면 {'FOO': 'bar'}구문 파이썬 및 JSON 꽤 독특합니다. 따라서 json을 많이 사용 {}하면 큰 따옴표와 함께 리터럴 을 사용할 수 있습니다 .

dict 상속 클래스, 추가 메소드가있는 사용자 정의 dict 클래스를 작성하는 dict 리터럴은 없습니다. 이 경우 사용자 정의 dict 클래스 생성자를 사용해야합니다. 예를 들면 다음과 같습니다.

class NestedDict(dict):

    # ... skipped

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

또한 연산자와 일치하는 토큰을 생성자 구문 (예 : 대시 키)에서 사용할 수 없다는 사실을 고려하십시오.

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

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