윈도우 리터레이터를 롤링 또는 슬라이딩합니까?

윈도우 리터레이터를 롤링 또는 슬라이딩합니까?

시퀀스/반복기/제너레이터에서 반복 가능한 롤링 윈도우(슬라이딩 윈도우라고도 함)가 필요합니다.(기본 Python 반복은 윈도우 길이가 1인 특수한 경우로 간주할 수 있습니다.)저는 현재 아래 코드를 사용하고 있습니다.어떻게 하면 더 우아하고 효율적으로 할 수 있을까요?

def rolling_window(seq, window_size):
    it = iter(seq)
    win = [it.next() for cnt in xrange(window_size)] # First window
    yield win
    for e in it: # Subsequent windows
        win[:-1] = win[1:]
        win[-1] = e
        yield win

if __name__=="__main__":
    for w in rolling_window(xrange(6), 3):
        print w

"""Example output:   
   [0, 1, 2]
   [1, 2, 3]
   [2, 3, 4]
   [3, 4, 5]
"""

---

_{구체적인 경우window_size == 2(즉, 연속적으로 겹치는 인접 쌍에 걸쳐 반복) Python에서 목록을 쌍으로 반복(현재, 다음)을 참조하십시오.}

이전 버전의 Python 문서에는 다음과 같은 예가 있습니다.

from itertools import islice

def window(seq, n=2):
    "Returns a sliding window (of width n) over data from the iterable"
    "   s -> (s0,s1,...s[n-1]), (s1,s2,...,sn), ...                   "
    it = iter(seq)
    result = tuple(islice(it, n))
    if len(result) == n:
        yield result
    for elem in it:
        result = result[1:] + (elem,)
        yield result

좀 더 하고 간결하게 .itertools아, 아, 아, 아, 아, 아, 아, 아, 아, 아.

---

반복기가 간단한 목록/태플인 경우 지정된 창 크기를 사용하여 쉽게 슬라이드할 수 있는 방법은 다음과 같습니다.

seq = [0, 1, 2, 3, 4, 5]
window_size = 3

for i in range(len(seq) - window_size + 1):
    print(seq[i: i + window_size])

출력:

[0, 1, 2]
[1, 2, 3]
[2, 3, 4]
[3, 4, 5]

이것은 에 맞게 만들어진 것 같다.collections.deque기본적으로 FIFO가 있기 때문입니다(한쪽 끝에는 추가, 다른 쪽 끝에는 삭제). ,, 를, 예를 list번 게 그냥 자르는 게 것 요.「 」, 「 」, 「 」pop(0)와 스 the the the the the theappend()새로운 아이템

여기에서는, 원래의 것을 본떠 최적화된 디큐 베이스의 실장을 나타내고 있습니다.

from collections import deque

def window(seq, n=2):
    it = iter(seq)
    win = deque((next(it, None) for _ in xrange(n)), maxlen=n)
    yield win
    append = win.append
    for e in it:
        append(e)
        yield win

필문커가 되어 있는 것을 합니다.tee버전은 큰 반복성과 작은 윈도우를 능가합니다. 「」를 참조해 .deque원시 속도로 다시 앞으로 나아갑니다.

「 」의 접근deque의 지수를 끝과 가까운 이 더 빠릅니다.(처음에 가까운 항목이 더 빠르거나 음의 인덱스를 사용하는 경우 끝 부분에 가까운 항목이 더 빠릅니다.)sum(w)이 루프는 디크의 힘에 따라 재생됩니다(이 루프는 한 항목에서 다음 항목으로 빠르게 반복되므로 다음으로 빠른 방법인 필먼처보다 20% 이상 빠르게 작동합니다).되어 10개의 창이 나타납니다.tee% 20% %%%%%%%% 。할 수 , 5항은 인덱스를 사용하여 회복할 수 있었습니다.tee츠키노전체적으로 어느 쪽이든 대부분의 경우 고속으로 사용할 수 있을 것으로 예상되며, 좀 더 성능이 필요한 경우 프로파일을 작성하여 가장 적합한 것을 선택하십시오.

는 아요를 좋아한다.tee():

from itertools import tee, izip

def window(iterable, size):
    iters = tee(iterable, size)
    for i in xrange(1, size):
        for each in iters[i:]:
            next(each, None)
    return izip(*iters)

for each in window(xrange(6), 3):
    print list(each)

다음과 같은 기능이 있습니다.

