Spłaszczaj listę zagnieżdżonych podkategorii o zmiennej wielkości w tablicy SciPy

Question

Jak używać numpy/scipy do spłaszczenia zagnieżdżonej listy z podlistami o różnych rozmiarach? Szybkość jest bardzo ważna, a listy są duże.

lst = [[1, 2, 3, 4],[2, 3],[1, 2, 3, 4, 5],[4, 1, 2]] 

Czy coś jest szybsze niż to?

vec = sp.array(list(*chain(lst))) 

Answer 1

Jak o np.fromiter:

In [49]: %timeit np.hstack(lst*1000) 
10 loops, best of 3: 25.2 ms per loop 

In [50]: %timeit np.array(list(chain.from_iterable(lst*1000))) 
1000 loops, best of 3: 1.81 ms per loop 

In [52]: %timeit np.fromiter(chain.from_iterable(lst*1000), dtype='int') 
1000 loops, best of 3: 1 ms per loop 

Answer 2

Zastosowanie chain.from_iterable:

vec = sp.array(list(chain.from_iterable(lst))) 

ten sposób unika się stosując * co jest dość kosztowne w obsłudze, jeśli iterable ma wiele listy zagnieżdżone.

Innym rozwiązaniem potęga być sum listach:

vec = sp.array(sum(lst, [])) 

jednak pamiętać, że spowoduje to quadratic reallocation. Coś jak to wykonuje znacznie lepiej:

def sum_lists(lst): 
    if len(lst) < 2: 
     return sum(lst, []) 
    else: 
     half_length = len(lst) // 2 
     return sum_lists(lst[:half_length]) + sum_lists(lst[half_length:]) 

Na moim komputerze mam:

>>> L = [[random.randint(0, 500) for _ in range(x)] for x in range(10, 510)] 
>>> timeit.timeit('sum(L, [])', 'from __main__ import L', number=1000) 
168.3029818534851 
>>> timeit.timeit('sum_lists(L)', 'from __main__ import L,sum_lists', number=1000) 
10.248489141464233 
>>> 168.3029818534851/10.248489141464233 
16.422223757114615 

Jak widać, prędkość-up 16x. chain.from_iterable jest jeszcze szybsze:

>>> timeit.timeit('list(itertools.chain.from_iterable(L))', 'import itertools; from __main__ import L', number=1000) 
1.905594825744629 
>>> 10.248489141464233/1.905594825744629 
5.378105042586658 

Innym 6x speed-up.

---

Szukałem rozwiązania "czystego pythona", nie znając numpy. Wierzę, że rozwiązanieAbhijit unutbu/senderle to sposób, aby przejść w twoim przypadku.

Answer 3

Można spróbować numpy.hstack

>>> lst = [[1, 2, 3, 4],[2, 3],[1, 2, 3, 4, 5],[4, 1, 2]] 
>>> np.hstack(lst) 
array([1, 2, 3, 4, 2, 3, 1, 2, 3, 4, 5, 4, 1, 2]) 

Answer 4

Jak o próbie:

np.hstack(lst) 

Answer 5

Najszybszy sposób, aby utworzyć numpy tablicę z iterator jest użyj numpy.fromiter:

>>> %timeit numpy.fromiter(itertools.chain.from_iterable(lst), numpy.int64) 
100000 loops, best of 3: 3.76 us per loop 
>>> %timeit numpy.array(list(itertools.chain.from_iterable(lst))) 
100000 loops, best of 3: 14.5 us per loop 
>>> %timeit numpy.hstack(lst) 
10000 loops, best of 3: 57.7 us per loop 

Jak widać, jest to szybsze niż konwersja do listy i znacznie szybsze niż hstack.

Answer 6

Użyj funkcji spłaszczyć listę o

>>> flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x] 
>>> flatten(lst)