比较python3中列表元组中的元素的问题

Question

I am trying to compare elements within the tuple of a list and extract only the values which are not common but for some reason it is returning the whole combination. For example if I pass the values like this:

[(3,2), (2,4)]

then it should return

[(3,4)]

This is what I tried:

a=[]
for i in range(len(l)):
    j=i+1
    for j in range(len(l)):
        print(i)
        print(j)
        if l[i][0]==l[j][0]:
            a.append((l[i][1],l[j][1]))
            print(a)
        elif l[i][0]==l[j][1]:
            a.append((l[i][1],l[j][0]))
            print(a)
        elif l[i][1]==l[j][0]:    
            a.append((l[i][0],l[j][1]))
            print(a)
        elif l[i][1]==l[j][1]:
            a.append((l[i][0],l[j][0]))
            print(a)

I was trying to build a more generic code to handle different kinds of inputs but it's not able to handle all the cases. Its giving both the possibilities for a single comparison for eg [(3,2),(2,4)].It gives both 3 4 and 4 3 as output.

Sample inputs tried
>>onehop([(2,3),(1,2)]) input 
>>[(1, 3)] expected output
>>onehop([(2,3),(1,2),(3,1),(1,3),(3,2),(2,4),(4,1)]) input
>>[(1, 2), (1, 3), (1, 4), (2, 1), (3, 2), (3, 4), (4, 2), (4, 3)] output
>>onehop([(1,2),(3,4),(5,6)]) input
>>[] expected output
>>onehop([(1,2),(2,1)]) input
>>[ ] expected output
>>onehop([(1,2)]) input
>>[ ] expected output
>>onehop([(1,3),(1,2),(2,3),(2,1),(3,2),(3,1)]) input
>>[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)] expected output

Is there a more optimized code or a list comprehension possible. I am new to this and learning this This is what I have tried.

def onehop(l):
    a = []
    b = []
    c = []
    for i in range(len(l)):
        j = i+1
        for j in range(len(l)):
            print(i) 'Just to understand the loops'
            print(j)
            if l[i][0] == l[j][1] and l[i][1] != l[j][0]:
                a.append((l[i][1],l[j][0]))
            elif l[i][0] != l[j][1] and l[i][1] == l[j][0]:
                a.append((l[i][0],l[j][1]))
            elif l[i][0] == l[j][0] and l[i][1] != l[j][1]:
                a.append((l[i][1],l[j][1]))
            elif l[i][0] != l[j][0] and l[i][1] == l[j][1]:
                a.append((l[i][0],l[j][0]))
    b = list(set(a))
    b.sort()
    return b

Answer 1

It seems like an oversight but you set j and immediatly overwrite it with the for -loop, which explains why you get all combinations: It also compares each element with itself.

If you insert what your manually calculated j as lower bound it seems to work for your case:

l = [(3,2),(2,4)]
a = []
for i in range(len(l)):
    for j in range(i+1, len(l)):  # changed!
        if l[i][0]==l[j][0]:
            a.append((l[i][1],l[j][1]))
        elif l[i][0]==l[j][1]:
            a.append((l[i][1],l[j][0]))
        elif l[i][1]==l[j][0]:    
            a.append((l[i][0],l[j][1]))
        elif l[i][1]==l[j][1]:
            a.append((l[i][0],l[j][0]))
print(a)
# [(3, 4)]

Probably you could simplify the code (and make it faster) by using set operations like as @Bill Bell pointed out already:

For instance, tuple(set((3,2)).symmetric_difference(set((2,4)))) yields (3, 4)

Answer 2

def remove_dup(L):
    if L == ():
        return ()
    else:
        return L[0] + remove_dup(tuple(map(lambda li: tuple(filter(lambda x: x not in L[0], li)), L[1:])))

print(remove_dup([(3,2),(2,4)]))
-->
(3, 2, 4)

print(remove_dup([(3,2,9),(2,4),(4,3,8,9),(9,7),(8,)]))
-->
(3, 2, 9, 4, 8, 7)