Сравните два словаря и распечатайте пропущенные или не найденные совпадения

Question

Я новичок в Python и действительно хотел бы получить направление здесь.

У меня есть два почти идентичных словаря - First_Dict и Second_Dict

First_Dict = {"Texas": ["San Antonio", "Austin", "Houston", "Dallas"], 
         "California": ["San Diego", "Los Angeles", "San Francisco"],
        "Florida": ["Miami", "Orlando", "Jacksonville", "Naples"], 
         "Arizona": ["Phoenix", "Tucson"]}


Second_Dict = {"Texas": ["San Antonio, Austin, Houston"],
           "California": ["San Diego, Los Angeles, San Francisco"],
           "Florida": ["Miami", "Orlando", "Jacksonville"], "Illinois": 
          ["Chicago", "Naperville"]}

Цель: мне нужно сравнить их в следующем потоке:

Compare keys
    if key match
        compare values
            if all values match
                break
            else:
                print the key and the corresponding missing value/s.
                    "Missing value/s on key "Florida" in the Second_Dict"
                        "Naples"

    if keys NOT match or missing
        print the unmatching/missing key and corresponding value/s.
            "Missing key and value/s on First_Dict"
                Illinois
                    Chicago
                    Naperville

            "Missing key and value/s on Second_Dict"
                Arizona
                    Phoenix
                    Tucson

Мой код пока не очень :) Извините, я все еще учусь.

for key, value in First_Dict.items() and Second_Dict.items():
    if key in First_Dict.keys() == Second_Dict.keys():
       for value in First_Dict.value() and Second_Dict.value :
          if value in First_Dict.value() == Second_Dict.value():
              break
          else:
              print(value)

Answer 1

Я предполагаю, что вы хотите знать отличия не только для первого словаря от второго, но и наоборот. Для меня хорошим способом является разделение элемента управления по следующим шагам:

1. Поиск общих ключей для обоих словарей.
2. С помощью общих ключей вычисляются различия значений в обоих словарях.
3. Укажите недостающие ключи с относительными значениями.

Возможный код:

#Step 1
#Determination of common keys 
first_keys = first_Dict.keys() #retrieve keys of the dictionary
second_keys = second_Dict.keys()
common_keys = [key for key in first_keys if key in second_keys]

#Step 2
#so now for common keys we look for differences in value and printing them
for common in common_keys:
  townsA = first_Dict[common]
  townsB = second_Dict[common]

  #with the first statement determine the cities that are in the second
  #dictionary but not in first one.
  #with the second the opposite 
  missingOnFirst = [town for town in townsB if town not in townsA]
  missingOnSecond = [town for town in townsA if town not in townsB]

  if missingOnFirst:
    print("Missing on {0} in first dictionary: \n\t{1}".format(common,"\n\t".join(missingOnFirst)))
  if missingOnSecond:
    print("Missing on {0} in second dictionary: \n\t{1}".format(common,"\n\t".join(missingOnSecond)))

#Step 3
#printing the missing keys:
#on First dictionary
print("\n")
print("Missing key and value/s on first dictionary")
for key in second_keys:
  if key not in common_keys:
    print("{0}:\n\t{1}".format(key,"\n\t".join(second_Dict[key])))
#on Second dictionary
print("Missing key and value/s on second dictionary")
for key in first_keys:
  if key not in common_keys:
    print("{0}:\n\t{1}".format(key,"\n\t".join(first_Dict[key])))

Answer 2

Сначала объявляют два пустых списка: один для хранения отсутствующих ключей, а второй - для отсутствующих значений этих ключей.

key_lst=[]
values_lst=[]

Попробуйте этот код.

First_Dict = {"Texas": ["San Antonio", "Austin", "Houston", "Dallas"], 
     "California": ["San Diego", "Los Angeles", "San Francisco"],
    "Florida": ["Miami", "Orlando", "Jacksonville", "Naples"], 
     "Arizona": ["Phoenix", "Tucson"]}


Second_Dict = {"Texas": ["San Antonio", "Austin", "Houston","Dallas"],
       "California": ["San Diego", "Los Angeles", "San Francisco"],
       "Florida": ["Miami", "Orlando", "Jacksonville",], "Illinois": 
      ["Chicago", "Naperville"]}
key_lst=[]
values_lst=[]
for key, value in First_Dict.items() and Second_Dict.items():
    if key in First_Dict.keys() and Second_Dict.keys():
        if key in Second_Dict.keys() and First_Dict.keys() :
            continue
        else:
            key_lst.append(key)
    else:
        key_lst.append(key)
    if value in First_Dict.values() and Second_Dict.values():
        if value in Second_Dict.values() and First_Dict.values() :

            continue
        else:
            values_lst.append(value)
    else:
        values_lst.append(value)
