Python3: Comparaison d'une paire spécifique de clés et de valeurs entre deux dictionnaires

Question

EDIT : En cas de besoin de contexte, j'essaie en fait de généraliser ceci pour fonctionner dans des boucles for et while, où je voudrais quelque chose comme ceci pour fonctionner

if dictA[certainkey:'certainvalue'] == dictB[certainkey:'certainvalue']:
    return True

Question Originale : Existe-t-il un moyen de comparer les clés identiques de deux dictionnaires en Python 3 pour voir si elles ont les mêmes valeurs ?

Par exemple, disons que

dictA = {1:'Y', 2:'E', 3:'E'}
dictB = {1:'Y', 2:'A', 3:'W'}

Je veux que le programme me renvoie une valeur True si un certain ensemble de paires clé-valeur dans dictA correspond au même ensemble de paires clé-valeur dans dictB. Dans ce cas, la clé 1 est associée à la valeur 'Y' dans les deux dictA et dictB. Je ne savais pas s'il y avait de bonnes façons de le faire, alors j'ai naturellement essayé

print(dictA[1:'Y'] == dictB[1:'Y'])

en espérant obtenir un True imprimé. Comme cela n'a pas fonctionné (et je ne connais pas encore assez les dictionnaires), je me demandais s'il existait d'autres façons de le faire. Merci !

Answer 1

Vous pourriez fusionner les dictionnaires sur des paires égales (clé, valeur) puis effectuer des vérifications ultérieures contre le dictionnaire fusionné.

>>> dictA = {1:'Y', 2:'E', 3:'E'}
>>> dictB = {1:'Y', 2:'A', 3:'W'}
>>> 
>>> merged = dict(dictA.items() & dictB.items())
>>> merged
{1: 'Y'}
>>> 
>>> 1 in merged
True
>>> 3 in merged
False

La création de merged est facile car les valeurs de retour de dict.keys, dict.values et dict.items prennent en charge l'interface set en ce qui concerne les opérations telles que l'union, l'intersection, etc.

Astuce : nécessite des valeurs hashables dans vos dictionnaires. Si vous avez des valeurs non hashables, créez merged via

>>> b_items = dictB.items()
>>> merged = dict(pair for pair in dictA.items() if pair in b_items)

Answer 2

Tout d'abord, obtenez les clés correspondantes entre les dictionnaires, puis utilisez une compréhension de dictionnaire pour comparer chacune de ces clés correspondantes.

matching_keys = dictA.keys() & dictB.keys()

>>> {k: dictA[k] == dictB[k] for k in matching_keys}
{1: True, 2: False, 3: False}

Pour simplement obtenir les clés où les valeurs correspondent, utilisez une compréhension de liste:

keys_with_matching_values = [k for k in matching_keys if dictA[k] == dictB[k]]
# Or: [k for k in dictA if k in dictA and dictA[k] == dictB[k]]

>>> keys_with_matching_values
[1]

Remarquez que les deux méthodes sont efficaces en termes de mémoire, car elles n'enregistrent pas inutilement les valeurs correspondantes dans les dictionnaires.

Answer 3

pour clé dans dictA
    i = 0
    if clé in dictA:
        mot = dictA[0][i]
        if dictA[0][i] == dictB[0][0]:
            print(mot + 'correspond à dict 0')
        if dictA[0][i] == dictB[0][1]:
            print(mot + 'correspond à dict 1')
        if dictA[0][i] == dictB[0][2]:
            print(mot + 'correspond à dict 2')
            i += 1

J'ai écrit ceci très rapidement dans la navette depuis le travail, c'est bâclé et je pourrais faire une boucle pour dictB. Mais cela devrait fonctionner pour automatiser le processus de recherche du mot. (Mais cela peut ne pas fonctionner, car je l'ai écrit rapidement)

Answer 4

Vous pourriez simplement faire ce que vous avez mentionné dans une compréhension de liste

print([True if dicta[k] == dictb[k] else False for k in dicta])
# [True, False, False]

Étendu

for k in dicta:
    if dicta[k] == dictb[k]:
        print(True)
    else:
        print(False)