Traverse verschachtelte Liste mit einzelnen für

Question

Ich habe eine Reihe von Listen in Listen. Die Verschachtelungstiefe wird zur Laufzeit bestimmt, und ich möchte nur auf eine bestimmte (Laufzeit entschieden) Tiefe zugreifen, um das, was auf dieser Ebene ist, beliebig zu manipulieren.

Im Idealfall würde Ich mag Lage sein, dies zu tun, so einfach wie:

for x in access_list(nested_list, d) 
    # do stuff at nesting-depth d 

Was access_list tun soll:

>>> mylist = [[[0, 1], [2, 3]], [[4, 5], [6, 7]]] 
>>> for d in range(4): 
...  for l in access_list(mylist, d): 
...   print((d, l)) 
(0, [[[0, 1], [2, 3]], [[4, 5], [6, 7]]]) 
(1, [[[0, 1], [2, 3]]) 
(1, [[4, 5], [6, 7]]]) 
(2, [0, 1]) 
(2, [2, 3]) 
(2, [4, 5]) 
(2, [6, 7]) 
(3, 0) 
(3, 1) 
(3, 2) 
(3, 3) 
(3, 4) 
(3, 5) 
(3, 6) 
(3, 7) 

Mein Versuch erwies sich im Wesentlichen nichts zu tun:

def access_list(lists, d): 
    if not d: 
     return lists 
    return [access_list(_list, d-1) for _list in lists] 

Es gibt nur die gesamte Listenstruktur wieder zurück. Was kann ich tun, damit dies funktioniert?

Answer 1

Dieser Generator-Funktion für verschachtelte Listen arbeiten sollte und spart Speicherplatz, da es keine Liste selbst, sondern gemächlich produziert hat bauen die Elemente:

def access_list(nested_list): 
    if not isinstance(nested_list, list): 
    # if not isinstance(nested_list, (list, set)): you get the idea 
     yield nested_list 
    else: 
     for item in nested_list: 
      for x in access_list(item): 
       yield x 
      # in Python 3, you can replace that loop by: 
      # yield from access_list(item) 
    return 

> l = [1, 2, [3, [4, 5], 6]] 
> list(access_list(l)) 
[1, 2, 3, 4, 5, 6] 

Wenn Sie Zugriff auf Schachtelungstiefe wollen, wird die folgende erzeugen (item, depth) Paare:

def access_list(nested_list, d=0): 
    if not isinstance(nested_list, list): 
     yield nested_list, d 
    else: 
     for item in nested_list: 
      for x in access_list(item, d=d+1): 
       yield x 
    return 

> l = [1, 2, [3, [4, 5], 6]] 
> list(access_list(l)) 
[(1, 1), (2, 1), (3, 2), (4, 3), (5, 3), (6, 2)] 

Answer 2

Betrachten Sie diese Lösung:

def access_list(lists, d): 
    if not d: 
     return lists 
    else: 
     return sum(access_list(lists, d-1), []) 

Zum Beispiel mit dieser Liste: l=[[[1,2],[3]],[[4],[5,[6,7]]]]:

>>> access_list(l, 0) 
[[1, 2], [3]] 
[[4], [5, [6, 7]]] 

>>> access_list(l, 1) 
[1, 2] 
[3] 
[4] 
[5, [6, 7]] 

>>> access_list(l, 1) 
1 
2 
3 
4 
5 
[6, 7] 

Answer 3

Sie numpy Arrays verwenden könnten, es

import numpy 
def access_list(lists, d): 
    _lists=numpy.array(lists) 
    if not d: 
     L=[] 
     for index in range(len(_lists)): 
      L.append(_lists[index]) 
     return L 
    return _lists[:] 

Answer 4

Ziemlich nahe arbeiten kann! Versuchen Sie, die Listen in immer kleinere Teile aufzuteilen.

def access_list(x, d): 
    if d and isinstance(x, list) and x: 
     return access_list(x[0], d-1) + access_list(x[1:], d-1) 
    return [x] 

Okay, hatte gehofft, diese Ursache zu vermeiden, ist es etwas komplizierter ist, aber dies gibt die genaue Ausgabe für Sie hoffen:

def access_list(x, d): 
    def _access_list(x, d): 
     if d and isinstance(x, types.ListType) and x: 
      return access_list(x[0], d-1) + access_list(x[1:], d) 
     return [x] 
    return filter(lambda x: x, _access_list(x, d))