Mfcttrf

I would like to create a tuple which present all the possible pairs from two tuples

this is example for what I would like to receive :

first_tuple = (1, 2)
second_tuple = (4, 5)
mult_tuple(first_tuple, second_tuple)

output :

((1, 4), (4, 1), (1, 5), (5, 1), (2, 4), (4, 2), (2, 5), (5, 2))

This is what I did which succeed however look a bit cumbersome :

def mult_tuple(tuple1, tuple2):
 ls=[]
 for t1 in tuple1:

 for t2 in tuple2:
 c=(t1,t2)
 d=(t2,t1)
 ls.append(c)
 ls.append(d)

 return tuple(ls)


first_tuple = (1, 2) 
second_tuple = (4, 5) 
mult_tuple(first_tuple, second_tuple) 

The code I wrote works , however I am looking for a nicer code

thank you in advance

Here is an ugly one-liner.

first_tuple = (1, 2)
second_tuple = (4, 5)
tups = [first_tuple, second_tuple]
res = [(i, j) for x in tups for y in tups for i in x for j in y if x is not y]
# [(1, 4), (1, 5), (2, 4), (2, 5), (4, 1), (4, 2), (5, 1), (5, 2)]

You can use itertools's product and permutations:

from itertools import product, permutations

ls = []

for tup in product(first_tuple, second_tuple):
 ls.extend(list(permutations(tup)))

print(ls)

Output:

[(1, 4), (4, 1), (1, 5), (5, 1), (2, 4), (4, 2), (2, 5), (5, 2)]

product produces the tuples produced equally by the double for loop structure, and permutations produces the two permutations produced equally by your c and d variables, extend is used here instead of two appends.

itertools.product gives you what you want. However, since the Cartesian product of two tuples is not commutative (product(x,y) != product(y,x)), you need to compute both and concatenate the results.

>>> from itertools import chain, product
>>> x = (1,4)
>>> y = (2, 5)
>>> list(chain(product(x,y), product(y,x)))
[(1, 2), (1, 5), (4, 2), (4, 5), (2, 1), (2, 4), (5, 1), (5, 4)]

(You can use chain here instead of permutations because there are only two permutations of a 2-tuple, which are easy enough to specify explicitly.)

If you’d like to avoid the use of the standard library (itertools) then simply combine two list comprehensions:

result = [(x, y) for x in first_tuple for y in second_tuple]
result.extend( (x, y) for x in second_tuple for y in first_tuple )

then convert to a tuple if it’s important to you.

Also You can do:

from itertools import permutations 
t1=(1,2)
t2=(3,4)
my_tuple=tuple([key for key in filter(lambda x: x!=t1 and (x!=t2),list(permutations(t1+t2,2)))])

first_tuple = (1, 2)
second_tuple = (4, 5)

out = []
for val in first_tuple:
 for val2 in second_tuple:
 out.append((val, val2))
 out.append((val2, val))

print(tuple(out))

Prints:

((1, 4), (4, 1), (1, 5), (5, 1), (2, 4), (4, 2), (2, 5), (5, 2))