Python: compruebe si un diccionario es un subconjunto de otro diccionario más grande

Estoy tratando de escribir un método de filtro personalizado que toma un número arbitrario de kwargs y devuelve una lista que contiene los elementos de una lista similar a una base de datos que contiene esos kwargs .

Por ejemplo, suponga que d1 = {'a':'2', 'b':'3'}y d2= lo mismo. d1 == d2resulta en Verdadero. Pero supongamos d2= lo mismo más un montón de otras cosas. Mi método necesita poder decir si d1 en d2 , pero Python no puede hacer eso con diccionarios.

Contexto:

Tengo una clase de palabras, y cada objeto tiene propiedades como word, definition, part_of_speech, y así sucesivamente. Quiero poder llamar a un método de filtro en la lista principal de estas palabras, como Word.objects.filter(word='jump', part_of_speech='verb-intransitive'). No puedo entender cómo administrar estas claves y valores al mismo tiempo. Pero esto podría tener una mayor funcionalidad fuera de este contexto para otras personas.

Convierta a pares de elementos y compruebe la contención.

all(item in superset.items() for item in subset.items())

La optimización se deja como ejercicio para el lector.

En Python 3, puede usar dict.items()para obtener una vista similar a un conjunto de los elementos de dict. Luego puede usar el <=operador para probar si una vista es un "subconjunto" de la otra:

d1.items() <= d2.items()

En Python 2.7, use dict.viewitems()para hacer lo mismo:

d1.viewitems() <= d2.viewitems()

En Python 2.6 y versiones anteriores, necesitará una solución diferente, como usar all():

all(key in d2 and d2[key] == d1[key] for key in d1)

Nota para las personas que necesitan esto para las pruebas unitarias: también hay un assertDictContainsSubset()método en la TestCaseclase de Python .

http://docs.python.org/2/library/unittest.html?highlight=assertdictcontainssubset#unittest.TestCase.assertDictContainsSubset

Sin embargo, está obsoleto en 3.2, no estoy seguro de por qué, tal vez haya un reemplazo para él.

para claves y valores, verifique el uso: set(d1.items()).issubset(set(d2.items()))

si necesita verificar solo las claves: set(d1).issubset(set(d2))

Para completar, también puede hacer esto:

def is_subdict(small, big):
    return dict(big, **small) == big

Sin embargo, no hago ningún reclamo con respecto a la velocidad (o falta de ella) o legibilidad (o falta de ella).

>>> d1 = {'a':'2', 'b':'3'}
>>> d2 = {'a':'2', 'b':'3','c':'4'}
>>> all((k in d2 and d2[k]==v) for k,v in d1.iteritems())
True

contexto:

>>> d1 = {'a':'2', 'b':'3'}
>>> d2 = {'a':'2', 'b':'3','c':'4'}
>>> list(d1.iteritems())
[('a', '2'), ('b', '3')]
>>> [(k,v) for k,v in d1.iteritems()]
[('a', '2'), ('b', '3')]
>>> k,v = ('a','2')
>>> k
'a'
>>> v
'2'
>>> k in d2
True
>>> d2[k]
'2'
>>> k in d2 and d2[k]==v
True
>>> [(k in d2 and d2[k]==v) for k,v in d1.iteritems()]
[True, True]
>>> ((k in d2 and d2[k]==v) for k,v in d1.iteritems())
<generator object <genexpr> at 0x02A9D2B0>
>>> ((k in d2 and d2[k]==v) for k,v in d1.iteritems()).next()
True
>>> all((k in d2 and d2[k]==v) for k,v in d1.iteritems())
True
>>>

Mi función para el mismo propósito, haciendo esto de forma recursiva:

def dictMatch(patn, real):
    """does real dict match pattern?"""
    try:
        for pkey, pvalue in patn.iteritems():
            if type(pvalue) is dict:
                result = dictMatch(pvalue, real[pkey])
                assert result
            else:
                assert real[pkey] == pvalue
                result = True
    except (AssertionError, KeyError):
        result = False
    return result

En su ejemplo, dictMatch(d1, d2)debería devolver True incluso si d2 tiene otras cosas, además de que también se aplica a niveles inferiores:

d1 = {'a':'2', 'b':{3: 'iii'}}
d2 = {'a':'2', 'b':{3: 'iii', 4: 'iv'},'c':'4'}

dictMatch(d1, d2)   # True

Notas: Podría haber una solución aún mejor que evite la if type(pvalue) is dictcláusula y se aplique a una gama aún más amplia de casos (como listas de hashes, etc.). Además, la recursividad no está limitada aquí, así que úsala bajo tu propio riesgo. ;)

Aquí hay una solución que también se repite correctamente en listas y conjuntos contenidos en el diccionario. También puede usar esto para listas que contengan dictados, etc.

def is_subset(subset, superset):
    if isinstance(subset, dict):
        return all(key in superset and is_subset(val, superset[key]) for key, val in subset.items())

    if isinstance(subset, list) or isinstance(subset, set):
        return all(any(is_subset(subitem, superitem) for superitem in superset) for subitem in subset)

    # assume that subset is a plain value if none of the above match
    return subset == superset

Este problema aparentemente sencillo me cuesta un par de horas de investigación para encontrar una solución 100% confiable, así que documenté lo que encontré en esta respuesta.

1. Hablando con "Pythonic-ally", small_dict <= big_dictsería la forma más intuitiva, pero es una lástima que no funcione . {'a': 1} < {'a': 1, 'b': 2}aparentemente funciona en Python 2, pero no es confiable porque la documentación oficial lo menciona explícitamente. Vaya a la búsqueda "Los resultados distintos de la igualdad se resuelven de forma coherente, pero no se definen de otra manera". en esta sección . Sin mencionar que comparar 2 dictados en Python 3 da como resultado una excepción TypeError.

2. La segunda cosa más intuitiva es solo small.viewitems() <= big.viewitems()para Python 2.7 y small.items() <= big.items()para Python 3. Pero hay una advertencia: es potencialmente defectuoso . Si su programa podría potencialmente usarse en Python <= 2.6, en d1.items() <= d2.items()realidad está comparando 2 listas de tuplas, sin un orden particular, por lo que el resultado final no será confiable y se convertirá en un error desagradable en su programa. No estoy interesado en escribir otra implementación para Python <= 2.6, pero todavía no me siento cómodo con que mi código tenga un error conocido (incluso si está en una plataforma no compatible). De modo que abandono este enfoque.

3. Me establezco con la respuesta de @blubberdiblub (el crédito es para él):

   def is_subdict(small, big): return dict(big, **small) == big

   Vale la pena señalar que esta respuesta se basa en el ==comportamiento entre dictados, que está claramente definido en el documento oficial, por lo que debería funcionar en todas las versiones de Python . Ir a buscar:

   • "Los diccionarios se comparan igual si y solo si tienen los mismos pares (clave, valor)". es la última oración de esta página
   • "Las asignaciones (instancias de dict) se comparan igual si y solo si tienen pares (clave, valor) iguales. La comparación de igualdad de las claves y los elementos refuerza la reflexividad". en esta pagina

Aquí hay una solución recursiva general para el problema dado:

import traceback
import unittest

def is_subset(superset, subset):
    for key, value in subset.items():
        if key not in superset:
            return False

        if isinstance(value, dict):
            if not is_subset(superset[key], value):
                return False

        elif isinstance(value, str):
            if value not in superset[key]:
                return False

        elif isinstance(value, list):
            if not set(value) <= set(superset[key]):
                return False
        elif isinstance(value, set):
            if not value <= superset[key]:
                return False

        else:
            if not value == superset[key]:
                return False

    return True