[0, 1, 2]
[1, 2, 3]
[2, 3, 4]
[3, 4, 5]

필요한 기능을 제공하는 라이브러리가 있습니다.

import more_itertools
list(more_itertools.windowed([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],n=3, step=3))

Out: [(1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12), (13, 14, 15)]

이 개요는 다음과 같습니다.step,fillvalue★★★★★★★★★★★★★★★★★★:

from collections import deque
from itertools import islice

def sliding_window(iterable, size=2, step=1, fillvalue=None):
    if size < 0 or step < 1:
        raise ValueError
    it = iter(iterable)
    q = deque(islice(it, size), maxlen=size)
    if not q:
        return  # empty iterable or size == 0
    q.extend(fillvalue for _ in range(size - len(q)))  # pad to size
    while True:
        yield iter(q)  # iter() to avoid accidental outside modifications
        try:
            q.append(next(it))
        except StopIteration: # Python 3.5 pep 479 support
            return
        q.extend(next(it, fillvalue) for _ in range(step - 1))

은 덩어리로 된다.size에 롤링하다step에서는 각 청크를 " " " 로 .fillvalue의 예size=4, step=3, fillvalue='*':

 [a b c d]e f g h i j k l m n o p q r s t u v w x y z
  a b c[d e f g]h i j k l m n o p q r s t u v w x y z
  a b c d e f[g h i j]k l m n o p q r s t u v w x y z
  a b c d e f g h i[j k l m]n o p q r s t u v w x y z
  a b c d e f g h i j k l[m n o p]q r s t u v w x y z
  a b c d e f g h i j k l m n o[p q r s]t u v w x y z
  a b c d e f g h i j k l m n o p q r[s t u v]w x y z
  a b c d e f g h i j k l m n o p q r s t u[v w x y]z
  a b c d e f g h i j k l m n o p q r s t u v w x[y z * *]

「 」의 step매개 변수를 참조하십시오. python에서 큰 .txt 파일을 효율적으로 처리.

간단한 기고문입니다.

