compréhension de la liste python; compresser une liste de listes?

Question

les gars. J'essaie de trouver la solution la plus élégante à un problème et me demande si python a quelque chose de intégré pour ce que j'essaie de faire.

Ce que je fais est ceci. J'ai une liste, A, et j'ai une fonction f qui prend un article et renvoie une liste. Je peux utiliser une compréhension de liste pour tout convertir en A comme ça;

[f(a) for a in A] 

Mais cela retourne une liste de listes;

[a1,a2,a3] => [[b11,b12],[b21,b22],[b31,b32]] 

Ce que je veux vraiment, c'est obtenir la liste aplatie;

[b11,b12,b21,b22,b31,b32] 

Maintenant, d'autres langues l'ont; il est traditionnellement appelé flatmap dans les langages de programmation fonctionnels, et .Net l'appelle SelectMany. Est-ce que python a quelque chose de similaire? Existe-t-il une manière ordonnée de mapper une fonction sur une liste et d'aplatir le résultat?

Le problème que j'essaie de résoudre est le suivant: en commençant par une liste de répertoires, trouvez tous les sous-répertoires. alors;

import os 
dirs = ["c:\\usr", "c:\\temp"] 
subs = [os.listdir(d) for d in dirs] 
print subs 

currentliy me donne une liste-des-listes, mais je veux vraiment une liste.

Answer 1

Vous pouvez avoir des itérations imbriquées dans une seule compréhension de liste:

[filename for path in dirs for filename in os.listdir(path)] 

Answer 2

Vous pouvez essayer itertools.chain(), comme ceci:

import itertools 
import os 
dirs = ["c:\\usr", "c:\\temp"] 
subs = list(itertools.chain(*[os.listdir(d) for d in dirs])) 
print subs 

itertools.chain() retourne un itérateur, d'où le passage à list().

Answer 3

subs = [] 
map(subs.extend, (os.listdir(d) for d in dirs)) 

(mais la réponse de fourmis est mieux, +1 pour lui)

Answer 4

Vous pouvez trouver une bonne réponse dans itertools' recipes:

def flatten(listOfLists): 
    return list(chain.from_iterable(listOfLists)) 

(Note: nécessite Python 2.6+)

Answer 5

Google m'a apporté la solution suivante:

def flatten(l): 
    if isinstance(l,list): 
     return sum(map(flatten,l)) 
    else: 
     return l 

Answer 6

Vous pouvez simplement faire le simple:

subs = [] 
for d in dirs: 
    subs.extend(os.listdir(d)) 

Answer 7

Vous pouvez concaténer des listes à l'aide de l'opérateur d'ajout normal:

>>> [1, 2] + [3, 4] 
[1, 2, 3, 4] 

La fonction intégrée sum ajoutera les numéros dans une séquence et peut éventuellement commencer à partir d'une valeur spécifique:

>>> sum(xrange(10), 100) 
145 

Combiner ci-dessus pour aplatir une liste de listes:

>>> sum([[1, 2], [3, 4]], []) 
[1, 2, 3, 4] 

Vous pouvez maintenant définir votre flatmap:

>>> def flatmap(f, seq): 
... return sum([f(s) for s in seq], []) 
... 
>>> flatmap(range, [1,2,3]) 
[0, 0, 1, 0, 1, 2] 

Modifier: Je viens de voir la critique dans les commentaires pour another answer et je suppose qu'il est correct que Python va inutilement construire et garbage collecter beaucoup de petites listes avec cette solution. Donc, la meilleure chose qui peut être dit à ce sujet est qu'il est très simple et concise si vous êtes habitué à la programmation fonctionnelle :-)

Answer 8

>>> listOfLists = [[1, 2],[3, 4, 5], [6]] 
>>> reduce(list.__add__, listOfLists) 
[1, 2, 3, 4, 5, 6] 

Je devine que la solution itertools est plus efficace que cela, mais cela semble très pythonique et évite d'avoir à importer une bibliothèque juste pour le plaisir d'une seule opération de liste.

Answer 9

import itertools 
x=[['b11','b12'],['b21','b22'],['b31']] 
y=list(itertools.chain(*x)) 
print y 

itertools travailleront de python2.3 et plus

Answer 10

La question proposée flatmap. Certaines mises en œuvre sont proposées, mais elles peuvent ne pas créer de listes intermédiaires inutiles. Voici une implémentation basée sur les itérateurs.

def flatmap(func, *iterable): 
    return itertools.chain.from_iterable(map(func, *iterable)) 

In [148]: list(flatmap(os.listdir, ['c:/mfg','c:/Intel'])) 
Out[148]: ['SPEC.pdf', 'W7ADD64EN006.cdr', 'W7ADD64EN006.pdf', 'ExtremeGraphics', 'Logs'] 

En Python 2.x, utilisez itertools.map en place de map.

Answer 11

If listA=[list1,list2,list3] 
flattened_list=reduce(lambda x,y:x+y,listA) 

Cela fera l'affaire.

Answer 12

def flat_list(arr): 
    send_back = [] 
    for i in arr: 
     if type(i) == list: 
      send_back += flat_list(i) 
     else: 
      send_back.append(i) 
    return send_back 

Answer 13

Vous pouvez utiliser pyxtension:

from pyxtension.streams import stream 
stream([ [1,2,3], [4,5], [], [6] ]).flatMap() == range(7)