for key, value in Second_Dict.items() and First_Dict.items():
    if key in First_Dict.keys() and Second_Dict.keys():
        if key in Second_Dict.keys() and First_Dict.keys() :
            continue
        else:
            key_lst.append(key)
    else:
        key_lst.append(key)
    if value in First_Dict.values() and Second_Dict.values():
        if value in Second_Dict.values() and First_Dict.values() :

            continue
        else:
            values_lst.append(value)
    else:
        values_lst.append(value)
print("Missing Keys: ",key_lst[0],": Missing Values",values_lst[0])
print("Missing Keys: ",key_lst[1],": Missing Values",values_lst[1])

Вывод

Missing Keys:  Illinois : Missing Values ['Chicago', 'Naperville']
Missing Keys:  Arizona : Missing Values ['Phoenix', 'Tucson']

Отметьте ответ, если это полезно.

Answer 3

Еще один вариант использования наборов:

mismatch = {}
missing_from_first = {}
missing_from_second = {}
for state in list(set([state for state in First_Dict] + [state for state in Second_Dict])):
  set1 = set(First_Dict.get(state, []))
  set2 = set(Second_Dict.get(state, []))
  mismatch[state] = list(set1.union(set2) - set1.intersection(set2))
  missing_from_first[state] = list(set2 - set1)
  missing_from_second[state] = list(set1 - set2)

Итак, распечатка результатов:

print mismatch
print missing_from_first
print missing_from_second
#=> {'Florida': ['Naples'], 'Arizona': ['Tucson', 'Phoenix'], 'California': [], 'Texas': ['Dallas'], 'Illinois': ['Naperville', 'Chicago']}
#=> {'Florida': [], 'Arizona': [], 'California': [], 'Texas': [], 'Illinois': ['Naperville', 'Chicago']}
#=> {'Florida': ['Naples'], 'Arizona': ['Tucson', 'Phoenix'], 'California': [], 'Texas': ['Dallas'], 'Illinois': []}

Переберите результаты, чтобы отформатировать печать, как вам нужно.

Answer 4

Вы можете сделать что-то вроде этого:

First_Dict = {"Texas": ["San Antonio", "Austin", "Houston", "Dallas"],
              "California": ["San Diego", "Los Angeles", "San Francisco"],
              "Florida": ["Miami", "Orlando", "Jacksonville", "Naples"],
              "Arizona": ["Phoenix", "Tucson"]}

Second_Dict = {"Texas": ["San Antonio", "Austin", "Houston"],
               "California": ["San Diego", "Los Angeles", "San Francisco"],
               "Florida": ["Miami", "Orlando", "Jacksonville"], "Illinois":
                   ["Chicago", "Naperville"]}

for key, values in First_Dict.items():
    if key in Second_Dict:  # if key match
        diff = [value for value in values if value not in Second_Dict[key]]
        if not diff:  # all values match
            pass
        else:
            print("key: {}, missing values: {}".format(key, diff))
    else:
        print("key: {}, missing values: {}".format(key, values))

выход

key: Florida, missing values: ['Naples']
key: Texas, missing values: ['Dallas']
key: Arizona, missing values: ['Phoenix', 'Tucson']

Строка diff = [value for value in values if value not in Second_Dict[key]] представляет собой список и вычисляет разницу между значениями в First_Dict и Second_Dict, когда ключи совпадают.

UPDATE

Если вам нужны оба различия, вы можете сделать что-то вроде этого:

First_Dict = {"Texas": ["San Antonio", "Austin", "Houston", "Dallas"],
              "California": ["San Diego", "Los Angeles", "San Francisco"],
              "Florida": ["Miami", "Orlando", "Jacksonville", "Naples"],
              "Arizona": ["Phoenix", "Tucson"]}

Second_Dict = {"Texas": ["San Antonio", "Austin", "Houston"],
               "California": ["San Diego", "Los Angeles", "San Francisco"],
               "Florida": ["Miami", "Orlando", "Jacksonville"], "Illinois":
                   ["Chicago", "Naperville"]}

for key, values in First_Dict.items():
    if key in Second_Dict:  # if key match
        diff_first = [value for value in values if value not in Second_Dict[key]]
        diff_second = [value for value in Second_Dict[key] if value not in values]
        if not diff_first:  # all values match
            pass
        else:
            print("key: {}, missing values: {} in Second_Dict".format(key, diff_first))

        if not diff_second:
            pass
        else:
            print("key: {}, missing values: {} in First_Dict".format(key, diff_second))
    else:
        print("key: {}, missing values: {} in Second_Dict".format(key, values))

for key, values in Second_Dict.items():
    if key not in First_Dict:
        print("key: {}, missing values: {} in First_Dict".format(key, values))

выход

key: Texas, missing values: ['Dallas'] in Second_Dict
key: Florida, missing values: ['Naples'] in Second_Dict
key: Arizona, missing values: ['Phoenix', 'Tucson'] in Second_Dict
key: Illinois, missing values: ['Chicago', 'Naperville'] in First_Dict

Второй цикл предназначен для перебора ключей в Second_Dict, отсутствующих в First_Dict.