현재 python 문서에는 itertool 예제에 "displaces"가 없기 때문에(예를 들어, http://docs.python.org/library/itertools.html),의 아래에는 grouter의 코드에 근거한 스니펫이 있습니다).이러한 예는 다음과 같습니다.

import itertools as it
def window(iterable, size):
    shiftedStarts = [it.islice(iterable, s, None) for s in xrange(size)]
    return it.izip(*shiftedStarts)

기본적으로 일련의 슬라이스 반복기를 만듭니다.각각의 시작점은 1점 더 앞으로 나갑니다.그리고 나서, 우리는 이것들을 함께 지퍼로 잠근다.이 함수는 제너레이터를 반환합니다(직접 제너레이터 자체는 아님).

위의 추가 요소 및 확장 반복기 버전과 마찬가지로 성능(최적의 성능)은 목록 크기와 창 크기에 따라 달라집니다.이 제품은 2라인이라 마음에 듭니다(원라이너일 수도 있지만, 저는 네이밍 컨셉을 선호합니다).

위의 코드가 잘못된 것으로 판명되었습니다.반복 가능한 파라미터가 시퀀스일 경우 동작하지만 반복기일 경우 동작하지 않습니다.반복기일 경우 동일한 반복기가 Islice 콜 간에 공유되고(tee'd가 아님), 이로 인해 문제가 발생합니다.

다음은 몇 가지 고정 코드입니다.

import itertools as it
def window(iterable, size):
    itrs = it.tee(iterable, size)
    shiftedStarts = [it.islice(anItr, s, None) for s, anItr in enumerate(itrs)]
    return it.izip(*shiftedStarts)

그리고 책을 위한 한 가지 버전이 더.이 버전에서는 반복기를 복사한 후 여러 번 복사를 진행하는 대신 시작 위치를 앞당길 때 각 반복기의 쌍별 복사를 만듭니다.따라서, 반복기 t는 시작점이 t인 "완전한" 반복기와 반복기 t + 1을 만드는 기초를 모두 제공합니다.

import itertools as it
def window4(iterable, size):
    complete_itr, incomplete_itr = it.tee(iterable, 2)
    iters = [complete_itr]
    for i in xrange(1, size):
        incomplete_itr.next()
        complete_itr, incomplete_itr = it.tee(incomplete_itr, 2)
        iters.append(complete_itr)
    return it.izip(*iters)

레시피를 어떻게 조합할 수 있는지 보여드리기 위해pairwise한 한 window을 사용하다consume★★★★★★★★★★★★★★★★★★:

def consume(iterator, n):
    "Advance the iterator n-steps ahead. If n is none, consume entirely."
    # Use functions that consume iterators at C speed.
    if n is None:
        # feed the entire iterator into a zero-length deque
        collections.deque(iterator, maxlen=0)
    else:
        # advance to the empty slice starting at position n
        next(islice(iterator, n, n), None)

def window(iterable, n=2):
    "s -> (s0, ...,s(n-1)), (s1, ...,sn), (s2, ..., s(n+1)), ..."
    iters = tee(iterable, n)
    # Could use enumerate(islice(iters, 1, None), 1) to avoid consume(it, 0), but that's
    # slower for larger window sizes, while saving only small fixed "noop" cost
    for i, it in enumerate(iters):
        consume(it, i)
    return zip(*iters)

windowpairwise '스페이스'의 인 '스페이스tee이 점차 - ed 반복기n - 1터 using using. 사사사 using using를 사용해서.consume를 each각으로 islice(충분히 큰 반복가능성을 위해) 조금 더 빠릅니다." " " " " " , " " "islice오버헤드를 감싸기consume 단계 이 ( 、 phase 、 음 、 음 、 음 、 음따 （ 따음음음 ( ( ） ）n, 에 있는 항목 수입니다.iterable를 참조해 주세요.

퍼포먼스 면에서는, 다른 솔루션과 비교해도 꽤 우수합니다(또, 확장에 수반해 테스트한 다른 솔루션보다 우수합니다). 3.5에서 Python 3.5.0, Linux x86-64를 ipython %timeitmagic.magic.magic.magic.

Kindall이 해결책입니다.퍼포먼스/정확성을 위해 조정된islice 대신 반복 때 합니다. 반복 한 길이가 창보다 짧을 때 가 나오지 않습니다maxlendeque키워드 대신 위치(입력량이 작을 경우 놀라운 차이가 있음):

>>> %timeit -r5 deque(windowkindall(range(10), 3), 0)
100000 loops, best of 5: 1.87 μs per loop
>>> %timeit -r5 deque(windowkindall(range(1000), 3), 0)
10000 loops, best of 5: 72.6 μs per loop
>>> %timeit -r5 deque(windowkindall(range(1000), 30), 0)
1000 loops, best of 5: 71.6 μs per loop

하지만 각 Kindall 에서는 Kindall이 사용됩니다.yield win로 changed to 로 변경되다yield tuple(win) 저장은 않고 에서는 다른 합니다).tuple=tuple의 합니다.tuple BLEGBL:

>>> %timeit -r5 deque(windowkindalltupled(range(10), 3), 0)
100000 loops, best of 5: 3.05 μs per loop
>>> %timeit -r5 deque(windowkindalltupled(range(1000), 3), 0)
10000 loops, best of 5: 207 μs per loop
>>> %timeit -r5 deque(windowkindalltupled(range(1000), 30), 0)
1000 loops, best of 5: 348 μs per loop

consume- : - " " 위 - shown shown shown shown shown:

>>> %timeit -r5 deque(windowconsume(range(10), 3), 0)
100000 loops, best of 5: 3.92 μs per loop
>>> %timeit -r5 deque(windowconsume(range(1000), 3), 0)
10000 loops, best of 5: 42.8 μs per loop
>>> %timeit -r5 deque(windowconsume(range(1000), 30), 0)
1000 loops, best of 5: 232 μs per loop

와다같 same consume단, , " ", " "else의 consume을 회피하기 , 「기능 콜」과 「기능 콜」을 하기 위해서입니다.n is None특히 설정 오버헤드가 중요한 작업의 일부인 소규모 입력의 경우 실행 시간을 줄이기 위해 테스트를 수행합니다.

>>> %timeit -r5 deque(windowinlineconsume(range(10), 3), 0)
100000 loops, best of 5: 3.57 μs per loop
>>> %timeit -r5 deque(windowinlineconsume(range(1000), 3), 0)
10000 loops, best of 5: 40.9 μs per loop
>>> %timeit -r5 deque(windowinlineconsume(range(1000), 30), 0)
1000 loops, best of 5: 211 μs per loop

의:pairwise 쓰죠.tee된 2를 .tee오브젝트, 따라서 임의의 반복자는 1회만 진보하고, 독립적으로 소비되는 횟수는 증가하지 않습니다.DrFenner씨의 답변과 비슷합니다.consume.consume모든 테스트에서, 그래서 간략하게 하기 위해 그 결과를 생략했습니다.)

