Abflachen einer flachen Liste in Python [doppelte]

Diese Frage hat hier schon eine Antwort:

  • Eine flache Liste aus der Liste der Listen in Python 21 Antworten zu machen

Gibt es einen einfachen Weg, um eine Liste von iterables mit einem Listenverständnis zu glätten, oder versäumt das, was würdest du alle als den besten Weg sein, eine flache Liste so zu glätten, die Leistung und Lesbarkeit auszugleichen?

Ich habe versucht, eine solche Liste mit einem verschachtelten Listenverständnis zu glätten, wie folgt:

[image for image in menuitem for menuitem in list_of_menuitems] 

Aber ich bekomme in Schwierigkeiten der NameError Vielfalt dort, weil der name 'menuitem' is not defined . Nach dem Gehen und dem Umschauen auf Stack Overflow bekam ich die gewünschten Ergebnisse mit einer reduce Aussage:

 reduce(list.__add__, map(lambda x: list(x), list_of_menuitems)) 

Aber diese Methode ist ziemlich unleserlich, weil ich diese list(x) anrufen muss, da x ein Django QuerySet Objekt ist.

Schlussfolgerung :

Danke an alle, die zu dieser Frage beigetragen haben. Hier ist eine Zusammenfassung dessen, was ich gelernt habe. Ich mache auch das eine Community-Wiki, falls andere diese Beobachtungen hinzufügen oder korrigieren möchten.

Meine ursprüngliche reduzierte Aussage ist überflüssig und wird besser so geschrieben:

 >>> reduce(list.__add__, (list(mi) for mi in list_of_menuitems)) 

Dies ist die richtige Syntax für ein verschachteltes Listenverständnis (Brilliant summary dF !):

 >>> [image for mi in list_of_menuitems for image in mi] 

Aber keiner dieser Methoden ist so effizient wie mit itertools.chain :

 >>> from itertools import chain >>> list(chain(*list_of_menuitems)) 

Und als @cdleary Notizen, ist es wahrscheinlich besser Stil zu vermeiden * Operator Magie mit chain.from_iterable wie chain.from_iterable :

 >>> chain = itertools.chain.from_iterable([[1,2],[3],[5,89],[],[6]]) >>> print(list(chain)) >>> [1, 2, 3, 5, 89, 6] 

19 Solutions collect form web for “Abflachen einer flachen Liste in Python [doppelte]”

Wenn Sie nur auf der Suche nach einer abgeflachten Version der Datenstruktur zu iterieren und brauchen keine Wendung Sequenz, betrachten itertools.chain und Unternehmen .

 >>> list_of_menuitems = [['image00', 'image01'], ['image10'], []] >>> import itertools >>> chain = itertools.chain(*list_of_menuitems) >>> print(list(chain)) ['image00', 'image01', 'image10'] 

Es wird auf alles, was ist QuerySet , die Django's QuerySet s, die es scheint, dass Sie in der Frage verwenden.

Edit: Dies ist wahrscheinlich so gut wie eine reduzieren sowieso, weil reduzieren wird die gleiche Overhead Kopieren der Elemente in die Liste, die erweitert wird. chain wird nur diese (gleiche) Overhead, wenn Sie list(chain) am Ende laufen.

Meta-Edit: Eigentlich ist es weniger Overhead als die vorgeschlagene Lösung der Frage, weil du die temporären Listen wegwerfst, die du erschaffst, wenn du das Original mit dem temporären verlängst.

Bearbeiten: Wie JF Sebastian sagt itertools.chain.from_iterable vermeidet das Auspacken und Sie sollten das verwenden, um zu vermeiden * Magie, aber die Timeit App zeigt vernachlässigbare Leistungsunterschied.

Sie haben es fast! Der Weg, um verschachtelte Listenverständnisse zu tun, ist, die Aussagen in der gleichen Reihenfolge zu setzen, wie sie in regelmäßigen Verschachtelten for Aussagen gehen würden.

Also das

 for inner_list in outer_list: for item in inner_list: ... 

entspricht

 [... for inner_list in outer_list for item in inner_list] 

