Python: transformer la "liste des tuples" en 1 Liste plate, ou 1 Matrice
avec Sqlite, un " select..à partir de la commande" renvoie les résultats "de sortie", qui imprime (en python):
>>print output
[(12.2817, 12.2817), (0, 0), (8.52, 8.52)]
Il semble être une liste de tuples. Je voudrais soit convertir "output" dans un simple tableau 1D (=list en Python je suppose):
[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 par l'intermédiaire de "sortie[i][j]"
la commande flatten ne fait pas le travail pour la 1ère option, et je n'ai aucune idée pour la seconde... :)
vous s'il vous plaît me donner un indice? Quelque chose de rapide serait bien que les données réelles sont beaucoup plus grandes (voici un exemple simple).
je vous Remercie.
9 réponses
de loin la solution la plus rapide (et la plus courte) a affiché:
list(sum(output, ()))
environ 50% plus rapide que le itertools solution, et environ 70% plus rapide que le map la solution.
en Python 3 vous pouvez utiliser le * syntaxe pour aplatir une liste de iterables:
>>> 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]
>>>
utiliser itertools chaîne:
>>> import itertools
>>> list(itertools.chain.from_iterable([(12.2817, 12.2817), (0, 0), (8.52, 8.52)]))
[12.2817, 12.2817, 0, 0, 8.52, 8.52]
Ou vous pouvez les aplatir la liste comme ceci:
reduce(lambda x,y:x+y, map(list, output))
une autre option plus rapide que l'option de la somme pour les grands tableaux:
aplatissement avec la carte/extension:
l = []
list(map(l.extend, output))
aplatir avec la compréhension de liste au lieu de map (le plus rapide)
l = []
list(l.extend(row) for row in output)
>>> 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 de la liste de tuple de liste unique, comme indiqué ci-dessus.
énumérer l'approche de compréhension qui fonctionne avec des types itérables et est plus rapide que les autres méthodes indiquées ici.
flattened = [item for sublist in l for item in sublist]
l est la liste à aplatir (appelée output dans le cas des OP cas)
timeit tests:
l = list(zip(range(99), range(99))) # list of tuples to flatten
compréhension de Liste
[item for sublist in l for item in sublist]
résultat timeit = 7,67 µs ± 129 ns par boucle
méthode list extend ()
flattened = []
list(flattened.extend(item) for item in l)
résultat timeit = 11 µs ± 433 ns par boucle
sum ()
list(sum(l, ()))
résultat timeit = 24.2 µs ± 269 ns par boucle
en cas de listes emboîtées arbitraires (juste au cas):
def flatten(lst):
result = []
for element in lst:
if hasattr(element, '__iter__'):
result.extend(flatten(element))
else:
result.append(element)
return result
>>> flatten(output)
[12.2817, 12.2817, 0, 0, 8.52, 8.52]
c'est Ce que numpy a été fait pour, à la fois d'un point de vue des structures de données, ainsi que la vitesse.
import numpy as np
output = [(12.2817, 12.2817), (0, 0), (8.52, 8.52)]
output_ary = np.array(output) # this is your matrix
output_vec = output_ary.ravel() # this is your 1d-array