Python: krótsza składnia dla plasterków z przerwami?

Question

Załóżmy chcę pierwszego elementu, 3. poprzez elementy 200. rocznicy, a 201st elementu poprzez ostatni element po kroku rozmiarze 3, z listy w Pythonie.

Jednym ze sposobów na to jest z wyraźną indeksowania i konkatenacji:

new_list = old_list[0:1] + old_list[3:201] + old_list[201::3] 

Czy istnieje sposób, aby to zrobić za pomocą jednego indeksu na old_list? Chciałbym coś jak poniżej (wiem, że to nie składniowo od pracy indeksy lista nie może być list, a od Python niestety doesn't have slice literals; Po prostu szukam czegoś bliskiego):

new_list = old_list[[0, 3:201, 201::3]] 

mogę osiągnąć niektóre to poprzez przełączenie na tablice NumPy, ale bardziej interesuje mnie, jak to zrobić dla natywnych list Pythona. I może również tworzyć a slice maker czy coś takiego, a być może, że pod silną rękę dając mi równoważny przedmiot plaster do reprezentowania składu wszystkich moich pożądanych plasterki.

ale szukam czegoś, co nie wiąże się tworząc nową klasę zarządzania plastry. Chcę po prostu rodzaj złączyć składni plasterka i paszy, że na mojej liście i mieć listę rozumieją, że oznacza to, że aby dostać osobno plasterki i złączyć ich odpowiednich wyników w końcu.

Answer 1

obiektu ekspres slice (np SliceMaker ze swojego inne pytanie, lub np.s_) może akceptować wiele wycinków oddzielonych przecinkami; są one odbierane jako tuple z slice s lub innych obiektów:

from numpy import s_ 
s_[0, 3:5, 6::3] 
Out[1]: (0, slice(3, 5, None), slice(6, None, 3)) 

NumPy używa tego do wielowymiarowych tablic, ale można go używać do plasterka konkatenacji:

def xslice(arr, slices): 
    if isinstance(slices, tuple): 
     return sum((arr[s] if isinstance(s, slice) else [arr[s]] for s in slices), []) 
    elif isinstance(slices, slice): 
     return arr[slices] 
    else: 
     return [arr[slices]] 
xslice(list(range(10)), s_[0, 3:5, 6::3]) 
Out[1]: [0, 3, 4, 6, 9] 
xslice(list(range(10)), s_[1]) 
Out[2]: [1] 
xslice(list(range(10)), s_[:]) 
Out[3]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 

Answer 2

Jesteś prawdopodobnie lepiej pisać swój własny rodzaj sekwencji.

>>> L = range(20) 
>>> L 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] 
>>> operator.itemgetter(*(range(1, 5) + range(10, 18, 3)))(L) 
(1, 2, 3, 4, 10, 13, 16) 

I możesz zacząć na tym:

>>> operator.itemgetter(*(range(*slice(1, 5).indices(len(L))) + range(*slice(10, 18, 3).indices(len(L)))))(L) 
(1, 2, 3, 4, 10, 13, 16) 

Answer 3

Dlaczego don; t utworzyć niestandardowy segment dla celów

>>> from itertools import chain, islice 
>>> it = range(50) 
>>> def cslice(iterable, *selectors): 
    return chain(*(islice(iterable,*s) for s in selectors)) 

>>> list(cslice(it,(1,5),(10,15),(25,None,3))) 
[1, 2, 3, 4, 10, 11, 12, 13, 14, 25, 28, 31, 34, 37, 40, 43, 46, 49] 

Answer 4

Nie jestem pewien, czy to jest „lepszy ”, ale działa, więc dlaczego nie ...

[y for x in [old_list[slice(*a)] for a in ((0,1),(3,201),(201,None,3))] for y in x]

to chyba powoli (szczególnie w porównaniu do cha w), ale jest to podstawowe Pythona (3.5.2 używane do testowania)