python - crear una tupla a partir de pares

tuples

Question

Me gustaría crear una tupla que presente todos los pares posibles de dos tuplas

Este es un ejemplo de lo que me gustaría recibir:

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

salida:

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

Esto es lo que hice que tuvo éxito, sin embargo, parece un poco engorroso:

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)  

El código que escribí funciona, sin embargo, estoy buscando un código más agradable
gracias de antemano

Answer 1

Aquí hay una frase fea.

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)]

A menos que esté utilizando esto para el deporte, probablemente debería elegir una solución más legible, por ejemplo, una de MrGeek a continuación.

Answer 2

Mi camino en una línea:

[item for sublist in [[(i,j),(j,i)] for i in first_tuple for j in second_tuple] for item in sublist]

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

Answer 3

Puede usar el product y las permutations itertools :

from itertools import product, permutations

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

result = ()

for tup in product(first_tuple, second_tuple):
    result += (*permutations(tup),)

print(result)

Salida:

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

product produce las tuplas (dos elementos) producidas igualmente por la estructura de bucle anidado (sus variables t1 y t2 ), y las permutations producen las dos permutaciones producidas igualmente por sus variables d .

Answer 4

Si desea evitar el uso de la biblioteca estándar ( itertools ), simplemente combine dos comprensiones de lista:

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 )

luego conviértalo en una tuple si es importante para usted.

Answer 5

También puedes hacer:

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)))])

Answer 6

Una línea usando una comprensión de la lista que no requiere una import .

t1 = (1, 2)
t2 = (4, 5)

>>> sorted([t for i in t1 for j in t2 for t in ((i, j), (j, i))])
# [(1, 4), (1, 5), (2, 4), (2, 5), (4, 1), (4, 2), (5, 1), (5, 2)]

Por supuesto, para "todos los pares posibles de dos tuplas significa" que tendría como máximo ocho pares de tuplas en el resultado. Puede hacer referencia explícita a ellos, lo que debería ser la solución más rápida si se trata de un código de tiempo crítico (y si no es necesario ordenarlo, será aún más rápido).

>>> sorted(((t1[0], t2[0]), (t1[0], t2[1]), (t1[1], t2[0]), (t1[1], t2[1]), 
            (t2[0], t1[0]), (t2[0], t1[1]), (t2[1], t1[0]), (t2[1], t1[1])))
# [(1, 4), (1, 5), (2, 4), (2, 5), (4, 1), (4, 2), (5, 1), (5, 2)]

Opcional: use set para garantizar que solo se devuelvan pares únicos.

t1 = (1, 2)
t2 = (1, 2)

>>> sorted([t for i in t1 for j in t2 for t in ((i, j), (j, i))])
# [(1, 1), (1, 1), (1, 2), (1, 2), (2, 1), (2, 1), (2, 2), (2, 2)]

>>> sorted(set([t for i in t1 for j in t2 for t in ((i, j), (j, i))]))
# [(1, 1), (1, 2), (2, 1), (2, 2)]

Answer 7

itertools.product te da lo que quieres. Sin embargo, dado que el producto cartesiano de dos tuplas no es conmutativo ( product(x,y) != product(y,x) ), debe calcular ambos y concatenar los resultados.

>>> 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)]

(Puede usar la chain aquí en lugar de las permutations porque solo hay dos permutaciones de una tupla de 2, que son lo suficientemente fáciles de especificar explícitamente).

Answer 8

def mul_tup(tup1, tup2):
        l=[]

        for x in tup1:
            for y in tup2:
                a=(x,y)
                b=(y,x)
                l.append(a)
                l.append(b)

        return tuple(l)

first_tup= tuple([eval(x) for x in input("enter the values: ").split('','')])
second_tup= tuple([eval(x) for x in input("enter the values: ").split('','')])
q = mult_tup(first_tup, second_tup)
print(q)

Answer 9

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))

Huellas dactilares:

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