보다시피, 발신자가 결과를 저장할 필요가 있는지 여부에 관계없이, 대부분의 경우, 최적화된 버전의 Kindall 솔루션이 승리합니다.단, "큰 반복 가능한 작은 창 크기 케이스"는 제외됩니다(인라인으로 표시되어 있습니다.consume): 반복 가능한 크기가 증가할수록 빠르게 저하되지만 윈도우 크기가 증가할수록 전혀 저하되지 않습니다(다른 모든 솔루션은 반복 가능한 크기가 증가할수록 더 느리게 저하되지만 윈도우 크기가 증가할수록 저하됩니다).또, 「탭이 필요」한 케이스에도 대응할 수 있습니다.map(tuple, ...)이는 함수에 튜플링을 넣는 것보다 실행 속도가 다소 느리지만(시간이 1~5% 더 소요됨) 단순하고 동일한 값을 반복적으로 반환하는 것을 허용할 수 있을 때 더 빠르게 실행할 수 있는 유연성을 유지할 수 있습니다.

반송이 저장되지 않도록 안전하게 해야 할 경우, 최소 입력 크기(인쇄되지 않은 입력 크기)를 제외한 모든 인쇄된 제품이 유리합니다.consume약간 느리지만 비슷하게 확장됩니다.)deque& TUPLING 기반 솔루션은 셋업 비용이 작기 때문에 최소한의 입력에만 유리하고 이익은 작습니다.반복 가능 시간이 길어질수록 성능이 저하됩니다.

의 적응 for for for 、 all 、 all 、 all 、 all for 。yields tuple사용한 s는 다음과 같습니다.

def windowkindalltupled(iterable, n=2, tuple=tuple):
    it = iter(iterable)
    win = deque(islice(it, n), n)
    if len(win) < n:
        return
    append = win.append
    yield tuple(win)
    for e in it:
        append(e)
        yield tuple(win)

합니다.tuple행및 ""의 을 나타냅니다.tupleyield더 빠르지만 덜 안전한 버전을 얻을 수 있습니다.

저는 아래 코드를 발전기를 사용하여 가독성을 대폭 높인 간단한 슬라이딩 창으로 사용하고 있습니다.그 속도는 지금까지 내 경험상 생물정보학 시퀀스 분석에 사용하기에 충분했다.

아직 이 방법을 사용하지 않았기 때문에 여기에 포함시킵니다.다시 한 번 말하지만, 나는 그것의 성능 비교에 대해 아무 주장도 하지 않는다.

def slidingWindow(sequence,winSize,step=1):
"""Returns a generator that will iterate through
the defined chunks of input sequence. Input sequence
must be sliceable."""

    # Verify the inputs
    if not ((type(winSize) == type(0)) and (type(step) == type(0))):
        raise Exception("**ERROR** type(winSize) and type(step) must be int.")
    if step > winSize:
        raise Exception("**ERROR** step must not be larger than winSize.")
    if winSize > len(sequence):
        raise Exception("**ERROR** winSize must not be larger than sequence length.")

    # Pre-compute number of chunks to emit
    numOfChunks = ((len(sequence)-winSize)/step)+1

    # Do the work
    for i in range(0,numOfChunks*step,step):
        yield sequence[i:i+winSize]

def GetShiftingWindows(thelist, size):
    return [ thelist[x:x+size] for x in range( len(thelist) - size + 1 ) ]

>> a = [1, 2, 3, 4, 5]
>> GetShiftingWindows(a, 3)
[ [1, 2, 3], [2, 3, 4], [3, 4, 5] ]

진정한 롤링 윈도우로 만들기 위해 약간 수정된 버전의 데크 윈도우.따라서 하나의 요소로 채워지기 시작한 후 최대 창 크기로 확장한 다음 왼쪽 가장자리가 끝에 가까워지면 축소됩니다.

from collections import deque
def window(seq, n=2):
    it = iter(seq)
    win = deque((next(it, None) for _ in xrange(1)), maxlen=n)
    yield win
    append = win.append
    for e in it:
        append(e)
        yield win
    for _ in xrange(len(win)-1):
        win.popleft()
        yield win

for wnd in window(range(5), n=3):
    print(list(wnd))

이것은 준다

