2
votes

Convertir une liste irrégulière avec plusieurs niveaux de listes imbriquées en une liste de listes

J'ai des données dans une liste imbriquée désordonnée avec de nombreux (sous) niveaux différents. Je ne me soucie pas vraiment de ces niveaux et je veux juste les données dans une grande liste de listes.

J'ai déjà cherché comment aplatir une liste de liste ou une liste imbriquée (par exemple ici , ici et ici ), mais les solutions à ces problèmes ne sont pas applicables ici (je pense).

Donc, fondamentalement, ce dont j'ai besoin est:

nested_list = [[[1, 2, 3], [[5, 6, 7], [8, 9, 10, 11, 23]]], [4], [[12, 13, 14], [[15, 16], [[17, 18], [19, 20]]]], [21, 22, 25, 26]]
unnested_list = nested_to_listoflist( nested_list )
#=> [ [1, 2, 3], [5, 6, 7], [8, 9, 10, 11, 23], [4], [12, 13, 14], [15, 16], [17, 18], [19, 20], [21, 22, 25, 26] ]

Des suggestions?

python list flatten

0 commentaires

5 Réponses :

1
votes

Je pense que cela fera l'affaire pour vous,

open_ = []
open_.append(nested_list)
res = []
while len(open_) > 0:
    element = open_.pop()
    for item in element:
        if isinstance(item, list):
            open_.append(item)
        else:
            res.append(element)
            break

0 commentaires

1
votes

Une manière amusante de le faire (déconseillée):

l = str(nested_l)
inner = False
new_l = "["

for i in range(2,len(l)):
    if l[i] == "]" and inner:
        inner = False
    elif l[i] == "[" and not inner:
        inner = True
    elif l[i] == "[" and inner or l[i] == "]" and not inner:
        continue
    new_l+=l[i]

new_l += "]"
new_l = eval(new_l)

1 commentaires

c'est marrant, tu as beaucoup de temps: D

2
votes

La fonction de générateur aplatir reçoit une liste et examine chaque sous-liste. Si la longueur de la sous-liste est égale à 0 ou si le premier élément de la sous-liste n'est pas une autre liste, il renvoie simplement la sous-liste en tant que liste suivante à ajouter au résultat. Sinon, il traite la sous-liste de manière récursive. La fonction nested_to_listoflist rassemble simplement toutes les listes "générées" en une seule liste finale.

[[1, 2, 3], [5, 6, 7], [8, 9, 10, 11, 23], [4], [12, 13, 14], [15, 16], [17, 18], [19, 20], [21, 22, 25, 26]]

Imprime:

def flatten(l):
    for el in l:
        if not el or not isinstance(el[0], list):
            yield el
        else:
            yield from flatten(el)

def nested_to_listoflist(l):
    return [el for el in flatten(l)]
    # or return list(flatten(l))


nested_list = [[[1, 2, 3], [[5, 6, 7], [8, 9, 10, 11, 23]]], [4], [[12, 13, 14], [[15, 16], [[17, 18], [19, 20]]]], [21, 22, 25, 26]]
unnested_list = nested_to_listoflist(nested_list)
print(unnested_list)

Démo Python

0 commentaires

1
votes

Essayez ceci:

def nested_to_listoflist(nested_list):
    if len(nested_list) == 0 or not isinstance(nested_list[0], list):
        return [nested_list]

    unnested_list = []
    for l in nested_list:
        unnested_list += nested_to_listoflist(l)

    return unnested_list

0 commentaires

0
votes

Vous pouvez utiliser cet algorithme récursif:

def flatten(l):
    result = []
    for item in l:
        if isinstance(item,list):
            if len(item)>0 and isinstance(item[0], list):
                result.extend(flatten(item))  #  recursion
            else:             
                result.append(item)
        else:
            result.append([item])   # decide what to do with stand_alone integers
    return result

nested_list = [[[1, 2, 3], [[5, 6, 7], [8, 9, 10, 11, 23]]], [], [[12, 13, 14], [[15, 16], [[17, 18], [19, 20]]]], [21, 22, 25, 26],3]
flattened_list = flatten(nested_list)

#  [[1, 2, 3], [5, 6, 7], [8, 9, 10, 11, 23], [], [12, 13, 14], [15, 16], [17, 18], [19, 20], [21, 22, 25, 26], [3]]

0 commentaires