mjhjmtu

Currently, I have a dictionary, with its key representing a zip code, and the values are also a dictionary.

d = 94111: 'a': 5, 'b': 7, 'd': 7, 
 95413: 'a': 6, 'd': 4, 
 84131: 'a': 5, 'b': 15, 'c': 10, 'd': 11, 
 73173: 'a': 15, 'c': 10, 'd': 15, 
 80132: 'b': 7, 'c': 7, 'd': 7 

And then a second dictionary, which associates which state the zip code belongs to.

states = 94111: "TX", 84131: "TX", 95413: "AL", 73173: "AL", 80132: "AL"

If the zip code in the dictionary states matches one of the keys in db then it would sum up those values and put it into a new dictionary like the expected output.

Expected Output:

'TX': 'a': 10, 'b': 22, 'd': 18, 'c': 10, 'AL': 'a': 21, 'd': 26, 'c': 17, 'b': 7

So far this is the direction I am looking to go into but I'm not sure when both the keys match, how to create a dictionary that will look like the expected output.

def zips(d, states):
 result = dict()
 for key, value in db.items():
 for keys, values in states.items():
 if key == keys:


zips(d, states)

Using collections module

Ex:

from collections import defaultdict, Counter

d = 94111: 'a': 5, 'b': 7, 'd': 7, 
 95413: 'a': 6, 'd': 4, 
 84131: 'a': 5, 'b': 15, 'c': 10, 'd': 11, 
 73173: 'a': 15, 'c': 10, 'd': 15, 
 80132: 'b': 7, 'c': 7, 'd': 7 

states = 94111: "TX", 84131: "TX", 95413: "AL", 73173: "AL", 80132: "AL"

result = defaultdict(Counter)
for k,v in d.items():
 if k in states:
 result[states[k]] += Counter(v)
print(result)

Output:

defaultdict(<class 'collections.Counter'>, 'AL': Counter('d': 26, 'a': 21, 'c': 17, 'b': 7), 
'TX': Counter('b': 22, 'd': 18, 'a': 10, 'c': 10))

You can just use defaultdict and count in a loop:

expected_output = defaultdict(lambda: defaultdict(int))
for postcode, state in states.items():
 for key, value in d.get(postcode, ).items():
 expected_output[state][key] += value

Just as a complement of the answer of Rakesh, Here is an answer closer to your code:

res = v: for v in states.values()

for k,v in states.items():
 if k in d:
 sub_dict = d[k]
 output_dict = res[v]
 for sub_k,sub_v in sub_dict.items():
 output_dict[sub_k] = output_dict.get(sub_k, 0) + sub_v

You can use something like this:

d = 94111: 'a': 5, 'b': 7, 'd': 7, 
 95413: 'a': 6, 'd': 4, 
 84131: 'a': 5, 'b': 15, 'c': 10, 'd': 11, 
 73173: 'a': 15, 'c': 10, 'd': 15, 
 80132: 'b': 7, 'c': 7, 'd': 7 
states = 94111: "TX", 84131: "TX", 95413: "AL", 73173: "AL", 80132: "AL" 

out = i: 0 for i in states.values() 
for key, value in d.items(): 
 if key in states: 
 if not out[states[key]]: 
 out[states[key]] = value 
 else: 
 for k, v in value.items(): 
 if k in out[states[key]]: 
 out[states[key]][k] += v 
 else: 
 out[states[key]][k] = v 
# out -> 'TX': 'a': 10, 'b': 22, 'd': 18, 'c': 10, 'AL': 'a': 21, 'd': 26, 'c': 17, 'b': 7

You can use the class Counter for counting objects:

from collections import Counter

d = 94111: 'a': 5, 'b': 7, 'd': 7, 
 95413: 'a': 6, 'd': 4, 
 84131: 'a': 5, 'b': 15, 'c': 10, 'd': 11, 
 73173: 'a': 15, 'c': 10, 'd': 15, 
 80132: 'b': 7, 'c': 7, 'd': 7 

states = 94111: "TX", 84131: "TX", 95413: "AL", 73173: "AL", 80132: "AL"

new_d = 
for k, v in d.items():
 if k in states:
 new_d.setdefault(states[k], Counter()).update(v)

print(new_d)
# 'TX': Counter('b': 22, 'd': 18, 'a': 10, 'c': 10), 'AL': Counter('d': 26, 'a': 21, 'c': 17, 'b': 7)

You can convert new_d to the dictionary of dictionaries:

for k, v in new_d.items():
 new_d[k] = dict(v)

print(new_d)
# 'TX': 'a': 10, 'b': 22, 'd': 18, 'c': 10, 'AL': 'a': 21, 'd': 26, 'c': 17, 'b': 7

You can leverage dict's .items() method, which returns a list of tuples, and get the expected output in a simple one-liner:

new_dict = value:d[key] for key, value in states.items()

Output:

'AL': 'b': 7, 'c': 7, 'd': 7, 'TX': 'a': 5, 'b': 15, 'c': 10, 'd': 11

You might want to reconsider your choice of dict for how to store your data. If you store your data using pandas, aggregation is a lot easier.

df = pd.DataFrame(d).transpose()
df['states']=pd.Series(states)
df.groupby('states').sum()

>> a b c d
>>states 
>>AL 21.0 7.0 17.0 26.0
>>TX 10.0 22.0 10.0 18.0