[0]
[0, 1]
[0, 1, 2]
[1, 2, 3]
[2, 3, 4]
[3, 4]
[4]

그거 좋지

def pairwise(iterable):
    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
    a, b = tee(iterable)
    next(b, None)
    return zip(a, b)

Python doc에 기재되어 있어 더 넓은 창으로 쉽게 확장할 수 있습니다.

게으르게 만들자!

from itertools import islice, tee

def window(iterable, size): 
    iterators = tee(iterable, size) 
    iterators = [islice(iterator, i, None) for i, iterator in enumerate(iterators)]  
    yield from zip(*iterators)

list(window(range(5), 3))
# [(0, 1, 2), (1, 2, 3), (2, 3, 4)]

def rolling_window(list, degree):
    for i in range(len(list)-degree+1):
        yield [list[i+o] for o in range(degree)]

롤링 평균 함수를 위해 만들었습니다.

제가 생각해낸 해결책과 함께 몇 가지 테스트를 해봤습니다.가장 빠른 것을 찾아 python3 구현을 공유하려고 합니다.

import itertools
import sys

def windowed(l, stride):
    return zip(*[itertools.islice(l, i, sys.maxsize) for i in range(stride)])

다중 반복기!

def window(seq, size, step=1):
    # initialize iterators
    iters = [iter(seq) for i in range(size)]
    # stagger iterators (without yielding)
    [next(iters[i]) for j in range(size) for i in range(-1, -j-1, -1)]
    while(True):
        yield [next(i) for i in iters]
        # next line does nothing for step = 1 (skips iterations for step > 1)
        [next(i) for i in iters for j in range(step-1)]

next(it)StopIteration시퀀스가 종료되면, 그리고 어떤 시원한 이유로 인해, 여기의 수율 문장은 제외되고 함수는 완전한 창을 형성하지 못한 나머지 값을 무시하고 반환됩니다.

이것은 이며, 은 require, 것, 것, 일, 일, 음, 음, 음, 음, 음, 음, 음, 음, 음, 음, 음이다.seq__iter__ ★★★★★★★★★★★★★★★★★」__getitem__하지 않다itertools ★★★★★★★★★★★★★★★★★」collections@ 이외 :)@dansalmod @ :)

#Importing the numpy library
import numpy as np
arr = np.arange(6) #Sequence
window_size = 3
np.lib.stride_tricks.as_strided(arr, shape= (len(arr) - window_size +1, window_size), 
strides = arr.strides*2)

"""Example output:

  [0, 1, 2]
  [1, 2, 3]
  [2, 3, 4]
  [3, 4, 5]

"""

toolz/cytoolz 패키지에는 sliding_window 기능이 있습니다.

>>> from cytoolz import sliding_window
>>> list(sliding_window(3, range(6))) # returns [(0, 1, 2), (1, 2, 3), (2, 3, 4), (3, 4, 5)]

>>> n, m = 6, 3
>>> k = n - m+1
>>> print ('{}\n'*(k)).format(*[range(i, i+m) for i in xrange(k)])
[0, 1, 2]
[1, 2, 3]
[2, 3, 4]
[3, 4, 5]

다음을 사용하는 것은 어떨까요?

mylist = [1, 2, 3, 4, 5, 6, 7]

def sliding_window(l, window_size=2):
    if window_size > len(l):
        raise ValueError("Window size must be smaller or equal to the number of elements in the list.")

    t = []
    for i in xrange(0, window_size):
        t.append(l[i:])

    return zip(*t)

print sliding_window(mylist, 3)

출력:

[(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6), (5, 6, 7)]

이것은 오래된 질문이지만 여전히 관심이 있는 사람들을 위해 (Adrian Rosebrock의) 이 페이지에 발전기를 사용한 윈도우 슬라이더의 훌륭한 구현이 있다.

OpenCV를 위한 구현이지만 다른 용도로 쉽게 사용할 수 있습니다.열심인 분들을 위해 여기에 코드를 붙이겠습니다만, 더 잘 이해하려면 원래 페이지를 방문하시는 것이 좋습니다.

def sliding_window(image, stepSize, windowSize):
    # slide a window across the image
    for y in xrange(0, image.shape[0], stepSize):
        for x in xrange(0, image.shape[1], stepSize):
            # yield the current window
            yield (x, y, image[y:y + windowSize[1], x:x + windowSize[0]])

힌트: 다음 웹 사이트를 확인하실 수 있습니다..shape 않는 할 때 으로 이동합니다.

