这是一个非常晚的聚会，但如果你有一个kwargs函数:

def foo(a=None, b=None):
    ...

而你的口头语是这样的

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)

但是d_2可能更适合重构foo签名中可能改变的参数名。因为在d_1中它们是字符串。

没有字典文字来创建字典继承类，自定义字典类与额外的方法。在这种情况下，应该使用自定义dict类构造函数，例如:

class NestedDict(dict):

    # ... skipped

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

它们在Python 3.2中看起来基本相同。

正如gnibbler指出的那样，第一个不需要查找字典，这应该会让它更快一点。

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

还要考虑这样一个事实:与运算符匹配的令牌不能在构造函数语法中使用，即dasherized key。

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

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

我想你已经指出了最明显的区别。除此之外，

第一个不需要查找字典，这应该使它稍微快一点

第二个在locals()中查找dict，然后在globals()中查找内置的，所以你可以通过定义一个称为dict的局部来切换行为，例如，尽管我想不出除了调试时可能在任何地方这将是一个好主意

Literal更快，因为它使用优化的BUILD_MAP和STORE_MAP操作码，而不是通用的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