반복을 통해 조각 목록
https://stackoverflow.com/questions/1335392
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
내가 원하는 알고리즘을 반복하고 목록을 통해 슬라이스입니다.슬라이스 크기가 설정한 외부의 함수와 다를 수 있습니다.
내 마음에 그것은 다음과 같습니다.
for list_of_x_items in fatherList:
foo(list_of_x_items)
는 방법이 있을 제대로 정의 list_of_x_items 또는 다른 방법이 사용하는 python2.5?
edit1:설명 모두"분할"과"슬라이딩 창을"약관 사운드 적용 가능한 내 작업,그러나 나는 아무 전문가입니다.그래서 나는 설명할 것이 문제가 조금 더 깊이 및 추가 질문:
이 fatherList 다단계 numpy.배가 나에서 파일입니다.는 기능을 찾을 수있다 평균의 시리즈(사용자 제공 길이의 시리즈)를 위한 평균 사용 mean() 기능입니다.지금 질문에 대한 확:
edit2: 수정하는 방법 기능을 제공하는 저장소에 추가 항목들을 사용할 때 다음 fatherList 공급하는 기능입니까?
예를 들면 목록은 길이 10 크기의 덩어리가 3,다음 10 의 구성원 목록을 저장하고 추가 시작 부분의 다음 목록입니다.
관련된:
해결책
질문의 마지막 부분에 대한 답변 :
질문 업데이트 : 추가 항목을 저장하고 다음 아버지 명단이 함수에 공급 될 때 사용한 기능을 수정하는 방법은 무엇입니까?
상태를 저장 해야하는 경우 객체를 사용할 수 있습니다.
class Chunker(object):
"""Split `iterable` on evenly sized chunks.
Leftovers are remembered and yielded at the next call.
"""
def __init__(self, chunksize):
assert chunksize > 0
self.chunksize = chunksize
self.chunk = []
def __call__(self, iterable):
"""Yield items from `iterable` `self.chunksize` at the time."""
assert len(self.chunk) < self.chunksize
for item in iterable:
self.chunk.append(item)
if len(self.chunk) == self.chunksize:
# yield collected full chunk
yield self.chunk
self.chunk = []
예시:
chunker = Chunker(3)
for s in "abcd", "efgh":
for chunk in chunker(s):
print ''.join(chunk)
if chunker.chunk: # is there anything left?
print ''.join(chunker.chunk)
산출:
abc
def
gh
다른 팁
목록을 슬라이스로 나누려면이 트릭을 사용할 수 있습니다.
list_of_slices = zip(*(iter(the_list),) * slice_size)
예를 들어
>>> zip(*(iter(range(10)),) * 3)
[(0, 1, 2), (3, 4, 5), (6, 7, 8)]
아이템 수를 슬라이스 크기로 나눌 수없고 목록을 없애고 싶다면 다음을 수행 할 수 있습니다.
>>> map(None, *(iter(range(10)),) * 3)
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, None, None)]
더러운 작은 속임수입니다
좋아, 그것이 어떻게 작동하는지 설명하겠습니다. 설명하는 것은 까다로울 것이지만 최선을 다하겠습니다.
먼저 작은 배경 :
파이썬에서는 다음과 같은 숫자로 목록을 곱할 수 있습니다.
[1, 2, 3] * 3 -> [1, 2, 3, 1, 2, 3, 1, 2, 3]
([1, 2, 3],) * 3 -> ([1, 2, 3], [1, 2, 3], [1, 2, 3])
그리고 반복자 객체는 다음과 같이 한 번 소비 할 수 있습니다.
>>> l=iter([1, 2, 3])
>>> l.next()
1
>>> l.next()
2
>>> l.next()
3
그만큼 지퍼 함수는 튜플 목록을 반환하며, 여기서 i-th 튜플은 각 인수 시퀀스 또는 반복성의 i-th 요소를 포함합니다. 예를 들어:
zip([1, 2, 3], [20, 30, 40]) -> [(1, 20), (2, 30), (3, 40)]
zip(*[(1, 20), (2, 30), (3, 40)]) -> [[1, 2, 3], [20, 30, 40]]
Zip 앞에서 * 인수를 풀었습니다. 자세한 내용은 찾을 수 있습니다 여기. 그래서
zip(*[(1, 20), (2, 30), (3, 40)])
실제로는 동일합니다
zip((1, 20), (2, 30), (3, 40))
변수의 인수와 함께 작동합니다
이제 트릭으로 돌아갑니다.
list_of_slices = zip(*(iter(the_list),) * slice_size)
iter(the_list) -> 목록을 반복자로 변환합니다
(iter(the_list),) * N ->는 the_list iterator에 대한 n 참조를 생성합니다.
zip(*(iter(the_list),) * N) -> 해당 반복자 목록을 ZIP에 공급합니다. 결과적으로 그것들을 n 크기의 튜플로 분류 할 것입니다. 그러나 모든 N 항목은 실제로 동일한 반복자에 대한 참조이므로 iter(the_list) 결과는 반복적으로 전화 할 것입니다 next() 원래 반복자에
설명하기를 바랍니다. 이해하기 쉬운 솔루션으로 가라고 조언합니다. 나는 그것을 좋아하기 때문에이 트릭을 언급하고 싶은 유혹을 받았다.
반복 가능한 모든 것을 소비하려면 다음 기능을 사용할 수 있습니다.
from itertools import chain, islice
def ichunked(seq, chunksize):
"""Yields items from an iterator in iterable chunks."""
it = iter(seq)
while True:
yield chain([it.next()], islice(it, chunksize-1))
def chunked(seq, chunksize):
"""Yields items from an iterator in list chunks."""
for chunk in ichunked(seq, chunksize):
yield list(chunk)
당신은 다음과 같은 것을 의미합니까?
def callonslices(size, fatherList, foo):
for i in xrange(0, len(fatherList), size):
foo(fatherList[i:i+size])
이것이 대략 원하는 기능이라면, 원한다면 생성기에서 약간 옷을 입으십시오.
def sliceup(size, fatherList):
for i in xrange(0, len(fatherList), size):
yield fatherList[i:i+size]
그리고:
def callonslices(size, fatherList, foo):
for sli in sliceup(size, fatherList):
foo(sli)
발전기 사용 :
big_list = [1,2,3,4,5,6,7,8,9]
slice_length = 3
def sliceIterator(lst, sliceLen):
for i in range(len(lst) - sliceLen + 1):
yield lst[i:i + sliceLen]
for slice in sliceIterator(big_list, slice_length):
foo(slice)
sliceIterator 너비의 "슬라이딩 창"을 구현합니다 sliceLen Squence에 lst, 즉, 겹치는 슬라이스를 생성합니다 : [1,2,3], [2,3,4], [3,4,5], ... 그것이 OP의 의도인지 확실하지 않습니다.
확실하지 않지만 이동 평균이라고하는 일을하고 싶어요. Numpy는이를위한 시설을 제공합니다 (Convolve 기능).
>>> x = numpy.array(range(20))
>>> x
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19])
>>> n = 2 # moving average window
>>> numpy.convolve(numpy.ones(n)/n, x)[n-1:-n+1]
array([ 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5,
9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5, 16.5, 17.5, 18.5])
좋은 점은 다른 가중치 체계를 멋지게 조정한다는 것입니다 (그냥 변경 numpy.ones(n) / n 다른 것에).
여기에서 완전한 자료를 찾을 수 있습니다.http://www.scipy.org/cookbook/signalsmooth
귀하의 질문은 더 자세한 내용을 사용할 수 있지만 다음과 같습니다.
def iterate_over_slices(the_list, slice_size):
for start in range(0, len(the_list)-slice_size):
slice = the_list[start:start+slice_size]
foo(slice)
가까운 중 하나는 라이너(후 itertools 가져오기)의 정맥에서 나디아의 응답을 다루는 비 덩어리를 나눌 수 있기 없 padding:
>>> import itertools as itt
>>> chunksize = 5
>>> myseq = range(18)
>>> cnt = itt.count()
>>> print [ tuple(grp) for k,grp in itt.groupby(myseq, key=lambda x: cnt.next()//chunksize%2)]
[(0, 1, 2, 3, 4), (5, 6, 7, 8, 9), (10, 11, 12, 13, 14), (15, 16, 17)]
당신이 원하는 경우에,당신이 얻을 수 있는 제거 itertools.count() 용 enumerate(), 으로,오히려 더:
[ [e[1] for e in grp] for k,grp in itt.groupby(enumerate(myseq), key=lambda x: x[0]//chunksize%2) ]
(예시: enumerate() 불필요한 것이지만,모든 시퀀스는 깔끔한 범위는 다음과 같이 분명히)
으로 깔끔한 몇 가지 다른 답변,하지만에 유용한 한 스푼을 경우 특히,이 가져오기 itertools.
