Convertir les arguments en liste à plat?

Question

Je sais que c'est très similaires à quelques autres questions, mais je ne peux pas vraiment obtenir cette fonction pour fonctionner correctement.

def flatten(*args): 
    return list(item for iterable in args for item in iterable) 

La sortie Je cherche est:

flatten(1) -> [1] 
flatten(1,[2]) -> [1, 2] 
flatten([1,[2]]) -> [1, 2] 

La fonction actuelle, que je pris d'une autre réponse SO, ne semble pas produire des résultats corrects du tout:

>>> flatten([1,[2]]) 
[1, [2]] 

Answer 1

Pour une solution rapide, il suffit de prendre votre deuxième fonction et la rendre récursive.

def flatten(*args): 
    output = [] 
    for arg in args: 
     if hasattr(arg, '__iter__'): 
      output.extend(flatten(*arg)) 
     else: 
      output.append(arg) 
    return output 

Answer 2

Si vous voulez aplatir les listes arbitrairement imbriquées vous avez besoin d'une fonction récursive:

def flatten(ls): 
    if isinstance(ls, list): 
    return [fa for a in ls for fa in flatten(a)] 
    else: 
    return [ls] 

(Si vous prévoyez d'aplatir les grandes structures cela pourrait être rendu plus efficace en utilisant des générateurs au lieu des listes de retour.)

Cette fonction peut également être réutilisée pour créer une fonction qui prend plusieurs paramètres:

def pflatten(*ls): 
    return flatten(list(ls)) 

Answer 3

résolu le problème ...

def flatlist(*args): 
    lst = [] 
    for a in args: 
     if hasattr(a, '__iter__'): lst.extend(flatlist(*a)) 
     else: lst.append(a) 
    return lst 

Answer 4

Vérification __ __ iter présence peut être assez étrange quand aplatissement dictionnaire:

>>> def flatten(*args): 
...  output = [] 
...  for arg in args: 
...   if hasattr(arg, '__iter__'): 
...    output.extend(flatten(*arg)) 
...   else: 
...    output.append(arg) 
...  return output 
... 
>>> adict = {1:2, 3:4, 5:6} 
>>> blist = ['a', 'b', 'c'] 
>>> raw = [adict, blist] 
>>> flatten(raw) 
[1, 3, 5, 'a', 'b', 'c'] 

Je pense que aplatissent devrait fonctionner pour les listes et tuples seulement:

import types 

def flatten(*args): 
    output = [] 
    for arg in args: 
     if isinstance(arg, (types.ListType, types.TupleType)): 
      output.extend(flatten(*list(arg))) 
     else: 
      output.append(arg) 
    return output 

adict = {1:2, 3:4, 5:6} 
blist = ['a', 'b', 'c'] 
raw = [adict, blist] 
print flatten(raw)