Transformer une "liste de tuples" en une liste plate ou une matrice

Question

Avec Sqlite, un select .. from La commande renvoie les résultats output qui imprime :

>>print output
[(12.2817, 12.2817), (0, 0), (8.52, 8.52)]

Il semble s'agir d'une liste de tuples. Je voudrais soit convertir output à une simple liste :

[12.2817, 12.2817, 0, 0, 8.52, 8.52]

ou une matrice 2x3 :

12.2817 12.2817
0          0 
8.52     8.52

à lire via output[i][j]

La commande flatten ne fait pas l'affaire pour la 1ère option, et je n'ai aucune idée pour la seconde...

Une solution rapide serait appréciée, car les données réelles sont beaucoup plus importantes.

Answer 1

De loin la solution la plus rapide (et la plus courte) mise en ligne :

list(sum(output, ()))

Environ 50% plus rapide que le itertools et environ 70 % plus rapide que la solution map solution.

Answer 2

Approche de la compréhension des listes qui fonctionne avec les types Iterable et qui est plus rapide que les autres méthodes présentées ici.

flattened = [item for sublist in l for item in sublist]

l est la liste à aplatir (appelée output dans le cas de l'OP)

---

tests de temps :

l = list(zip(range(99), range(99)))  # list of tuples to flatten

Compréhension de la liste

[item for sublist in l for item in sublist]

résultat timeit = 7.67 µs ± 129 ns par boucle

Méthode de la liste extend()

flattened = []
list(flattened.extend(item) for item in l)

résultat timeit = 11 µs ± 433 ns par boucle

somme()

list(sum(l, ()))

résultat timeit = 24.2 µs ± 269 ns par boucle

Answer 3

Dans Python 2.7, et toutes les versions de Python3, vous pouvez utiliser itertools.chain pour aplatir une liste d'itérables. Soit avec l'option * ou la méthode de la classe.

>>> t = [ (1,2), (3,4), (5,6) ]
>>> t
[(1, 2), (3, 4), (5, 6)]
>>> import itertools
>>> list(itertools.chain(*t))
[1, 2, 3, 4, 5, 6]
>>> list(itertools.chain.from_iterable(t))
[1, 2, 3, 4, 5, 6]

Answer 4

Mise à jour : Aplatissement en utilisant extend mais sans compréhension et sans utiliser la liste comme itérateur (le plus rapide)

Après avoir vérifié la réponse suivante qui proposait une solution plus rapide via une compréhension de liste avec l'option dual for J'ai fait une petite modification et maintenant il fonctionne mieux, d'abord l'exécution de list(...) traînait un grand pourcentage de temps, puis le changement d'une compréhension de liste pour une boucle simple a également réduit un peu plus.

La nouvelle solution est :

l = []
for row in output: l.extend(row)

L'ancien remplaçant list con [] (un peu plus lent mais pas beaucoup) :

[l.extend(row) for row in output]

---

Plus vieux (plus lent) :

Aplatissement avec compréhension des listes

l = []
list(l.extend(row) for row in output)

---

quelques timeits pour new extend et l'amélioration obtenue en supprimant simplement list(...) pour [...] :

import timeit
t = timeit.timeit
o = "output=list(zip(range(1000000000), range(10000000))); l=[]"
steps_ext = "for row in output: l.extend(row)"
steps_ext_old = "list(l.extend(row) for row in output)"
steps_ext_remove_list = "[l.extend(row) for row in output]"
steps_com = "[item for sublist in output for item in sublist]"

print(f"{steps_ext}\n>>>{t(steps_ext, setup=o, number=10)}")
print(f"{steps_ext_remove_list}\n>>>{t(steps_ext_remove_list, setup=o, number=10)}")
print(f"{steps_com}\n>>>{t(steps_com, setup=o, number=10)}")
print(f"{steps_ext_old}\n>>>{t(steps_ext_old, setup=o, number=10)}")

L'heure des résultats :

for row in output: l.extend(row)                  
>>> 7.022608777000187

[l.extend(row) for row in output]
>>> 9.155910597999991

[item for sublist in output for item in sublist]
>>> 9.920002304000036

list(l.extend(row) for row in output)
>>> 10.703829122000116

Answer 5

>>> flat_list = []
>>> nested_list = [(1, 2, 4), (0, 9)]
>>> for a_tuple in nested_list:
...     flat_list.extend(list(a_tuple))
... 
>>> flat_list
[1, 2, 4, 0, 9]
>>> 

vous pouvez facilement passer d'une liste de tuple à une liste unique comme indiqué ci-dessus.