class Foo(unittest.TestCase):

    def setUp(self):
        self.dct = {
            'a': 'hello world',
            'b': 12345,
            'c': 1.2345,
            'd': [1, 2, 3, 4, 5],
            'e': {1, 2, 3, 4, 5},
            'f': {
                'a': 'hello world',
                'b': 12345,
                'c': 1.2345,
                'd': [1, 2, 3, 4, 5],
                'e': {1, 2, 3, 4, 5},
                'g': False,
                'h': None
            },
            'g': False,
            'h': None,
            'question': 'mcve',
            'metadata': {}
        }

    def tearDown(self):
        pass

    def check_true(self, superset, subset):
        return self.assertEqual(is_subset(superset, subset), True)

    def check_false(self, superset, subset):
        return self.assertEqual(is_subset(superset, subset), False)

    def test_simple_cases(self):
        self.check_true(self.dct, {'a': 'hello world'})
        self.check_true(self.dct, {'b': 12345})
        self.check_true(self.dct, {'c': 1.2345})
        self.check_true(self.dct, {'d': [1, 2, 3, 4, 5]})
        self.check_true(self.dct, {'e': {1, 2, 3, 4, 5}})
        self.check_true(self.dct, {'f': {
            'a': 'hello world',
            'b': 12345,
            'c': 1.2345,
            'd': [1, 2, 3, 4, 5],
            'e': {1, 2, 3, 4, 5},
        }})
        self.check_true(self.dct, {'g': False})
        self.check_true(self.dct, {'h': None})

    def test_tricky_cases(self):
        self.check_true(self.dct, {'a': 'hello'})
        self.check_true(self.dct, {'d': [1, 2, 3]})
        self.check_true(self.dct, {'e': {3, 4}})
        self.check_true(self.dct, {'f': {
            'a': 'hello world',
            'h': None
        }})
        self.check_false(
            self.dct, {'question': 'mcve', 'metadata': {'author': 'BPL'}})
        self.check_true(
            self.dct, {'question': 'mcve', 'metadata': {}})
        self.check_false(
            self.dct, {'question1': 'mcve', 'metadata': {}})

if __name__ == "__main__":
    unittest.main()

NOTA: El código original fallaría en ciertos casos, los créditos por la reparación van a @ olivier-melançon

Si no les importa usar pydash existe is_matchallí, lo que hace exactamente eso:

import pydash

a = {1:2, 3:4, 5:{6:7}}
b = {3:4.0, 5:{6:8}}
c = {3:4.0, 5:{6:7}}

pydash.predicates.is_match(a, b) # False
pydash.predicates.is_match(a, c) # True

Sé que esta pregunta es antigua, pero aquí está mi solución para verificar si un diccionario anidado es parte de otro diccionario anidado. La solución es recursiva.

def compare_dicts(a, b):
    for key, value in a.items():
        if key in b:
            if isinstance(a[key], dict):
                if not compare_dicts(a[key], b[key]):
                    return False
            elif value != b[key]:
                return False
        else:
            return False
    return True

Esta función funciona para valores no hash. También creo que es claro y fácil de leer.

def isSubDict(subDict,dictionary):
    for key in subDict.keys():
        if (not key in dictionary) or (not subDict[key] == dictionary[key]):
            return False
    return True

In [126]: isSubDict({1:2},{3:4})
Out[126]: False

In [127]: isSubDict({1:2},{1:2,3:4})
Out[127]: True

In [128]: isSubDict({1:{2:3}},{1:{2:3},3:4})
Out[128]: True

In [129]: isSubDict({1:{2:3}},{1:{2:4},3:4})
Out[129]: False

Una implementación recursiva corta que funciona para diccionarios anidados:

def compare_dicts(a,b):
    if not a: return True
    if isinstance(a, dict):
        key, val = a.popitem()
        return isinstance(b, dict) and key in b and compare_dicts(val, b.pop(key)) and compare_dicts(a, b)
    return a == b

Esto consumirá los dictados ayb. Si alguien conoce una buena manera de evitar eso sin recurrir a soluciones parcialmente iterativas como en otras respuestas, dímelo. Necesitaría una forma de dividir un dictado en cabeza y cola según una clave.

Este código es más útil como ejercicio de programación, y probablemente sea mucho más lento que otras soluciones aquí que mezclan recursividad e iteración. La solución de @ Nutcracker es bastante buena para los diccionarios anidados.

Utilice este objeto contenedor que proporciona una comparación parcial y diferencias agradables:

class DictMatch(dict):
    """ Partial match of a dictionary to another one """
    def __eq__(self, other: dict):
        assert isinstance(other, dict)
        return all(other[name] == value for name, value in self.items())

actual_name = {'praenomen': 'Gaius', 'nomen': 'Julius', 'cognomen': 'Caesar'}
expected_name = DictMatch({'praenomen': 'Gaius'})  # partial match
assert expected_name == actual_name  # True