¿Cómo puedo obtener un resultado plano de una lista de comprensión en lugar de una lista anidada?

Question 1

tengo una lista Ay una función f que toma un elemento de A y devuelve una lista. Puedo usar una lista de comprensión para convertir todo en A me gusta [f(a) for a in A], pero esto devuelve una lista de listas. Supongamos que mi entrada es [a1,a2,a3]Resultando en [[b11,b12],[b21,b22],[b31,b32]].

¿Cómo puedo obtener el aplanado lista [b11,b12,b21,b22,b31,b32] ¿en cambio? En otras palabras, en Python, ¿cómo puedo obtener lo que tradicionalmente se llama flatmap en lenguajes de programación funcionales, o SelectMany ¿en la red?

(En el código real, A es una lista de directorios, y f es os.listdir. Quiero construir una lista plana de subdirectorios.)

_{Ver también: ¿Cómo hago una lista plana a partir de una lista de listas? para el problema más general de aplanar una lista de listas después de haberla creado.}

Question 2

Puede tener iteraciones anidadas en una sola lista de comprensión:

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

que es equivalente (al menos funcionalmente) a:

filenames = []
for path in dirs:
    for filename in os.listdir(path):
        filenames.append(filename)

Question 3

>>> from functools import reduce  # not needed on Python 2
>>> list_of_lists = [[1, 2],[3, 4, 5], [6]]
>>> reduce(list.__add__, list_of_lists)
[1, 2, 3, 4, 5, 6]

los itertools La solución es más eficiente, pero esto se siente muy pitónico.

Question 4

Puedes encontrar una buena respuesta en el itertools recetas:

import itertools

def flatten(list_of_lists):
    return list(itertools.chain.from_iterable(list_of_lists))

Question 5

La pregunta propuesta flatmap. Se proponen algunas implementaciones pero pueden ser innecesarias creando listas intermedias. Aquí hay una implementación que se basa en iteradores.

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, use itertools.map en lugar de map.

Question 6

Podrías simplemente hacer lo sencillo:

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

Question 7

Puede concatenar listas usando el operador de suma normal:

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

La función incorporada sum agregará los números en una secuencia y, opcionalmente, puede comenzar desde un valor específico:

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

Combine lo anterior para aplanar una lista de listas:

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

Ahora puede definir su flatmap:

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

Editar: Acabo de ver la crítica en los comentarios para otra respuesta y supongo que es correcto que Python construya innecesariamente y recolecte basura muchas listas más pequeñas con esta solución. Entonces, lo mejor que se puede decir al respecto es que es muy simple y conciso si estás acostumbrado a la programación funcional 🙂

Question 8

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

(pero la respuesta de Ants es mejor; +1 para él)

¿Ha sido útil esta solución?