Python使用组合来对字典中列表中的元组中的值求和？

Question

I am trying to sum a combination of values from a list of tuples in a dictionary. For example, my dictionary contains:

dict = {1: [(2, 2), (4, 3), (6, 1), (7, 1), (8, 3)], 2: [(4, 1), (5, 3), (1, 2)],...} 

and goes on for multiple entries. I'm trying to sum the second value of the tuples for each entry in as many combinations that sum to a maximum of 4. So for entry 1, the desired output would be:

{1: [(2, 6, 3), (2, 7, 3), (4, 6, 4), (4, 7, 4), (6, 7, 2), (8, 6, 4), (8, 7, 4)]

Where the third value in this tuple is the sum of the combinations of the second value of the previous tuples, and the first and second values of this tuple are the associated first values of the previous tuples.

I have tried the following code:

for key, value in dict.items():
    object1 = key
    mylist = value
    for tup in mylist:
         object2 = tup[0]
         pair = tup[1]
         combo = itertools.combinations(tup[1],2)
         sum = {k:sum(j for _,j in v) for k,v in combo}
         if sum <= 4:
             print(sum)

And I get the error

'numpy.float64' object is not iterable

I think my error stems from "combo" and possibly my use of itertools. I am unsure if I just need to fix this section of my code or if I am way off base in my approach.

Answer 1

Yes, you can do this with itertools.combinations , but you have to pass it the right arguments. :) You need to pass it the list of tuples so it can make the pairs of tuples. You could do this with comprehensions, but I think using traditional for loops makes it easier to read.

As others have mentioned, there are other problems with your code, apart from not passing the right things to combinations . The main one being that you're assigning a dictionary to the name sum , which shadows the sum built-in function that you're also trying to use. And you also attempt to compare that dictionary with the integer 4, that doesn't make a lot of sense. :)

Anyway, here's some code that does what you want. Note that in your expected output you messed up the last two tuples: (8, 6, 4) and (8, 7, 4) should be (6, 8, 4) and (7, 8, 4) , respectively.

from itertools import combinations

a = {
    1: [(2, 2), (4, 3), (6, 1), (7, 1), (8, 3)], 
    2: [(4, 1), (5, 3), (1, 2)],
}

new_dict = {}

for k, seq in a.items():
    c = []
    for (u,v), (x,y) in combinations(seq, 2):
        total = v + y
        if total <= 4:
            c.append((u, x, total))
    new_dict[k] = c

for k, seq in new_dict.items():
    print(k, seq)

output

1 [(2, 6, 3), (2, 7, 3), (4, 6, 4), (4, 7, 4), (6, 7, 2), (6, 8, 4), (7, 8, 4)]
2 [(4, 5, 4), (4, 1, 3)]

combinations(seq, 2) yields pairs of tuples, and we can unpack those tuples into their individual numbers with

for (u,v), (x,y) in combinations(seq, 2):

We could have done something like

for t0, t1 in combinations(seq, 2):

and then unpacked the t0 and t1 tuples in a separate step, or just used indexing to get their items. Eg,

for t0, t1 in combinations(seq, 2):
    total = t0[1] + t1[1]
    if total <= 4:
        c.append((t[0], t[1], total))

But I think the previous way is less cluttered.

---

But if you insist on doing it all with comprehensions, you can:

new_dict = {k: [(u, x, v+y) for (u,v), (x,y) in combinations(seq, 2) if v+y <= 4]
    for k, seq in a.items()}

Note that this is less efficient than the previous versions because it computes v+y twice for every combination that passes the v+y <= 4 test.