Python idioma: propagazione dei rendimenti o sequenze di appiattimento?

Question

Sto scrivendo un funzione di attraversamento albero DF ampiezza, e quello che voglio fare è questo:

def traverse(node): 
    yield node 
    for n in node.children: 
     yield_all traverse(n) # << if Python had a yield_all statement 

L'idea è di finire con un (piatta) sequenza di nodi nell'albero .

Approccio # 1: (i rendimenti che si propagano)

def traverse(node): 
    yield node 
    for n in node.children: 
     for m in traverse(n): 
      yield m 

Approccio # 2: (sequenze appiattimento)

def traverse(node): 
    return itertools.chain([node],*(traverse(n) for n in node.children)) 

Il primo approccio sembra più pulito, ma mi sento strano esplicitamente yield ing ogni nodo nella sottostruttura di ogni livello.

Il secondo approccio è terso e un po 'sporca, ma corrisponde a ciò che avrei scritto in Haskell:

traverse node = node : concatMap traverse (children node) 

Quindi la mia domanda è: quale è meglio? O mi manca una migliore terza opzione?

Answer 1

[UPDATE] CfrPEP-380, questo rendimento tutto sintassi è disponibile a partire da Python 3.3 come yield from:

def traverse(node): 
    yield node 
    for n in node.children: 
     yield from traverse(n) 

Answer 2

mi piacerebbe andare con il primo. Si supererà la propagazione dei rendimenti dopo un paio di volte. :-)

Answer 3

Questa è una domanda di opinioni, quindi tutte le risposte saranno solo giudizi di valore. Per quanto posso pensare, non c'è una terza via elegante, però.

La mia opinione è che il primo modo vince a mani basse. È più chiaro e più facile da leggere - Python non è Haskell, anche se può fare qualcosa di funzionale, e spesso l'approccio funzionale non è così semplice.

Answer 4

Avanzamento con posizione di nodo:

def iter_tree(t, i=0, j=0): 
    yield (i, j), t 
    for j, n in enumerate(t.children): 
     yield from iter_tree(n, i + 1, j) 

for (i, j), n in iter_tree(t): 
    print(i*' ', (i, j), n)