Jak uzyskać takie zagnieżdżone listy?

Question

variable tree structure 

- nestedList1 variable 

aa3 
| 
aa1  aa2  bb1 
    \ / /
    aa  bb 
     \ /
     root 

- nestedList2 variable 

       bb4 
       | 
aa3   bb2  bb3 
|    \ /
aa1  aa2  bb1 cc1 
    \ / /  | 
    aa  bb   cc 
     \  |  /
       root 

nestedList1 = ['root', ['aa', ['aa1', ['aa3'], 'aa2'], 'bb', ['bb1']]] 
nestedList2 = ['root', ['aa', ['aa1', ['aa3'], 'aa2'], 'bb', ['bb1', ['bb2', ['bb4'], 'bb3']], 'cc', ['cc1']]] 

def ConvertTraverse(nlist, depth=0): 
    convertlist = [] 
    for leaf in nlist: 
     if isinstance(leaf, list): 
      tmplist = ConvertTraverse(leaf, depth+1) 
      convertlist.insert(0, tmplist) 
     else: 
      convertlist += [leaf] 
    return convertlist 

print ConvertTraverse(nestedList1) 
print ConvertTraverse(nestedList2) 

• wynik
  nestedList1: [[['bb1'], [['aa3'], 'aa1', 'aa2'], 'aa', 'bb'], 'root']
  nestedList2: [[['cc1'], [[['bb4'], 'bb2', 'bb3'], 'bb1'], [['aa3'], 'aa1', 'aa2'], 'aa', 'bb', 'cc'], 'root']

Wszystko czego chcę to poniższe wyniki.

• wynik
  nestedList1: [[[['aa3'], 'aa1', 'aa2'], 'aa', ['bb1'], 'bb'], 'root']
  nestedList2: [[[['aa3'], 'aa1', 'aa2'], 'aa', [[['bb4'], 'bb2', 'bb3'], 'bb1'], 'bb', ['cc1'], 'cc'], 'root']

Jak mogę dostać taki zagnieżdżone listy? Chcę listę zagnieżdżoną, uporządkowaną do przemieszczania po zamówieniu.

Answer 1

Zasadniczo, co należy zrobić, aby zmienić kolejność listy: Gdy element n jest etykietą, a element n+1 jest podliścią, zamień te dwa elementy. Można to zrobić w miejscu w kilku linii:

def reorder(lst): 
    for i, (cur, nxt) in enumerate(zip(lst, lst[1:])): 
     if isinstance(cur, str) and isinstance(nxt, list): 
      reorder(nxt) 
      lst[i:i+2] = [nxt, cur] 

Dla rozwiązania nie na miejscu, można po prostu stworzyć głęboko kopię listy, a następnie użyj że na kopii .

Answer 2

Mogę być poza linią lub całkowicie pomijać punkt, ale zaryzykuję twierdzenie, że myślę, że będzie łatwiej, jeśli zbieramy każdą gałąź w pełni do nawiasów. tj napisać każdą gałąź jako charakterystyczny [root [branch1], [Branch2], ...]

nestedList1 = ['root', ['aa', ['aa1', ['aa3']], ['aa2']], ['bb', ['bb1']]] 
nestedList2 = ['root', ['aa', ['aa1', ['aa3']], ['aa2']], ['bb', ['bb1', ['bb2', ['bb4']], ['bb3']]], ['cc', ['cc1']]] 

Następnie można po prostu rekursywnie zmienić kolejność, aby każdy oddział liści-1st, tułowia-2nd.

def recursivereverese(l): 
    if len(l)<=1 or type(l) is not list: 
     return l 
    else: 
     new = [] 
     for k in l[::-1]: 
      new.append(recursivereverese(k)) 
     return new 

Wyniki na zmodyfikowanym nestedlists:

In [127]: recursivereverese(nestedList1) 
Out[127]: [[['bb1'], 'bb'], [['aa2'], [['aa3'], 'aa1'], 'aa'], 'root'] 

In [128]: recursivereverese(nestedList2) 
Out[128]: 
[[['cc1'], 'cc'], 
[[['bb3'], [['bb4'], 'bb2'], 'bb1'], 'bb'], 
[['aa2'], [['aa3'], 'aa1'], 'aa'], 
'root'] 

Czy to, czego szukali?

Odnajdywanie, która gałąź jest głębsza dla ładnego kreślenia, to inny temat.