Transform "- Liste von Tupeln" in einer flachen Liste oder einer matrix

Mit Sqlite, ein "select..from" - Befehl gibt die Ergebnisse "output", das Drucke (in python):

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

Scheint es sich um eine Liste von Tupeln. Ich möchte entweder konvertieren "output" in einem einfachen 1D-array (=Liste, in Python, die ich denke):

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

oder einer 2x3 matrix:

12.2817 12.2817
0          0 
8.52     8.52

gelesen werden, die über "output[i][j]"

Den flatten-Befehl nicht die Arbeit machen, für die 1. option, und ich habe keine Idee für die zweite... 🙂

Bitte könnten Sie mir einen Tipp geben? Einige Sache schnell groß sein würde, wie real die Daten sind viel größer (hier ist nur ein einfaches Beispiel).

InformationsquelleAutor garth | 2012-05-17
  1. 96

    Das mit Abstand Schnellste (und kürzeste) Lösung gepostet:

    list(sum(output, ()))

    Etwa 50% schneller als die itertools - Lösung, und etwa 70% schneller als die map Lösung.

    • nett, aber ich Frage mich, wie es funktioniert? list(output[0]+output[1]+output[2]) gibt das gewünschte Ergebnis, aber list(sum(output)) nicht. Warum? Welche "Magie" muss die () zu tun?
    • Ok, ich sollte das Handbuch gelesen haben g. Es scheint sum(sequence[, start]): Summe addiert start standardmäßig 0 sondern dann nur ab sequence[0] wenn es vorhanden ist und fügt dann den rest der Elemente. Sorry für stört Sie.
    • Dies ist ein bekanntes anti-pattern: nicht verwenden sum zu Sequenzen verketten, es Ergebnisse in einer quadratischen Zeit-Algorithmus. In der Tat, die sum Funktion wird sich beschweren, falls Sie versuchen, diese mit Saiten!
    • vereinbart. Es gibt nur sehr wenige Anwendungsfälle wo diese vorzuziehen wäre.
    • Ja, schnell, aber völlig stumpf. Sie müssten, um einen Kommentar zu hinterlassen, was es tatsächlich tut 🙁
    • Siehe meine Antwort für einen Vergleich mit anderen Techniken gibt, die schneller sind und mehr Pythonic IMO.

    InformationsquelleAutor Joel Cornett
  2. 19

    Liste Verständnis Konzept, das funktioniert mit Wiederholenden Typen und ist schneller als andere Methoden, die hier gezeigt werden.

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

    l ist die Liste zu reduzieren (genannt output im OP der Fall)

    timeit tests:

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

    Liste Verständnis

    [item for sublist in l for item in sublist]

    timeit Ergebnis = 7.67 µs ± 129 ns pro Schleife

    Liste erweitern () - Methode

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

    timeit Ergebnis = 11 µs ± 433 ns pro Schleife

    Summe()

    list(sum(l, ()))

    timeit Ergebnis = 24.2 µs ± 269 ns pro Schleife

    • Ich musste diese über ein großes dataset, das list-comprehension-Methode war mit Abstand der Schnellste!
    • Ich habe ein wenig verändern, um den .verlängern Lösung und führt jetzt ein bisschen besser. check it out auf Ihrem timeit zu vergleichen
    InformationsquelleAutor Gman
  3. 14

    In Python 3 können Sie den * syntax zu glätten, eine Liste von 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]
>>>
    • funktioniert auf python 2.7.6 auch!
    InformationsquelleAutor Thruston
  4. 7

    Oder Sie können glätten die Liste wie diese:

    reduce(lambda x,y:x+y, map(list, output))
    • reduce(lambda x,y:x+y, output) scheint zu funktionieren, die direkt konvertieren in eine lange Tupel (die umgewandelt werden können, um eine Liste). Warum map(list, output) innerhalb der reduce() nennen? Vielleicht ist Es mehr in Einklang mit der Tatsache, dass Tupel sind unveränderliche Listen sind veränderlich.
    InformationsquelleAutor Maria Zverina
  5. 7

    verwenden itertools Kette:

    >>> 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]
    InformationsquelleAutor Charles Beattie
  6. 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]
>>>

    könnten Sie leicht verschieben Sie aus der Liste von Tupel auf einzelne Liste, wie oben gezeigt.

    InformationsquelleAutor cobie
  7. 5

    Update: Abflachung mit verlängern, aber ohne das Verständnis und ohne die Verwendung der Liste als iterator (Schnellste)

    Nach Prüfung der nächsten Antwort auf diese, dass, sofern eine schnellere Lösung durch eine list comprehension mit dual for ich habe ein wenig zwicken und jetzt führt es besser, zuerst die Ausführung der Liste(...) war, ziehen einen großen Prozentsatz der Zeit, dann ändern einer Liste Verständnis für eine einfache Schleife Rasiert ein bisschen mehr als gut.

    Ist die neue Lösung:

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

    Älter:

    Abflachung mit Karte/erweitern:

    l = []
list(map(l.extend, output))

    Abflachung mit list comprehension statt Karte

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

    einige timeits für neue verlängern und die Verbesserung bekommen, indem nur Liste(...) für [...]:

    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("new extend:      ", t(steps_ext, setup=o, number=10))
print("old extend w []: ", t(steps_ext_remove_list, setup=o, number=10))
print("comprehension:   ", t(steps_com, setup=o, number=10,))
print("old extend:      ", t(steps_ext_old, setup=o, number=10))

>>> new extend:       4.502427191007882
>>> old extend w []:  5.281140706967562
>>> comprehension:    5.54302118299529
>>> old extend:       6.840151469223201
    • das ist die richtige Lösung für große arrays
    InformationsquelleAutor Totoro
  8. 3

    Dies ist, was numpy für gemacht wurde, die beide aus einem data-Strukturen, sowie die Geschwindigkeit Perspektive.

    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
    InformationsquelleAutor Joshua Cook
  9. 2

    Im Fall der willkürlichen verschachtelte Listen(nur für den Fall):

    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]
    InformationsquelleAutor cval
Schreibe einen Kommentar