python循环中的计数对

Question

I have a list of dictionaries where each dict is of the form:

 {'A': a,'B': b}

I want to iterate through the list and for every (a,b) pair, find the pair(s), (b,a), if it exists.

For example if for a given entry of the list A = 13 and B = 14, then the original pair would be (13,14). I would want to search the entire list of dicts to find the pair (14,13). If (14,13) occurred multiple times I would like to record that too.

I would like to count the number of times for all original (a,b) pairs in the list, when the complement (b,a) appears, and if so how many times. To do this I have two for loops and a counter when a complement pair is found.

pairs_found = 0
for i, val in enumerate( list_of_dicts ):
    for j, vol in enumerate( list_of_dicts ):
        if val['A'] == vol['B']:
            if vol['A'] == val['B']:
                pairs_found += 1

This generates a pairs_found greater than the length of list_of_dicts . I realize this is because the same pairs will be over-counted. I am not sure how I can overcome this degeneracy?

Edit for Clarity

list_of_dicts = []

list_of_dicts[0] = {'A': 14, 'B', 23}
list_of_dicts[1] = {'A': 235, 'B', 98}
list_of_dicts[2] = {'A': 686, 'B', 999}
list_of_dicts[3] = {'A': 128, 'B', 123}

....

Lets say that the list has around 100000 entries. Somewhere in that list, there will be one or more entries, of the form {'A' 23, 'B': 14}. If this is true then I would like a counter to increase its value by one. I would like to do this for every value in the list.

Answer 1

Here is what I suggest:

• Use tuple to represent your pairs and use them as dict/set keys.
• Build a set of unique inverted pairs you'll look for.
• Use a dict to store the number of time a pair appears inverted

Then the code should look like this:

# Create a set of unique inverted pairs    
inverted_pairs_set = {(d['B'],d['A']) for d in list_of_dicts}
# Create a counter for original pairs
pairs_counter_dict = {(ip[1],ip[0]):0 for ip in inverted_pairs_set]
# Create list of pairs
pairs_list = [(d['A'],d['B']) for d in list_of_dicts]
# Count for each inverted pairs, how many times 
for p in pairs_list:
   if p in inverted_pairs_set:
      pairs_counter_dict[(p[1],p[0])] += 1

Answer 2

You could first create a list with the values of each dictionary as tuples:

example_dict = [{"A": 1, "B": 2}, {"A": 4, "B": 3}, {"A": 5, "B": 1}, {"A": 2, "B": 1}]
dict_values = [tuple(x.values()) for x in example_dict]

Then create a second list with the number of occurrences of each element inverted:

occurrences = [dict_values.count(x[::-1]) for x in dict_values]

Finally, create a dict with dict_values as keys and occurrences as values:

dict(zip(dict_values, occurrences))

Output:

{(1, 2): 1, (2, 1): 1, (4, 3): 0, (5, 1): 0}

For each key, you have the number of inverted keys. You can also create the dictionary on the fly:

occurrences = {dict_values: dict_values.count(x[::-1]) for x in dict_values}

Answer 3

I am still not 100% sure what it is you want to do but here is my guess :

pairs_found = 0
for i, dict1 in enumerate(list_of_dicts):
    for j, dict2 in enumerate(list_of_dicts[i+1:]):
        if dict1['A'] == dict2['B'] and dict1['B'] == dict2['A']:
            pairs_found += 1

Note the slicing on the second for loop. This avoids checking pairs that have already been checked before (comparing D1 with D2 is enough; no need to compare D2 to D1)

This is better than O(n**2) but still there is probably room for improvement

Answer 4

You can create a counter dictionary that contains the values of the 'A' and 'B' keys in all your dictionaries:

complements_cnt = {(dct['A'], dct['B']): 0 for dct in list_of_dicts}

Then all you need is to iterate over your dictionaries again and increment the value for the "complements":

for dct in list_of_dicts:
    try:
        complements_cnt[(dct['B'], dct['A'])] += 1
    except KeyError:   # in case there is no complement there is nothing to increase
        pass

For example with such a list_of_dicts :

list_of_dicts = [{'A': 1, 'B': 2}, {'A': 2, 'B': 1}, {'A': 1, 'B': 2}]

This gives:

{(1, 2): 1, (2, 1): 2}   

Which basically says that the {'A': 1, 'B': 2} has one complement (the second) and {'A': 2, 'B': 1} has two (the first and the last).

The solution is O(n) which should be quite fast even for 100000 dictionaries.

Note: This is quite similar to @debzsud answer. I haven't seen it before I posted the answer though. :(