web-dev-qa-db-fra.com

créer un tuple à partir de paires

Je voudrais créer un Tuple qui présente toutes les paires possibles à partir de deux tuples

voici un exemple de ce que j'aimerais recevoir:

first_Tuple = (1, 2)
second_Tuple = (4, 5)
mult_Tuple(first_Tuple, second_Tuple)

production :

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

C'est ce que j'ai fait qui réussit cependant à paraître un peu lourd:

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)

Le code que j'ai écrit fonctionne, mais je cherche un code plus agréable
Merci d'avance

pythontuples
24
zachi

Voici un vilain 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)]

Sauf si vous l'utilisez pour le sport, vous devriez probablement opter pour une solution plus lisible, par ex. un par MrGeek ci-dessous.

12
hilberts_drinking_problem

Vous pouvez utiliser itertoolsproduct et permutations :

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)

Production:

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

product produit les tuples (deux éléments) produits également par la structure de boucle imbriquée for (votre t1 et t2 variables) et permutations produit les deux permutations produites également par vos variables c et d.

34
MrGeek

itertools.product Vous donne ce que vous voulez. Cependant, comme le produit cartésien de deux tuples n'est pas commutatif (product(x,y) != product(y,x)), vous devez calculer les deux et concaténer les résultats.

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

(Vous pouvez utiliser chain ici au lieu de permutations car il n'y a que deux permutations d'un 2-Tuple, qui sont assez faciles à spécifier explicitement.)

8
chepner

Si vous souhaitez éviter l'utilisation de la bibliothèque standard (itertools), combinez simplement deux listes de compréhension:

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 )

puis convertissez-le en Tuple si cela est important pour vous.

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

Tirages:

((1, 4), (4, 1), (1, 5), (5, 1), (2, 4), (4, 2), (2, 5), (5, 2))
2
Andrej Kesely

Vous pouvez également faire:

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

Un one-liner utilisant une compréhension de liste qui ne nécessite pas de 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)]

Bien sûr, pour "toutes les paires possibles de deux tuples" signifie que vous auriez au maximum huit paires de tuples dans le résultat. Vous pouvez les référencer explicitement, ce qui devrait être la solution la plus rapide s'il s'agit d'un code à temps critique (et si le tri n'est pas requis, il sera encore plus rapide).

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

Facultatif: utilisez set pour vous assurer que seules les paires uniques sont renvoyées.

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

Mon chemin en une seule ligne:

[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)]
0
Billy Bonaros