递归地遍历Python中列表的子项

Question

I try to recursively print sentences from a nested list of lists

I want to obtain a list containing

['big bad dog', 'big fluffy cat', 'small blue happy pony', 'small frog']

Here is my code, it don't work...

Am I on the right path or I should structure my data in an another way to achieve my goal?

from pprint import pprint

dirs = [

{ 
    'kw': 'big',
    'childs': [
        { 
            'kw': 'bad',
            'childs': [
                {
                    'kw': 'dog'
                }
            ]
        },
        {
            'kw': 'fluffy',
            'childs': [
                {
                    'kw': 'cat'
                }
            ]
        }

    ]
},

{ 
    'kw': 'small',
    'childs': [
        { 
            'kw': 'blue',
            'childs': [
                {

                    'kw': 'happy',
                    'childs': [
                        { 
                            'kw': 'pony'

                        }

                    ]
                }
            ]
        },
        {
            'kw': 'frog'

        }

    ]
},
]


def traverse(d, l):

    kw = d.get('kw')
    c = d.get('childs')
    l.append(kw)
    if c:
        for cc in c:
           l = traverse(cc, l)



return l


r = traverse(dirs[0], [])

pprint(r)

Answer 1

Check out this function:

def traverse(d, l, s = None):
  kw = d.get('kw')
  c = d.get('childs')
  if(s == None):
     s = kw
  else:
     s = s + " " +kw
  if c:
      for cc in c:
          l = traverse(cc, l, s)
  else:
      l.append(s)

  return l 

Its a very small modification to your recursion function:

r = traverse(dirs[0], [])

Answer 2

As usual, generators work nicely with recursive structures

def traverse(i):
    for d in i:
        childs = d.get('childs')
        for j in traverse(childs) if childs else ['']:
            yield d['kw']+' '+j

res = list(traverse(dirs))

In Python3.3, this becomes

def traverse(i):
    for d in i:
        c = d.get('childs')
        yield from (d['kw']+' '+j for j in (traverse(c) if c else ['']))

Answer 3

Here's a solution to the given problem, with dirs being the json like structure you defined above. It's recursive, it works and it covers edge cases like the top structure being a dictionary.

def traverse(l, al = "", comps = []):
    if isinstance(l,dict):
        if not al:
            al += l.get("kw")
        else:        
            al += ", %s" % l.get("kw")
        traverse(l.get("childs"), al, comps)
    elif isinstance (l,list):
        for i in l:
            traverse(i, al, comps)
    else:
        comps.append(al)
    return comps

print traverse(dirs)

Answer 4

I would say my solution is pretty simple (change the item lookup for get if you want to handle cases where the key isn't found)

def _traverse(d):
    prefix = d['kw']
    if 'childs' not in d:
        return [prefix]
    results = []
    for subdict in d['childs']:
        subtraversal = _traverse(subdict)
        results.extend(prefix+' '+item for item in subtraversal)
    return results

def traverse(d):
    return list(sum((_traverse(subdict) for subdict in d),[]))

Answer 5

Ah, Gnibbler beat me to the generator hattip. Only difference worth mentioning is " ".join to stitch the sentence and the *syntax to avoid if tests

def traverse_keys(*dictvalues):
    for dictval in dictvalues:
        for token in traverse_keys(*dictval.get('childs', [])):
            yield token
        kw = dictval.get('kw')
        if kw: yield kw

tokens = [kw for kw in traverse_keys (*dirs)]
tokens.reverse()
print " ".join(tokens)

If you dont expect multiple branches in your children, the you can just nest the dictionaries directly - your logic doesn't have a way to choose which branch in the current structure. You could have named branches just by nesting dictionaries:

{ 'kw': 'dog'
  'big': { 'kw': 'scary' } 
  'small': { 'kw': 'yippy',  'fluffy': { 'kw': 'poodle'} }
}

which would make the traversal cleaner