blocks|key|2953652|text|我认为你已经指出了最明显的区别。除此之外，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2953653|第一个不需要查找dict，这应该会使它稍微快一点|offset|length|style|CODE|2953654|第二个方法在locals()中查找dict，然后在globals()中查找，然后查找内置代码，因此您可以通过定义一个名为dict的本地代码来切换行为，尽管我想不出在任何地方这可能是一个好主意，除非是在调试时|2953655|entityMap^0|0|8|4|0|6|8|H|4|P|9|1O|4|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]|$D|U|E|V|F|G]|$D|W|E|X|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$]]

I think you have pointed out the most obvious difference. Apart from that, 

the first doesn't need to lookup <code>dict</code> which should make it a tiny bit faster 

the second looks up <code>dict</code> in <code>locals()</code> and then <code>globals()</code> and the finds the builtin, so you can switch the behaviour by defining a local called <code>dict</code> for example although I can't think of anywhere this would be a good idea apart from maybe when debugging

blocks|key|259931|text|这两种方法生成相同的字典，除非您已经注意到，Python的词法规则会发生冲突。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|259932|字典文字是更明显的字典，您可以创建任何类型的键，但您需要引用键的名称。另一方面，如果出于某些原因需要，您可以使用键的变量：|259933|a+=+"hello"
d+=+{
++++a:+'hi'
++++}|code-block|syntax|javascript|259934|dict()构造函数提供了更大的灵活性，因为它采用的输入形式多种多样。例如，您可以为它提供一个成对的迭代器，它会将它们视为键/值对。|offset|length|style|CODE|259935|我不知道为什么PyCharm会提供将一种表单转换为另一种表单。|259936|entityMap^0|0|0|0|0|6|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

These two approaches produce identical dictionaries, except, as you've noted, where the lexical rules of Python interfere.

Dictionary literals are a little more obviously dictionaries, and you can create any kind of key, but you need to quote the key names. On the other hand, you can use variables for keys if you need to for some reason:

<pre><code>a = "hello"
d = {
 a: 'hi'
 }
</code></pre>

The <code>dict()</code> constructor gives you more flexibility because of the variety of forms of input it takes. For example, you can provide it with an iterator of pairs, and it will treat them as key/value pairs.

I have no idea why PyCharm would offer to convert one form to the other.

blocks|key|2953684|text|它们在Python+3.2上看起来几乎一样。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2953685|正如gnibbler指出的那样，第一个不需要查找dict，这应该会让它更快一点。|offset|length|style|CODE|2953686|>>>+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|code-block|syntax|javascript|2953687|entityMap^0|0|O|4|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

They look pretty much the same on Python 3.2.

As gnibbler pointed out, the first doesn't need to lookup <code>dict</code>, which should make it a tiny bit faster.

<pre><code>&gt;&gt;&gt; def literal():
... d = {'one': 1, 'two': 2}
...
&gt;&gt;&gt; def constructor():
... d = dict(one='1', two='2')
...
&gt;&gt;&gt; import dis
&gt;&gt;&gt; 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
&gt;&gt;&gt; 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
</code></pre>

blocks|key|262204|text|来自python+2.7教程：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|262205|262206|一对大括号创建一个空字典：{}。将以逗号分隔的键:值对列表放在大括号中会将初始键:值对添加到字典中；这也是字典在输出中写入的方式。|blockquote|262207|262208|262209|tel+=+{'jack':+4098,+'sape':+4139}
data+=+{k:v+for+k,v+in+zip(xrange(10),+xrange(10,20))}|code-block|syntax|javascript|262210|而：|262211|262212|+()构造函数直接从存储为元组的键值对列表构建字典。当这些对形成模式时，列表理解可以紧凑地指定键值列表。|262213|262214|262215|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)))|262216|262217|当密钥是简单的字符串时，有时使用关键字参数指定对更容易：|262218|262219|262220|dict(sape=4139,+guido=4127,+jack=4098)
>>>++{'sape':+4139,+'jack':4098,+'guido':+4127}|262221|因此，{}和dict()都生成字典，但是提供了一些不同方法来初始化字典数据。|262222|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|18|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1B|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1C|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|P|3|Q|5|E|7|1E|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|T|3|U|5|J|7|1H|8|@]|9|@]|A|$K|L]]|$1|V|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|W|3|X|5|E|7|1J|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|10|3|11|5|J|7|1M|8|@]|9|@]|A|$K|L]]|$1|12|3|13|5|6|7|1N|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|15|$]]