Also du möchtest

 [image for menuitem in list_of_menuitems for image in menuitem] 

@ S.Lott : Du hast mich dazu inspiriert, eine timeit app zu schreiben.

Ich dachte, es würde auch variieren je nach Anzahl der Partitionen (Anzahl der Iteratoren in der Container-Liste) – Ihr Kommentar nicht erwähnt, wie viele Partitionen gab es von den dreißig Artikel. Diese Handlung plattiert tausend Gegenstände in jedem Lauf, mit unterschiedlicher Anzahl von Trennwänden. Die Gegenstände sind gleichmäßig auf die Trennwände verteilt.

Abflachen Vergleich

Code (Python 2.6):

 #!/usr/bin/env python2.6 """Usage: %prog item_count""" from __future__ import print_function import collections import itertools import operator from timeit import Timer import sys import matplotlib.pyplot as pyplot def itertools_flatten(iter_lst): return list(itertools.chain(*iter_lst)) def itertools_iterable_flatten(iter_iter): return list(itertools.chain.from_iterable(iter_iter)) def reduce_flatten(iter_lst): return reduce(operator.add, map(list, iter_lst)) def reduce_lambda_flatten(iter_lst): return reduce(operator.add, map(lambda x: list(x), [i for i in iter_lst])) def comprehension_flatten(iter_lst): return list(item for iter_ in iter_lst for item in iter_) METHODS = ['itertools', 'itertools_iterable', 'reduce', 'reduce_lambda', 'comprehension'] def _time_test_assert(iter_lst): """Make sure all methods produce an equivalent value. :raise AssertionError: On any non-equivalent value.""" callables = (globals()[method + '_flatten'] for method in METHODS) results = [callable(iter_lst) for callable in callables] if not all(result == results[0] for result in results[1:]): raise AssertionError def time_test(partition_count, item_count_per_partition, test_count=10000): """Run flatten methods on a list of :param:`partition_count` iterables. Normalize results over :param:`test_count` runs. :return: Mapping from method to (normalized) microseconds per pass. """ iter_lst = [[dict()] * item_count_per_partition] * partition_count print('Partition count: ', partition_count) print('Items per partition:', item_count_per_partition) _time_test_assert(iter_lst) test_str = 'flatten(%r)' % iter_lst result_by_method = {} for method in METHODS: setup_str = 'from test import %s_flatten as flatten' % method t = Timer(test_str, setup_str) per_pass = test_count * t.timeit(number=test_count) / test_count print('%20s: %.2f usec/pass' % (method, per_pass)) result_by_method[method] = per_pass return result_by_method if __name__ == '__main__': if len(sys.argv) != 2: raise ValueError('Need a number of items to flatten') item_count = int(sys.argv[1]) partition_counts = [] pass_times_by_method = collections.defaultdict(list) for partition_count in xrange(1, item_count): if item_count % partition_count != 0: continue items_per_partition = item_count / partition_count result_by_method = time_test(partition_count, items_per_partition) partition_counts.append(partition_count) for method, result in result_by_method.iteritems(): pass_times_by_method[method].append(result) for method, pass_times in pass_times_by_method.iteritems(): pyplot.plot(partition_counts, pass_times, label=method) pyplot.legend() pyplot.title('Flattening Comparison for %d Items' % item_count) pyplot.xlabel('Number of Partitions') pyplot.ylabel('Microseconds') pyplot.show() 

Bearbeiten: Beschlossen, es Community-Wiki zu machen.

Hinweis: METHODS sollten wahrscheinlich mit einem Dekorateur angesammelt werden, aber ich METHODS es wäre einfacher für die Menschen auf diese Weise zu lesen.

sum(list of lists, []) würde es glätten.

 l = [['image00', 'image01'], ['image10'], []] print sum(l,[]) # prints ['image00', 'image01', 'image10'] 

Diese Lösung arbeitet für beliebige Nisttiefe – nicht nur die "Liste der Listen", die manche (alle?) Der anderen Lösungen beschränken:

 def flatten(x): result = [] for el in x: if hasattr(el, "__iter__") and not isinstance(el, basestring): result.extend(flatten(el)) else: result.append(el) return result 

