Eine unregelmäßige Liste von Listen abflachen

Question

Ja, ich weiß, dass dieses Thema schon einmal behandelt wurde ( aquí , aquí , aquí , aquí ), aber soweit ich weiß, scheitern alle Lösungen, außer einer, an einer solchen Liste:

L = [[[1, 2, 3], [4, 5]], 6]

Die gewünschte Leistung ist

[1, 2, 3, 4, 5, 6]

Oder vielleicht noch besser, ein Iterator. Die einzige Lösung, die ich gesehen habe, die für eine beliebige Verschachtelung funktioniert, ist gefunden in dieser Frage :

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

flatten(L)

Ist dies das beste Modell? Habe ich etwas übersehen? Gibt es Probleme?

Answer 1

Ich bin überrascht, dass noch niemand auf diese Idee gekommen ist. Verdammt Rekursion ich nicht bekommen, die rekursive Antworten, die die fortgeschrittenen Menschen hier gemacht. sowieso hier ist mein Versuch auf diese. caveat ist es sehr spezifisch für die OP Anwendungsfall

import re

L = [[[1, 2, 3], [4, 5]], 6]
flattened_list = re.sub("[\[\]]", "", str(L)).replace(" ", "").split(",")
new_list = list(map(int, flattened_list))
print(new_list)

Ausgabe:

[1, 2, 3, 4, 5, 6]

Answer 2

Hier ist die compiler.ast.flatten Implementierung in 2.7.5:

def flatten(seq):
    l = []
    for elt in seq:
        t = type(elt)
        if t is tuple or t is list:
            for elt2 in flatten(elt):
                l.append(elt2)
        else:
            l.append(elt)
    return l

Es gibt bessere, schnellere Methoden (wenn Sie hierher gekommen sind, haben Sie sie bereits gesehen)

Beachten Sie auch:

Veraltet seit Version 2.6: Das Compiler-Paket wurde in Python 3 entfernt.

Answer 3

Der einfachste Weg ist die Verwendung der morph Bibliothek mit pip install morph .

Der Code lautet:

import morph

list = [[[1, 2, 3], [4, 5]], 6]
flattened_list = morph.flatten(list)  # returns [1, 2, 3, 4, 5, 6]

Answer 4

Ich bin ein dummer Kerl, also werde ich eine "dumme" Lösung geben. Diese ganze Rekursion tut meinem Gehirn weh.

flattened_list = []
nested_list = [[[1, 2, 3], [4, 5]], 6]

def flatten(nested_list, container):
    for item in nested_list:
        if isintance(item, list):
            flatten(item, container)
        else:
            container.append(item)

>>> flatten(nested_list, flattened_list)
>>> flattened_list
[1, 2, 3, 4, 5, 6]

Ich bekomme, dass es mit einem Nebeneffekt, aber gut, das ist zum Besten von meinem Verständnis der Rekursion gehen kann

Answer 5

Damit wird eine Liste oder ein Wörterbuch (oder eine Liste von Listen oder Wörterbücher von Wörterbüchern usw.) geglättet. Es wird davon ausgegangen, dass die Werte Strings sind, und es wird ein String erstellt, der jedes Element mit einem Trennzeichen-Argument verkettet. Wenn Sie möchten, können Sie den Separator verwenden, um das Ergebnis anschließend in ein Listenobjekt aufzuteilen. Es verwendet eine Rekursion, wenn der nächste Wert eine Liste oder eine Zeichenkette ist. Mit dem Argument key geben Sie an, ob Sie die Schlüssel oder die Werte (set key to false) aus dem Dictionary-Objekt haben wollen.

def flatten_obj(n_obj, key=True, my_sep=''):
    my_string = ''
    if type(n_obj) == list:
        for val in n_obj:
            my_sep_setter = my_sep if my_string != '' else ''
            if type(val) == list or type(val) == dict:
                my_string += my_sep_setter + flatten_obj(val, key, my_sep)
            else:
                my_string += my_sep_setter + val
    elif type(n_obj) == dict:
        for k, v in n_obj.items():
            my_sep_setter = my_sep if my_string != '' else ''
            d_val = k if key else v
            if type(v) == list or type(v) == dict:
                my_string += my_sep_setter + flatten_obj(v, key, my_sep)
            else:
                my_string += my_sep_setter + d_val
    elif type(n_obj) == str:
        my_sep_setter = my_sep if my_string != '' else ''
        my_string += my_sep_setter + n_obj
        return my_string
    return my_string

print(flatten_obj(['just', 'a', ['test', 'to', 'try'], 'right', 'now', ['or', 'later', 'today'],
                [{'dictionary_test': 'test'}, {'dictionary_test_two': 'later_today'}, 'my power is 9000']], my_sep=', ')

erbringt:

just, a, test, to, try, right, now, or, later, today, dictionary_test, dictionary_test_two, my power is 9000