From python 2.7 tutorial:

<blockquote>
 A pair of braces creates an empty
 dictionary: {}. Placing a
 comma-separated list of key:value
 pairs within the braces adds initial
 key:value pairs to the dictionary;
 this is also the way dictionaries are
 written on output.
</blockquote>

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

While:

<blockquote>
 The dict() constructor builds
 dictionaries directly from lists of
 key-value pairs stored as tuples. When
 the pairs form a pattern, list
 comprehensions can compactly specify
 the key-value list.
</blockquote>

<pre><code>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)))
</code></pre>

<blockquote>
 When the keys are simple strings, it
 is sometimes easier to specify pairs
 using keyword arguments:
</blockquote>

<pre><code>dict(sape=4139, guido=4127, jack=4098)
&gt;&gt;&gt; {'sape': 4139, 'jack':4098, 'guido': 4127}
</code></pre>

So both {} and dict() produce dictionary but provide a bit different ways of dictionary data initialization.

blocks|key|3167528|text|文本要快得多，因为它使用优化的BUILD_MAP和STORE_MAP操作码，而不是通用的CALL_FUNCTION：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3167529|>+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|code-block|syntax|javascript|3167530|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Literal is much faster, since it uses optimized BUILD_MAP and STORE_MAP opcodes rather than generic CALL_FUNCTION:

<pre><code>&gt; 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

&gt; 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

&gt; 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

&gt; 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
</code></pre>

blocks|key|263994|text|我发现dict文本d+=+{'one':+'1'}更具可读性，它是您定义数据的方式，而不是为事物赋值并将它们发送到dict()构造函数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|263995|另一方面，我看到人们错误地将dict字面输入为d+=+{'one',+'1'}，这在现代python+2.7%2B中会创建一个集合。|263996|尽管如此，我仍然倾向于始终使用set字面量，因为我认为它更具可读性，我想是个人偏好。|263997|entityMap^0|9|G|1L|6|0|N|G|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|T|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|K|$]]

I find the dict literal <code>d = {'one': '1'}</code> to be much more readable, your defining data, rather than assigning things values and sending them to the <code>dict()</code> constructor.

On the other hand i have seen people mistype the dict literal as <code>d = {'one', '1'}</code> which in modern python 2.7+ will create a set.

Despite this i still prefer to all-ways use the set literal because i think its more readable, personal preference i suppose.

blocks|key|3167587|text|与python3.4%2B+pycharm的一个很大的区别是，如果键数超过256，dict()构造函数就会产生“语法错误”消息。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3167588|我现在更喜欢使用dict字面。|3167589|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

One big difference with python 3.4 + pycharm is that the dict() constructor
produces a "syntax error" message if the number of keys exceeds 256.

I prefer using the dict literal now.

blocks|key|3167599|text|当你从其他东西(非python)，例如环境变量列表中复制粘贴值时，dict()字面量很有用。如果你有一个bash文件，比如|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3167600|FOO='bar'
CABBAGE='good'|code-block|syntax|javascript|3167601|您可以轻松地将其粘贴到dict()文本中并添加注释。这也使得相反的操作变得更容易，复制到其他东西中。而{'FOO':+'bar'}语法是python和json所独有的。因此，如果您经常使用json，您可能希望使用带双引号的{}文字。|offset|length|style|CODE|3167602|entityMap^0|0|0|B|6|1F|E|33|2|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

the dict() literal is nice when you are copy pasting values from something else (none python)
For example a list of environment variables.
if you had a bash file, say 