Es ist die Rekursion, die eine beliebige Tiefenverschachtelung ermöglicht – bis Sie die maximale Rekursionstiefe natürlich …

In Python 2.6, mit chain.from_iterable() :

 >>> from itertools import chain >>> list(chain.from_iterable(mi.image_set.all() for mi in h.get_image_menu())) 

Es vermeidet die Erstellung einer Zwischenliste.

Leistungsergebnisse. Überarbeitet.

 import itertools def itertools_flatten( aList ): return list( itertools.chain(*aList) ) from operator import add def reduce_flatten1( aList ): return reduce(add, map(lambda x: list(x), [mi for mi in aList])) def reduce_flatten2( aList ): return reduce(list.__add__, map(list, aList)) def comprehension_flatten( aList ): return list(y for x in aList for y in x) 

Ich habe eine 2-stufige Liste von 30 Items 1000 Mal abgeflacht

 itertools_flatten 0.00554 comprehension_flatten 0.00815 reduce_flatten2 0.01103 reduce_flatten1 0.01404 

Reduzieren ist immer eine schlechte Wahl.

Es scheint eine Verwirrung mit operator.add ! Wenn du zwei Listen zusammenfügst, ist der richtige Begriff dafür concat , nicht hinzufügen. operator.concat ist was Sie brauchen, um zu verwenden.

Wenn Sie funktional denken, ist es so einfach wie das ::

 >>> list2d = ((1,2,3),(4,5,6), (7,), (8,9)) >>> reduce(operator.concat, list2d) (1, 2, 3, 4, 5, 6, 7, 8, 9) 

Sie sehen, verringert Respekt der Sequenz-Typ, also, wenn Sie ein Tupel liefern, erhalten Sie ein Tupel zurück. Lass uns mit einer Liste versuchen

 >>> list2d = [[1,2,3],[4,5,6], [7], [8,9]] >>> reduce(operator.concat, list2d) [1, 2, 3, 4, 5, 6, 7, 8, 9] 

Aha, du bekommst eine Liste zurück.

Wie wäre es mit der Leistung?

 >>> list2d = [[1,2,3],[4,5,6], [7], [8,9]] >>> %timeit list(itertools.chain.from_iterable(list2d)) 1000000 loops, best of 3: 1.36 µs per loop 

From_iterable ist ziemlich schnell! Aber es ist kein Vergleich, um mit Concat zu reduzieren.

 >>> list2d = ((1,2,3),(4,5,6), (7,), (8,9)) >>> %timeit reduce(operator.concat, list2d) 1000000 loops, best of 3: 492 ns per loop 

Von der Oberseite meines Kopfes kannst du das Lambda beseitigen:

 reduce(list.__add__, map(list, [mi.image_set.all() for mi in list_of_menuitems])) 

Oder sogar die Karte zu beseitigen, da du schon eine List-Comp bekommen hast:

 reduce(list.__add__, [list(mi.image_set.all()) for mi in list_of_menuitems]) 

Sie können dies auch nur als eine Summe von Listen ausdrücken:

 sum([list(mi.image_set.all()) for mi in list_of_menuitems], []) 

Hier ist die richtige Lösung mit List-Verständnis (sie sind rückwärts in der Frage):

 >>> join = lambda it: (y for x in it for y in x) >>> list(join([[1,2],[3,4,5],[]])) [1, 2, 3, 4, 5] 

In deinem Fall wäre es so

 [image for menuitem in list_of_menuitems for image in menuitem.image_set.all()] 

Oder du könntest join und sagen

 join(menuitem.image_set.all() for menuitem in list_of_menuitems) 

In beiden Fällen war die Gotcha die Nist der Schlinge.

