前言：

　　之前博客说过，一个字典是否包含在另一个字典中，可以将字典转化为set，然后使用他其中的issubset来判断是否存在包含关系。详细可参考：https://www.cnblogs.com/dflblog/p/11944980.html

　　也就是已知一个dict，比如为a = {"a":1},另一个dict比如为b = {"a":1,"b":2},想要一个结果判断a是否在与b中，将a转化为set，b转化为set，然后用a的issubset来确认是否返回Ture。

背景：

　　这里会存在一个问题，因为set是一个无序且不重复的元素集合。元素为不可变对象！！！

　　是什么意思，也就是如上例，b的数据类型为这个样子的话：

　　b = {"a":{"aa":11},"b":[1,2,3],"c":(1,2,3)}

　　那么就直接异常了。

代码先跑起来：

　　　　

d = {"a":{"aa":11},"b":[1,2,3],"c":(1,2,3)}
dd = set(d.items())

结果直接抛出异常TypeError: unhashable type: 'dict'。

告诉我们类型错了，dict是一个可变对象，说到这里又开始上篇的问题了。如果都是不可变对象，上篇是可以使用的

但如果存在可变对象，没办法转化成set类型， 这个怎么处理？？？

没办法，只能自己一个一个处理了。给打开放一个刚设计的一个例子。

仔细看的人会发现还有问题存在～～嘻嘻嘻。

a = {"a":{"aa":11}}
a1 = {"d":"d"}
b = {"a":{"aa":11},"b":[1,2,3],"c":(1,2,3)}
class assertDictIn:
    def __init__(self):
        ## 初始化set类型
        self.result = set()

    def _getKeys(self,data):

        ## 等于dict类型
        if type(data) == dict:
            ## 循环走起
            for key,value in data.items():

                ## 若循环的value值为list类型，继续调用
                ## 各个为空处理
                if type(value) == list:
                    if value == []:
                        self.result.add(key)
                        self.result.add(value)
                    else:
                        self._getKeys(value)

                if type(value) == dict:
                    ## 如果dict为空处理
                    if value == {}:
                        self.result.add(key)
                        self.result.add(value)
                    else:
                        self._getKeys(value)
                ## 同list
                if type(value) == tuple:
                    if value == ():
                        self.result.add(key)
                        self.result.add(value)
                    else:
                        self._getKeys(value)
                    self._getKeys(value)

                ## 如果循环的value类型为基本类型，直接添加
                if type(value) in (str,int,float,set):
                    self.result.add(key)
                    self.result.add(value)

        ## 若传入类型为list或者tuple
        if type(data) in (list,tuple):
            ## 依旧循环走起
            for value in data:
                ## list时继续调用
                if type(value) == list:
                    self._getKeys(value)

                ## dict时也继续调用
                if type(value) == dict:
                    self._getKeys(value)

                ## tuple时继续调用
                if type(value) == tuple:
                    self._getKeys(value)

                ## 若为这些类型，直接添加
                if type(value) in (str, int, float, set):
                    self.result.add(value)

        ## 若传入为set类型，直接添加
        if type(data) is set:
            for value in data:
                self.result.add(value)

        return self.result

    def checkIn(self,first:dict,second:dict):

        ## 非字典处理，直接raise
        if type(first) != dict or type(second) != dict:
            raise Exception("内部目前仅支持dict类型判断")

        ## 赋值第一个参数
        fir = self._getKeys(first)
        ## 重置一下结果
        self._clear()
        ## 赋值第一个参数
        sec = self._getKeys(second)
        ## 也重置一下吧
        self._clear()

        ## 断言
        if fir.issubset(sec):
            return True
        else:
            return False

    def _clear(self):
        self.result = set()
asser = assertDictIn()
print(asser.checkIn(a,b))
print(asser.checkIn(a1,b))

结果为：

Ture

False