<pre><code>FOO='bar'
CABBAGE='good'
</code></pre>

you can easily paste then into a <code>dict()</code> literal and add comments. It also makes it easier to do the opposite, copy into something else. Whereas the <code>{'FOO': 'bar'}</code> syntax is pretty unique to python and json. So if you use json a lot, you might want to use <code>{}</code> literals with double quotes.

blocks|key|264032|text|还要考虑与运算符匹配的令牌不能在构造函数语法中使用的事实，即dasherized键。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|264033|>>>+dict(foo-bar=1)
File+"<stdin>",+line+1
SyntaxError:+keyword+can't+be+an+expression

>>>+{'foo-bar':+1}
{'foo-bar':+1}|code-block|syntax|javascript|264034|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Also consider the fact that tokens that match for operators can't be used in the constructor syntax, i.e. dasherized keys.

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

&gt;&gt;&gt; {'foo-bar': 1}
{'foo-bar': 1}
</code></pre>

blocks|key|2953800|text|没有dict文字来创建dict继承的类，带有其他方法的自定义dict类。在这种情况下，应该使用自定义dict类构造函数，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2953801|class+NestedDict(dict):

++++#+...+skipped

state_type_map+=+NestedDict(**{
++++'owns':+'Another',
++++'uses':+'Another',
})|code-block|syntax|javascript|2953802|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

There is no dict literal to create dict-inherited classes, custom dict classes with additional methods. In such case custom dict class constructor should be used, for example:

<pre><code>class NestedDict(dict):

 # ... skipped

state_type_map = NestedDict(**{
 'owns': 'Another',
 'uses': 'Another',
})
</code></pre>

blocks|key|2953825|text|很晚才来这里，但是如果你有一个kwargs函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2953826|def+foo(a=None,+b=None):
++++...|code-block|syntax|javascript|2953827|你的dict就像这样：|offset|length|style|CODE|2953828|d_1+=+{+'a':+1,+'b':+2+}
d_2+=+dict(a=1,+b=2)

#+This+works
foo(**d_1)

#+And+this+as+well
foo(**d_2)|2953829|但是，d_2可能更适合重构可能在foo签名中更改的参数名称。因为在d_1中它们是字符串。|2953830|entityMap^0|0|0|2|4|0|0|3|3|G|3|X|3|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@$I|Z|J|10|K|L]|$I|11|J|12|K|L]|$I|13|J|14|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|R|$]]

Super late to the party here, but if you have a kwargs function:
<pre><code>def foo(a=None, b=None):
 ...
</code></pre>
And your splatting a <code>dict</code> like so:
<pre class="lang-py prettyprint-override"><code>d_1 = { 'a': 1, 'b': 2 }
d_2 = dict(a=1, b=2)

# This works
foo(**d_1)

# And this as well
foo(**d_2)
</code></pre>
But <code>d_2</code> may be better suited for refactoring argument names that may change in your <code>foo</code> signature. Since in <code>d_1</code> they are strings.

Using PyCharm, I noticed it offers to convert a dict literal:

<pre><code>d = {
 'one': '1',
 'two': '2',
}
</code></pre>



into a dict constructor:

<pre><code>d = dict(one='1', two='2')
</code></pre>



Do these different approaches differ in some significant way?

(While writing this question I noticed that using <code>dict()</code> it seems impossible to specify a numeric key .. <code>d = {1: 'one', 2: 'two'}</code> is possible, but, obviously, <code>dict(1='one' ...)</code> is not. Anything else?)

Is there a difference between using a dict literal and a dict constructor?

Python

在使用PyCharm时，我注意到它提供了转换字典文字的功能d = {    'one': '1',    'two': '2',}​​到一个字典构造函数中d = dict(one='1', two='2')​​这些不同的方法在一些重要方面有区别吗？(在写这个问题时，我注意到使用dict()似乎不可能指定一个数字键。d ...

问使用dict字面量和dict构造函数有区别吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用dict字面量和dict构造函数有区别吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用dict字面量和dict构造函数有区别吗？
EN