Hast du es geschafft? Von matplotlib.cbook.flatten (seq, scalarp =) ?

 l=[[1,2,3],[4,5,6], [7], [8,9]]*33 run("list(flatten(l))") 3732 function calls (3303 primitive calls) in 0.007 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.000 0.000 0.007 0.007 <string>:1(<module>) 429 0.001 0.000 0.001 0.000 cbook.py:475(iterable) 429 0.002 0.000 0.003 0.000 cbook.py:484(is_string_like) 429 0.002 0.000 0.006 0.000 cbook.py:565(is_scalar_or_string) 727/298 0.001 0.000 0.007 0.000 cbook.py:605(flatten) 429 0.000 0.000 0.001 0.000 core.py:5641(isMaskedArray) 858 0.001 0.000 0.001 0.000 {isinstance} 429 0.000 0.000 0.000 0.000 {iter} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} l=[[1,2,3],[4,5,6], [7], [8,9]]*66 run("list(flatten(l))") 7461 function calls (6603 primitive calls) in 0.007 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.000 0.000 0.007 0.007 <string>:1(<module>) 858 0.001 0.000 0.001 0.000 cbook.py:475(iterable) 858 0.002 0.000 0.003 0.000 cbook.py:484(is_string_like) 858 0.002 0.000 0.006 0.000 cbook.py:565(is_scalar_or_string) 1453/595 0.001 0.000 0.007 0.000 cbook.py:605(flatten) 858 0.000 0.000 0.001 0.000 core.py:5641(isMaskedArray) 1716 0.001 0.000 0.001 0.000 {isinstance} 858 0.000 0.000 0.000 0.000 {iter} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} l=[[1,2,3],[4,5,6], [7], [8,9]]*99 run("list(flatten(l))") 11190 function calls (9903 primitive calls) in 0.010 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.000 0.000 0.010 0.010 <string>:1(<module>) 1287 0.002 0.000 0.002 0.000 cbook.py:475(iterable) 1287 0.003 0.000 0.004 0.000 cbook.py:484(is_string_like) 1287 0.002 0.000 0.009 0.000 cbook.py:565(is_scalar_or_string) 2179/892 0.001 0.000 0.010 0.000 cbook.py:605(flatten) 1287 0.001 0.000 0.001 0.000 core.py:5641(isMaskedArray) 2574 0.001 0.000 0.001 0.000 {isinstance} 1287 0.000 0.000 0.000 0.000 {iter} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} l=[[1,2,3],[4,5,6], [7], [8,9]]*132 run("list(flatten(l))") 14919 function calls (13203 primitive calls) in 0.013 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.000 0.000 0.013 0.013 <string>:1(<module>) 1716 0.002 0.000 0.002 0.000 cbook.py:475(iterable) 1716 0.004 0.000 0.006 0.000 cbook.py:484(is_string_like) 1716 0.003 0.000 0.011 0.000 cbook.py:565(is_scalar_or_string) 2905/1189 0.002 0.000 0.013 0.000 cbook.py:605(flatten) 1716 0.001 0.000 0.001 0.000 core.py:5641(isMaskedArray) 3432 0.001 0.000 0.001 0.000 {isinstance} 1716 0.001 0.000 0.001 0.000 {iter} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' 

UPDATE Was gab mir noch eine Idee:

 l=[[1,2,3],[4,5,6], [7], [8,9]]*33 run("flattenlist(l)") 564 function calls (432 primitive calls) in 0.000 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 133/1 0.000 0.000 0.000 0.000 <ipython-input-55-39b139bad497>:4(flattenlist) 1 0.000 0.000 0.000 0.000 <string>:1(<module>) 429 0.000 0.000 0.000 0.000 {isinstance} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} l=[[1,2,3],[4,5,6], [7], [8,9]]*66 run("flattenlist(l)") 1125 function calls (861 primitive calls) in 0.001 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 265/1 0.001 0.000 0.001 0.001 <ipython-input-55-39b139bad497>:4(flattenlist) 1 0.000 0.000 0.001 0.001 <string>:1(<module>) 858 0.000 0.000 0.000 0.000 {isinstance} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} l=[[1,2,3],[4,5,6], [7], [8,9]]*99 run("flattenlist(l)") 1686 function calls (1290 primitive calls) in 0.001 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 397/1 0.001 0.000 0.001 0.001 <ipython-input-55-39b139bad497>:4(flattenlist) 1 0.000 0.000 0.001 0.001 <string>:1(<module>) 1287 0.000 0.000 0.000 0.000 {isinstance} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} l=[[1,2,3],[4,5,6], [7], [8,9]]*132 run("flattenlist(l)") 2247 function calls (1719 primitive calls) in 0.002 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 529/1 0.001 0.000 0.002 0.002 <ipython-input-55-39b139bad497>:4(flattenlist) 1 0.000 0.000 0.002 0.002 <string>:1(<module>) 1716 0.001 0.000 0.001 0.000 {isinstance} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} l=[[1,2,3],[4,5,6], [7], [8,9]]*1320 run("flattenlist(l)") 22443 function calls (17163 primitive calls) in 0.016 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 5281/1 0.011 0.000 0.016 0.016 <ipython-input-55-39b139bad497>:4(flattenlist) 1 0.000 0.000 0.016 0.016 <string>:1(<module>) 17160 0.005 0.000 0.005 0.000 {isinstance} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} 

