Python: verifique se um dicionário é um subconjunto de outro dicionário maior

Estou tentando escrever um método de filtro personalizado que usa um número arbitrário de kwargs e retorna uma lista contendo os elementos de uma lista do tipo banco de dados que contém esses kwargs .

Por exemplo, suponha d1 = {'a':'2', 'b':'3'}e d2= a mesma coisa. d1 == d2resulta em Verdadeiro. Mas suponha d2= a mesma coisa mais um monte de outras coisas. Meu método precisa ser capaz de dizer se d1 em d2 , mas Python não pode fazer isso com dicionários.

Contexto:

Eu tenho uma classe Word, e cada objeto tem propriedades como word, definition, part_of_speeche assim por diante. Quero ser capaz de chamar um método de filtro na lista principal dessas palavras, como Word.objects.filter(word='jump', part_of_speech='verb-intransitive'). Não consigo descobrir como gerenciar essas chaves e valores ao mesmo tempo. Mas isso poderia ter uma funcionalidade maior fora deste contexto para outras pessoas.

Converta em pares de itens e verifique se há contenção.

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

A otimização é deixada como um exercício para o leitor.

No Python 3, você pode usar dict.items()para obter uma visão semelhante a um conjunto dos itens de dicionário. Você pode então usar o <=operador para testar se uma visualização é um "subconjunto" da outra:

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

No Python 2.7, use o dict.viewitems()para fazer o mesmo:

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

No Python 2.6 e abaixo, você precisará de uma solução diferente, como usar all():

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

Nota para as pessoas que precisam disso para testes de unidade: também há um assertDictContainsSubset()método na TestCaseclasse do Python .

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

No entanto, ele está obsoleto no 3.2, não sei por que, talvez haja um substituto para ele.

para chaves e valores, verifique o uso: set(d1.items()).issubset(set(d2.items()))

se você precisar verificar apenas as chaves: set(d1).issubset(set(d2))

Para ser completo, você também pode fazer isso:

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

No entanto, eu não faço qualquer reclamação sobre velocidade (ou falta dela) ou legibilidade (ou falta dela).

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

Minha função com o mesmo propósito, fazendo isso recursivamente:

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

Em seu exemplo, dictMatch(d1, d2)deve retornar True mesmo se d2 tiver outras coisas nele, além de se aplicar também a níveis inferiores:

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

dictMatch(d1, d2)   # True

Notas: Pode haver uma solução ainda melhor que evite a if type(pvalue) is dictcláusula e se aplique a uma gama ainda maior de casos (como listas de hashes, etc.). Além disso, a recursão não é limitada aqui, portanto, use por sua própria conta e risco. ;)

Aqui está uma solução que também recorre adequadamente às listas e conjuntos contidos no dicionário. Você também pode usar isso para listas contendo dictos 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

Esse problema aparentemente simples me custa algumas horas em pesquisas para encontrar uma solução 100% confiável, então documentei o que encontrei nesta resposta.

1. Falando de forma "pitônica", small_dict <= big_dictseria a forma mais intuitiva, mas uma pena que não funcionará . {'a': 1} < {'a': 1, 'b': 2}aparentemente funciona no Python 2, mas não é confiável porque a documentação oficial o menciona explicitamente. Vá pesquisar "Resultados diferentes da igualdade são resolvidos de forma consistente, mas não são definidos de outra forma." em esta seção . Sem mencionar que a comparação de 2 dictos em Python 3 resulta em uma exceção TypeError.

2. A segunda coisa mais intuitiva é apenas small.viewitems() <= big.viewitems()para Python 2.7 e small.items() <= big.items()para Python 3. Mas há uma ressalva: é potencialmente bugado . Se o seu programa puder ser usado em Python <= 2.6, ele d1.items() <= d2.items()está, na verdade, comparando 2 listas de tuplas, sem uma ordem específica, então o resultado final não será confiável e se tornará um bug desagradável em seu programa. Não estou interessado em escrever outra implementação para Python <= 2.6, mas ainda não me sinto confortável se meu código vem com um bug conhecido (mesmo se estiver em uma plataforma sem suporte). Portanto, abandono essa abordagem.

3. Eu me sento com a resposta de @blubberdiblub (o crédito vai para ele):

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

   Vale ressaltar que, essa resposta depende do ==comportamento entre dictos, que está claramente definido em documento oficial, portanto deve funcionar em todas as versões do Python . Vá pesquisar:

   • "Os dicionários são comparados de forma igual se e somente se tiverem os mesmos pares (chave, valor)." é a última frase nesta página
   • "Mapeamentos (instâncias de dict) são comparados iguais se e somente se eles têm pares iguais (chave, valor). A comparação de igualdade das chaves e elementos impõe reflexividade." em esta página

Aqui está uma solução recursiva geral para o problema fornecido:

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: O código original iria falhar em certos casos, os créditos pela correção vão para @olivier-melançon

Se você não se importa de usar pydash , is_matchexiste um que faz exatamente isso:

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

Eu sei que esta pergunta é antiga, mas aqui está minha solução para verificar se um dicionário aninhado faz parte de outro dicionário aninhado. A solução é 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 função funciona para valores não hashable. Também acho que é claro e fácil de ler.

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

Uma implementação recursiva curta que funciona para dicionários aninhados:

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

Isso consumirá os dictos a e b. Se alguém souber de uma boa maneira de evitar isso sem recorrer a soluções parcialmente iterativas como em outras respostas, por favor me diga. Eu precisaria de uma maneira de dividir um dicionário em cabeçalho e cauda com base em uma chave.

Este código é mais útil como um exercício de programação e provavelmente é muito mais lento do que outras soluções aqui que misturam recursão e iteração. A solução do @Nutcracker é muito boa para dicionários aninhados.

Use este objeto wrapper que fornece comparação parcial e diferenças legais:

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