Comment aplatir une liste de listes une étape

Question

J'ai une liste de listes de tuples

A= [ [(1,2,3),(4,5,6)], [(7,8,9),(8,7,6),(5,4,3)],[(2,1,0),(1,3,5)] ] 

La liste extérieure peut avoir un certain nombre de listes internes, les listes internes peuvent avoir un certain nombre de tuples, un tuple toujours a 3 entiers.

Je veux générer toutes les combinaisons de tuples, un de chaque liste:

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

Une façon simple de le faire est d'utiliser une fonction similaire à itertools.poduct() mais il doit être appelé comme celui-ci

itertools.product([(1,2,3),(4,5,6)], [(7,8,9),(8,7,6),(5,4,3)],[(2,1,0),(1,3,5)]) 

Par exemple, la liste externe est supprimée. Et je ne sais pas comment faire ça. Existe-t-il un meilleur moyen de générer toutes les combinaisons de tuples?

Answer 1

itertools.product(*A) 

Pour plus de détails vérifier la python tutorial

Answer 2

Cela fonctionne pour votre exemple, s'il n'y a qu'un seul niveau de listes imbriquées (pas de listes de listes de listes):

itertools.product(*A) 

Answer 3

vous pouvez appeler probablement itertools.product comme ceci:

itertools.product(*A) # where A is your list of lists of tuples 

de cette façon, il élargit les élémen de votre liste ts en arguments pour la fonction que vous appelez.

Answer 4

Ce n'est pas exactement un pas, mais cela ferait ce que vous voulez si pour une raison quelconque, vous ne voulez pas utiliser la solution itertools:

def crossprod(listoflists): 
    if len(listoflists) == 1: 
     return listoflists 
    else: 
     result = [] 
     remaining_product = prod(listoflists[1:]) 
     for outertupe in listoflists[0]: 
      for innercombo in remaining_product[0]: 
       newcombo = [outertupe] 
       newcombo.append(innercombo) 
       result.append(newcombo) 
     return result 

Answer 5

def flatten(A) 
    answer = [] 
    for i in A: 
     if type(i) == list: 
      ans.extend(i) 
     else: 
      ans.append(i) 
    return ans 

Answer 6

tard pour le parti, mais .. Je suis nouveau à python et viens d'un fond de lisp. C'est ce que je suis venu avec (voir les noms de var pour lulz):

def flatten(lst): 
    if lst: 
     car,*cdr=lst 
     if isinstance(car,(list)): 
      if cdr: return flatten(car) + flatten(cdr) 
      return flatten(car) 
     if cdr: return [car] + flatten(cdr) 
     return [car] 

Semble à travailler. Test:

A = [ [(1,2,3),(4,5,6)], [(7,8,9),(8,7,6),(5,4,3)],[(2,1,0),(1,3,5)] ] 

flatten(A) 

Résultat:

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

Note: la ligne car,*cdr=lst ne fonctionne que dans Python 3.0

Answer 7

Cela peut également être obtenue en utilisant la compréhension de la liste.

In [62]: A = [ [(1,2,3),(4,5,6)], [(7,8,9),(8,7,6),(5,4,3)],[(2,1,0),(1,3,5)] ] 

In [63]: improved_list = [num for elem in A for num in elem] 

In [64]: improved_list 
Out[64]: [(1, 2, 3), (4, 5, 6), (7, 8, 9), (8, 7, 6), (5, 4, 3), (2, 1, 0), (1, 3, 5)]