розуміння списку python; стиснення списку списків?

хлопці. Я намагаюся знайти найелегантніше рішення проблеми і замислювався, чи python має щось вбудоване для того, що я намагаюся зробити.

Я роблю це. У мене є список, Aі у мене є функція, fяка бере елемент і повертає список. Я можу використовувати розуміння списку, щоб перетворити все Aприблизно так;

[f(a) for a in A]

Але це повертає список списків;

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

Насправді я хочу отримати сплощений список;

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

Тепер це є в інших мовах; це традиційно називається flatmapу функціональних мовах програмування, а .Net - це SelectMany. Чи є у python щось подібне? Чи є акуратний спосіб відобразити функцію за списком і згладити результат?

Фактична проблема, яку я намагаюся вирішити, полягає в наступному; починаючи зі списку каталогів, знайдіть усі підкаталоги. так;

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

currentliy дає мені список зі списків, але я дуже хочу список.

Ви можете вкласти ітерації в одному розумінні списку:

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

що еквівалентно (принаймні функціонально):

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

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

Я припускаю, що рішення itertools є більш ефективним, ніж це, але це здається дуже пітонічним.

У Python 2 він уникає необхідності імпортувати бібліотеку лише заради однієї операції зі списком (оскільки reduceце вбудований).

Ви можете знайти хорошу відповідь у рецептах itertools:

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

(Примітка: потрібен Python 2.6+)

Запропоноване питання flatmap. Запропоновано деякі реалізації, але вони можуть не вимагати створення проміжних списків. Ось одна реалізація, яка базується на ітераторах.

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']

У Python 2.x використовуйте itertools.mapзамість map.

Ви можете зробити просто:

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

Ви можете об’єднати списки за допомогою звичайного оператора додавання:

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

Вбудована функція sumдодаватиме цифри в послідовності і може за бажанням починати з певного значення:

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

Поєднайте вищезазначене, щоб вирівняти список списків:

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

Тепер ви можете визначити flatmap:

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

Редагувати: Я щойно побачив критику в коментарях щодо іншої відповіді, і, мабуть, правильно, що Python без потреби будуватиме та збиратиме багато менших списків за допомогою цього рішення. Тож найкраще, що можна сказати про це, це те, що це дуже просто і стисло, якщо ви звикли до функціонального програмування :-)

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

itertools працюватиме з python2.3 і вище

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

(але відповідь Мурахи краща; +1 для нього)

Ви можете спробувати itertools.chain(), як це:

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

itertools.chain()повертає ітератор, отже, перехід до list().

Google запропонував мені наступне рішення:

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

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

Ви можете використовувати пікстензію :

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

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

Це буде робити.