Python 是否有一个内置功能可以说一个dict a包含另一个dict B？

e、 g.dict

a

包含dict

b1

，因为：

a = { 'name': 'mary', 'age': 56, 'gender': 'female' }
b1 = { 'name': 'mary', 'age': 56 }

但这是错误的，因为键

name

的值不同

b2 = { 'name': 'elizabeth', 'age': 56 }

set（b1.iteritems（））此“短路”。当发现
b2
的第一项不在
a
中时，
all（）
立即终止。还避免了创建临时集的内存开销

>>> a = { 'name': 'mary', 'age': 56, 'gender': 'female' }
>>> b1 = { 'name': 'mary', 'age': 56 }
>>> 
>>> all(a[k]==v for k,v in b1.iteritems())
True
>>> b2 = { 'name': 'elizabeth', 'age': 56 }
>>> all(a[k]==v for k,v in b2.iteritems())
False

如果
b
包含不在
a
中的键，则可以使用此选项

>>> all(a.get(k, object())==v for k,v in b2.iteritems())
False

我将回答词典是否兼容，因此我更改了示例：

>>> test_compat = lambda d1, d2: all(d1[k]==d2[k] for k in set(d1) & set(d2))
>>> a = { 'name': 'mary', 'age': 56, 'gender': 'female' }
>>> b1 = { 'name': 'mary', 'age': 56, 'phone' : '555' }
>>> b2 = { 'name': 'elizabeth', 'age': 56 }
>>> test_compat(a, b1) 
True
>>> test_compat(a, b2)
False
>>> test_compat(b1, a)
True

set（d1）&set（d2）
是两个字典之间所有键的交叉点<代码>所有

将提前退出任何相应的值不匹配

是有一个内置功能。返回字典的视图，其行为非常类似于

集

：

In [1]: a = { 'name': 'mary', 'age': 56, 'gender': 'female' }
   ...: b1 = { 'name': 'mary', 'age': 56 }
   ...: 

In [2]: b1.items() <= a.items()
Out[2]: True

In [3]: b2 = { 'name': 'elizabeth', 'age': 56 }

In [4]: b2.items() <= a.items()
Out[4]: False

而：

In [11]: a.items() <= a.items()
Out[11]: True

---

viewitems（）

比第二快的解决方案快约2倍。

而且它可以在任何dict上工作，即使它包含一些不易损坏的内容，如列表。+1，需要注意的是，当在

a

中找不到键

k

时，这会引发一个异常。作为保护措施和可选性能优化，如果

b1

的键不在a中，我会作为

all（a[k]==v代表k，v在b1中。iteritems（）如果a中的k是正确的，我会更改
a[k]==v
到a中的
k，并且a[k]==v
@digEmAll
具有\u键
不推荐使用。使用
中的
设置（b1.iteritems（））。IsubSet（a.iteritems（））
避免将
a.iteritem（）转换为set@gnibbler，不，它不是：如果您想避免构造两个集合，您应该使用理解：
bset=set（b1.iteritems（））；全部打印（b中的x为a.iteritems（）中的x设置）
。但这可能比使用内置的设置比较慢。。。
In [10]: a = {'a': [1]}
    ...: set(a.items()) <= set(a.items())
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-10-893acb4047c9> in <module>()
      1 a = {'a': [1]}
----> 2 set(a.items()) <= set(a.items())

TypeError: unhashable type: 'list'

In [11]: a.items() <= a.items()
Out[11]: True

In [1]: a = {'a'+str(i): i for i in range(500000)}
   ...: b = a.copy()
   ...: 

In [2]: %timeit set(a.iteritems()) <= set(b.iteritems())
1 loops, best of 3: 810 ms per loop

In [3]: %timeit all(a[k]==v for k,v in b.iteritems())
10 loops, best of 3: 157 ms per loop

In [4]: %timeit all(a.get(k,object())==v for k,v in b.iteritems())
1 loops, best of 3: 237 ms per loop

In [5]: %timeit a.viewitems() <= b.viewitems()
10 loops, best of 3: 80.8 ms per loop

In [6]: def test_compat(d1, d2):
   ...:     return all(d1[k]==d2[k] for k in set(d1) & set(d2))
   ...: 
   ...: def test_compat2(d1, d2):
   ...:     return all(d1[k] == d2[k] for k in d1.viewkeys() & d2.viewkeys())
   ...: 

In [7]: %timeit test_compat(a, b)
1 loops, best of 3: 514 ms per loop

In [8]: %timeit test_compat2(a, b)
1 loops, best of 3: 500 ms per loop