So zu testen, wie effektiv es ist, wenn rekursiv tiefer wird: Wie viel tiefer?

 l=[[1,2,3],[4,5,6], [7], [8,9]]*1320 new=[l]*33 run("flattenlist(new)") 740589 function calls (566316 primitive calls) in 0.418 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 174274/1 0.281 0.000 0.417 0.417 <ipython-input-55-39b139bad497>:4(flattenlist) 1 0.001 0.001 0.418 0.418 <string>:1(<module>) 566313 0.136 0.000 0.136 0.000 {isinstance} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} new=[l]*66 run("flattenlist(new)") 1481175 function calls (1132629 primitive calls) in 0.809 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 348547/1 0.542 0.000 0.807 0.807 <ipython-input-55-39b139bad497>:4(flattenlist) 1 0.002 0.002 0.809 0.809 <string>:1(<module>) 1132626 0.266 0.000 0.266 0.000 {isinstance} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} new=[l]*99 run("flattenlist(new)") 2221761 function calls (1698942 primitive calls) in 1.211 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 522820/1 0.815 0.000 1.208 1.208 <ipython-input-55-39b139bad497>:4(flattenlist) 1 0.002 0.002 1.211 1.211 <string>:1(<module>) 1698939 0.393 0.000 0.393 0.000 {isinstance} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} new=[l]*132 run("flattenlist(new)") 2962347 function calls (2265255 primitive calls) in 1.630 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 697093/1 1.091 0.000 1.627 1.627 <ipython-input-55-39b139bad497>:4(flattenlist) 1 0.003 0.003 1.630 1.630 <string>:1(<module>) 2265252 0.536 0.000 0.536 0.000 {isinstance} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} new=[l]*1320 run("flattenlist(new)") 29623443 function calls (22652523 primitive calls) in 16.103 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 6970921/1 10.842 0.000 16.069 16.069 <ipython-input-55-39b139bad497>:4(flattenlist) 1 0.034 0.034 16.103 16.103 <string>:1(<module>) 22652520 5.227 0.000 5.227 0.000 {isinstance} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} 

Ich werde wetten "flattenlist" Ich werde diese eher als matploblib für eine lange lange Zeit verwenden, wenn ich nicht einen Renditegenerator und schnelles Ergebnis als "Flatten" verwendet in matploblib.cbook

Das ist schnell.

  • Und hier ist der Code

:

 typ=(list,tuple) def flattenlist(d): thelist = [] for x in d: if not isinstance(x,typ): thelist += [x] else: thelist += flattenlist(x) return thelist 

Diese Version ist ein Generator.Tweak it, wenn Sie eine Liste wollen.

 def list_or_tuple(l): return isinstance(l,(list,tuple)) ## predicate will select the container to be flattened ## write your own as required ## this one flattens every list/tuple def flatten(seq,predicate=list_or_tuple): ## recursive generator for i in seq: if predicate(seq): for j in flatten(i): yield j else: yield i 

Sie können ein Prädikat hinzufügen, wenn Sie diejenigen, die eine Bedingung erfüllen, flachstellen möchten

Genommen aus python Kochbuch

