Esiste un modo funzionale per farlo?

Question

def flattenList(toFlatten): 
final=[] 
for el in toFlatten: 
    if isinstance(el, list): 
    final.extend(flattenList(el)) 
    else: 
    final.append(el) 
return final 

Quando non so quanto profondamente le liste si annidano, questo è l'unico modo in cui posso pensare di farlo.

Answer 1

Ecco un'altra opzione (se ci possono essere qualcosa di più pulito di tipo controllo, come il test se qualcosa è iterabile e quindi non un "atomo"):

def flatten(lst): 
    if not isinstance(lst,list): 
     return [lst] 
    else: 
     return reduce(lambda x,y:x+y,[flatten(x) for x in lst],[]) 

Si basa su qualcosa di schema simile.

Answer 2

1. Si dovrebbe evitare il typechecking in Python. In questo caso, ciò significa evitare strutture nidificate arbitrariamente dove si distingue per tipo. Puoi creare il tuo tipo di nodo che puoi percorrere con i metodi altro rispetto a typechecking, come guardare un attributo specifico.

2. Per appiattire un livello o esattamente n livelli, vedere itertools.chain.from_iterable.

3. Non so cosa intendi per "funzionale". Questo codice è piuttosto funzionale: usa la ricorsione (non al suo merito!) E non modifica la sua argomentazione. (A rigor di termini, si fa uso di stato mutevole per la costruzione di una lista, ma che è proprio come lo si fa in Python.

4. Suppongo che un attributo più funzionale sarebbe la valutazione pigra. Si potrebbe implementare questa convenzione è

   def flatten(toFlatten): 
       for item in toFlatten: 
        if isinstance(item, list): # Ewww, typchecking 
         for subitem in flatten(item): # they are considering adding 
          yield subitem    # "yield from" to the language 
                 # to give this pattern syntax 
        else: 
         yield item 
   

5. La ricorsione è molto limitata in Python (almeno, in tutte le sue principali implementazioni) e generalmente dovrebbe essere evitata per profondità arbitrarie.È abbastanza possibile riscrivere questo (e tutto il codice ricorsivo) per usare l'iterazione, che renderà questo più scalabile (e meno funzionale, che è una buona cosa in Python, che non è particolarmente adatto per FP.)

Answer 3

Sotto la doc per itertools, c'è una funzione di flatten()

Answer 4

Questa risposta spiega il motivo per cui non si desidera utilizzare reduce per questo in Python.

Si consideri il frammento di

reduce(operator.add, [[1], [2], [3], [4], [5]]) 

Che cosa ha a che fare?

[1] + [2] => [1, 2] 
[1, 2] + [3] => This makes a new list, having to go over 1, then 2, then 3. [1, 2, 3] 
[1, 2, 3] + [4] => This has to copy the 1, 2, and 3 and then put 4 in the new list 
[1, 2, 3, 4] + [5] => The length of stuff I have to copy gets bigger each time! 

Questo comportamento quadratico è completamente evitabile: la soluzione originale (e qualsiasi numero di altre soluzioni) non costituisce questi passaggi di copia intermedi.