건배.

임의 채우기 및 가변 단계 크기를 허용하도록 DiPaolo의 답변 수정

import itertools
def window(seq, n=2,step=1,fill=None,keep=0):
    "Returns a sliding window (of width n) over data from the iterable"
    "   s -> (s0,s1,...s[n-1]), (s1,s2,...,sn), ...                   "
    it = iter(seq)
    result = tuple(itertools.islice(it, n))    
    if len(result) == n:
        yield result
    while True:        
#         for elem in it:        
        elem = tuple( next(it, fill) for _ in range(step))
        result = result[step:] + elem        
        if elem[-1] is fill:
            if keep:
                yield result
            break
        yield result

여기 라이너가 하나 있습니다.타이밍을 맞췄더니 상위 답변의 성능에 맞게 구성되며, seq가 클수록 속도가 20% 느림(len(seq) = 20%, len(seq) = 10000일 때 7% 느림)에서 점차 향상됩니다.

zip(*[seq[i:(len(seq) - n - 1 + i)] for i in range(n)])

내 파트, 단순하고, 라이너 하나, 섬들을 이용한 버마틱한 방법.그러나 최적으로 효율적이지 않을 수 있습니다.

from itertools import islice
array = range(0, 10)
window_size = 4
map(lambda i: list(islice(array, i, i + window_size)), range(0, len(array) - window_size + 1))
# output = [[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8], [6, 7, 8, 9]]

설명:window_size의 islice를 사용하여 창을 만들고 모든 어레이에서 맵을 사용하여 이 작업을 반복합니다.

딥러닝에서 윈도우 데이터 슬라이딩에 최적화된 기능

def SlidingWindow(X, window_length, stride):
    indexer = np.arange(window_length)[None, :] + stride*np.arange(int(len(X)/stride)-window_length+4)[:, None]
    return X.take(indexer)

다차원 배열에 적용하다

import numpy as np
def SlidingWindow(X, window_length, stride1):
    stride=  X.shape[1]*stride1
    window_length = window_length*X.shape[1]
    indexer = np.arange(window_length)[None, :] + stride1*np.arange(int(len(X)/stride1)-window_length-1)[:, None]
    return X.take(indexer)

의 두 인 my my my my my my my my my my my my mywindow

from typing import Sized, Iterable

def window(seq: Sized, n: int, strid: int = 1, drop_last: bool = False):
    for i in range(0, len(seq), strid):
        res = seq[i:i + n]
        if drop_last and len(res) < n:
            break
        yield res


def window2(seq: Iterable, n: int, strid: int = 1, drop_last: bool = False):
    it = iter(seq)
    result = []
    step = 0
    for i, ele in enumerate(it):
        result.append(ele)
        result = result[-n:]
        if len(result) == n:
            if step % strid == 0:
                yield result
            step += 1
    if not drop_last:
        yield result

목록에서 고정 길이의 창을 생성하는 또 다른 간단한 방법

from collections import deque

def window(ls,window_size=3):
    window = deque(maxlen=window_size)

    for element in ls:
        
        if len(window)==window_size:
            yield list(window)
        window.append(element)

ls = [0,1,2,3,4,5]

for w in window(ls):
    print(w)

(심플하게 유지) 솔루션을 사용하게 되었습니다.

def sliding_window(items, size):
    return [items[start:end] for start, end
            in zip(range(0, len(items) - size + 1), range(size, len(items) + 1))]

말할 필요도 없이items시퀀스는 슬라이스 가능해야 합니다.지수를 사용하는 것이 이상적이지는 않지만 다른 대안을 고려할 때 가장 덜 나쁜 선택인 것 같습니다.도 있습니다. 그냥 해 주세요. 교체만 하면 됩니다.[...](...).

3.Python 3.10이 .itertools.pairwise(iterable) 두 요소를 하여 창을 :

다음은 문서입니다.

입력 반복 가능에서 가져온 연속되는 중복 쌍을 반환합니다.

출력 반복기의 2튜플 수는 입력 수보다 1개 적습니다.입력 반복 가능 값이 2개 미만일 경우 비어 있습니다.

대략 다음과 같습니다.

def pairwise(iterable):
    # pairwise('ABCDEFG') --> AB BC CD DE EF FG
    a, b = tee(iterable)
    next(b, None)
    return zip(a, b)

언급URL : https://stackoverflow.com/questions/6822725/rolling-or-sliding-window-iterator