Aus meiner Erfahrung ist der effizienteste Weg, um eine Liste von Listen zu platzieren:

 flat_list = [] map(flat_list.extend, list_of_list) 

Einige zeitliche Vergleiche mit den anderen vorgeschlagenen Methoden:

 list_of_list = [range(10)]*1000 %timeit flat_list=[]; map(flat_list.extend, list_of_list) #10000 loops, best of 3: 119 µs per loop %timeit flat_list=list(itertools.chain.from_iterable(list_of_list)) #1000 loops, best of 3: 210 µs per loop %timeit flat_list=[i for sublist in list_of_list for i in sublist] #1000 loops, best of 3: 525 µs per loop %timeit flat_list=reduce(list.__add__,list_of_list) #100 loops, best of 3: 18.1 ms per loop 

Jetzt ist der Effizienzgewinn bei der Verarbeitung längerer Sublisten besser:

 list_of_list = [range(1000)]*10 %timeit flat_list=[]; map(flat_list.extend, list_of_list) #10000 loops, best of 3: 60.7 µs per loop %timeit flat_list=list(itertools.chain.from_iterable(list_of_list)) #10000 loops, best of 3: 176 µs per loop 

Und diese Methoden funktionieren auch mit jedem iterativen Objekt:

 class SquaredRange(object): def __init__(self, n): self.range = range(n) def __iter__(self): for i in self.range: yield i**2 list_of_list = [SquaredRange(5)]*3 flat_list = [] map(flat_list.extend, list_of_list) print flat_list #[0, 1, 4, 9, 16, 0, 1, 4, 9, 16, 0, 1, 4, 9, 16] 

Wie wäre es mit:

 from operator import add reduce(add, map(lambda x: list(x.image_set.all()), [mi for mi in list_of_menuitems])) 

Aber Guido empfiehlt es, zu viel in einer einzigen Codezeile zu führen, da es die Lesbarkeit reduziert. Es gibt minimal, wenn überhaupt, Leistung zu gewinnen, indem Sie, was Sie wollen in einer einzigen Zeile vs mehrere Zeilen.

Pylab bietet eine flache: link zu numpy flatten

Hier ist eine Version, die für mehrere Ebenen der Liste mit collectons.Iterable :

 import collections def flatten(o): result = [] for i in o: if isinstance(i, collections.Iterable): result.extend(flatten(i)) else: result.append(i) return result 

Wenn jedes Element in der Liste ein String ist (und alle Strings innerhalb dieser Strings verwenden "" anstatt "'), können Sie reguläre Ausdrücke ( re Modul)

 >>> flattener = re.compile("\'.*?\'") >>> flattener <_sre.SRE_Pattern object at 0x10d439ca8> >>> stred = str(in_list) >>> outed = flattener.findall(stred) 

Der obige Code konvertiert in_list in einen String, verwendet den Regex, um alle Teilstrings innerhalb von Anführungszeichen (dh jedes Element der Liste) zu finden und sie als Liste auszuspucken.

Wenn Sie eine kompliziertere Liste mit nicht lesbaren Elementen oder mit einer Tiefe von mehr als 2 flach haben, können Sie folgende Funktion verwenden:

 def flat_list(list_to_flat): if not isinstance(list_to_flat, list): yield list_to_flat else: for item in list_to_flat: yield from flat_list(item) 

Es wird das Generatorobjekt zurückgeben, das Sie mit der list() Funktion in die Liste umwandeln können. Beachten Sie, dass die yield from Syntax von python3.3 verfügbar ist, aber Sie können stattdessen explizite Iteration verwenden.
Beispiel:

 >>> a = [1, [2, 3], [1, [2, 3, [1, [2, 3]]]]] >>> print(list(flat_list(a))) [1, 2, 3, 1, 2, 3, 1, 2, 3] 

Wenn Sie nach einem eingebauten, einfachen Ein-Liner suchen, können Sie:

 a = [[1, 2, 3], [4, 5, 6] b = [i[x] for i in a for x in range(len(i))] print b 

kehrt zurück

 [1, 2, 3, 4, 5, 6] 
Python ist die beste Programmiersprache der Welt.