cách chia một phần có thể lặp lại thành các phần có kích thước không đổi

Có thể trùng lặp:
Làm cách nào để bạn chia danh sách thành các phần có kích thước đồng đều trong Python?

Tôi rất ngạc nhiên vì tôi không thể tìm thấy một hàm "batch" sẽ lấy làm đầu vào là một tệp có thể lặp lại và trả về một tệp lặp có thể lặp lại.

Ví dụ:

for i in batch(range(0,10), 1): print i
[0]
[1]
...
[9]

hoặc là:

for i in batch(range(0,10), 3): print i
[0,1,2]
[3,4,5]
[6,7,8]
[9]

Bây giờ, tôi đã viết những gì tôi nghĩ là một máy phát điện khá đơn giản:

def batch(iterable, n = 1):
   current_batch = []
   for item in iterable:
       current_batch.append(item)
       if len(current_batch) == n:
           yield current_batch
           current_batch = []
   if current_batch:
       yield current_batch

Nhưng những điều trên không mang lại cho tôi những gì tôi mong đợi:

for x in   batch(range(0,10),3): print x
[0]
[0, 1]
[0, 1, 2]
[3]
[3, 4]
[3, 4, 5]
[6]
[6, 7]
[6, 7, 8]
[9]

Vì vậy, tôi đã bỏ lỡ điều gì đó và điều này có thể cho thấy sự thiếu hiểu biết của tôi về trình tạo python. Có ai muốn chỉ cho tôi đi đúng hướng không?

[Chỉnh sửa: Cuối cùng tôi nhận ra rằng hành vi trên chỉ xảy ra khi tôi chạy điều này trong ipython chứ không phải chính python]

Điều này có lẽ hiệu quả hơn (nhanh hơn)

def batch(iterable, n=1):
    l = len(iterable)
    for ndx in range(0, l, n):
        yield iterable[ndx:min(ndx + n, l)]

for x in batch(range(0, 10), 3):
    print x

Ví dụ sử dụng danh sách

data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # list of data 

for x in batch(data, 3):
    print(x)

# Output

[0, 1, 2]
[3, 4, 5]
[6, 7, 8]
[9, 10]

Nó tránh xây dựng danh sách mới.

FWIW, công thức nấu ăn trong mô-đun itertools cung cấp ví dụ sau:

def grouper(n, iterable, fillvalue=None):
    "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
    args = [iter(iterable)] * n
    return zip_longest(fillvalue=fillvalue, *args)

Nó hoạt động như thế này:

>>> list(grouper(3, range(10)))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, None, None)]

Như những người khác đã lưu ý, mã bạn đã cung cấp thực hiện chính xác những gì bạn muốn. Đối với một cách tiếp cận khác bằng cách sử dụng, itertools.islicebạn có thể xem một ví dụ về công thức sau:

from itertools import islice, chain

def batch(iterable, size):
    sourceiter = iter(iterable)
    while True:
        batchiter = islice(sourceiter, size)
        yield chain([batchiter.next()], batchiter)

Tôi chỉ đưa ra một câu trả lời. Tuy nhiên, bây giờ tôi cảm thấy giải pháp tốt nhất có thể là không viết bất kỳ chức năng mới nào. More-itertools bao gồm nhiều công cụ bổ sung và chunkednằm trong số đó.

Kỳ lạ, dường như hoạt động tốt đối với tôi trong Python 2.x

>>> def batch(iterable, n = 1):
...    current_batch = []
...    for item in iterable:
...        current_batch.append(item)
...        if len(current_batch) == n:
...            yield current_batch
...            current_batch = []
...    if current_batch:
...        yield current_batch
...
>>> for x in batch(range(0, 10), 3):
...     print x
...
[0, 1, 2]
[3, 4, 5]
[6, 7, 8]
[9]

Đây là một đoạn mã rất ngắn mà tôi biết không sử dụng lenvà hoạt động trong cả Python 2 và 3 (không phải do tôi tạo):

def chunks(iterable, size):
    from itertools import chain, islice
    iterator = iter(iterable)
    for first in iterator:
        yield list(chain([first], islice(iterator, size - 1)))

Giải pháp cho Python 3.8 nếu bạn đang làm việc với các tệp lặp không xác định một lenhàm và bị kiệt sức:

def batcher(iterable, batch_size):
    while batch := list(islice(iterable, batch_size)):
        yield batch

Ví dụ sử dụng:

def my_gen():
    yield from range(10)
 
for batch in batcher(my_gen(), 3):
    print(batch)

>>> [0, 1, 2]
>>> [3, 4, 5]
>>> [6, 7, 8]
>>> [9]

Tất nhiên có thể được thực hiện mà không có nhà điều hành hải mã.

Đây là những gì tôi sử dụng trong dự án của mình. Nó xử lý các tệp lặp hoặc danh sách hiệu quả nhất có thể.

def chunker(iterable, size):
    if not hasattr(iterable, "__len__"):
        # generators don't have len, so fall back to slower
        # method that works with generators
        for chunk in chunker_gen(iterable, size):
            yield chunk
        return

    it = iter(iterable)
    for i in range(0, len(iterable), size):
        yield [k for k in islice(it, size)]


def chunker_gen(generator, size):
    iterator = iter(generator)
    for first in iterator:

        def chunk():
            yield first
            for more in islice(iterator, size - 1):
                yield more

        yield [k for k in chunk()]

def batch(iterable, n):
    iterable=iter(iterable)
    while True:
        chunk=[]
        for i in range(n):
            try:
                chunk.append(next(iterable))
            except StopIteration:
                yield chunk
                return
        yield chunk

list(batch(range(10), 3))
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]

Điều này sẽ hoạt động cho bất kỳ có thể lặp lại.

from itertools import zip_longest, filterfalse

def batch_iterable(iterable, batch_size=2): 
    args = [iter(iterable)] * batch_size 
    return (tuple(filterfalse(lambda x: x is None, group)) for group in zip_longest(fillvalue=None, *args))

Nó sẽ hoạt động như thế này:

>>>list(batch_iterable(range(0,5)), 2)
[(0, 1), (2, 3), (4,)]

Tái bút: Nó sẽ không hoạt động nếu có thể lặp lại không có giá trị nào.

Đây là một cách tiếp cận bằng cách sử dụng reducehàm.

Lót:

from functools import reduce
reduce(lambda cumulator,item: cumulator[-1].append(item) or cumulator if len(cumulator[-1]) < batch_size else cumulator + [[item]], input_array, [[]])

Hoặc phiên bản dễ đọc hơn:

from functools import reduce
def batch(input_list, batch_size):
  def reducer(cumulator, item):
    if len(cumulator[-1]) < batch_size:
      cumulator[-1].append(item)
      return cumulator
    else:
      cumulator.append([item])
    return cumulator
  return reduce(reducer, input_list, [[]])

Kiểm tra:

>>> batch([1,2,3,4,5,6,7], 3)
[[1, 2, 3], [4, 5, 6], [7]]
>>> batch(a, 8)
[[1, 2, 3, 4, 5, 6, 7]]
>>> batch([1,2,3,None,4], 3)
[[1, 2, 3], [None, 4]]

Bạn chỉ có thể nhóm các mục có thể lặp lại theo chỉ mục hàng loạt của chúng.

def batch(items: Iterable, batch_size: int) -> Iterable[Iterable]:
    # enumerate items and group them by batch index
    enumerated_item_groups = itertools.groupby(enumerate(items), lambda t: t[0] // batch_size)
    # extract items from enumeration tuples
    item_batches = ((t[1] for t in enumerated_items) for key, enumerated_items in enumerated_item_groups)
    return item_batches

Nó thường xảy ra khi bạn muốn thu thập các vòng lặp bên trong, vì vậy đây là phiên bản nâng cao hơn.

def batch_advanced(items: Iterable, batch_size: int, batches_mapper: Callable[[Iterable], Any] = None) -> Iterable[Iterable]:
    enumerated_item_groups = itertools.groupby(enumerate(items), lambda t: t[0] // batch_size)
    if batches_mapper:
        item_batches = (batches_mapper(t[1] for t in enumerated_items) for key, enumerated_items in enumerated_item_groups)
    else:
        item_batches = ((t[1] for t in enumerated_items) for key, enumerated_items in enumerated_item_groups)
    return item_batches

Ví dụ:

print(list(batch_advanced([1, 9, 3, 5, 2, 4, 2], 4, tuple)))
# [(1, 9, 3, 5), (2, 4, 2)]
print(list(batch_advanced([1, 9, 3, 5, 2, 4, 2], 4, list)))
# [[1, 9, 3, 5], [2, 4, 2]]

Chức năng liên quan bạn có thể cần:

def batch(size, i):
    """ Get the i'th batch of the given size """
    return slice(size* i, size* i + size)

Sử dụng:

>>> [1,2,3,4,5,6,7,8,9,10][batch(3, 1)]
>>> [4, 5, 6]

Nó lấy lô thứ i từ chuỗi và nó cũng có thể hoạt động với các cấu trúc dữ liệu khác, như pandas dataframes ( df.iloc[batch(100,0)]) hoặc numpy array ( array[batch(100,0)]).

from itertools import *

class SENTINEL: pass

def batch(iterable, n):
    return (tuple(filterfalse(lambda x: x is SENTINEL, group)) for group in zip_longest(fillvalue=SENTINEL, *[iter(iterable)] * n))

print(list(range(10), 3)))
# outputs: [(0, 1, 2), (3, 4, 5), (6, 7, 8), (9,)]
print(list(batch([None]*10, 3)))
# outputs: [(None, None, None), (None, None, None), (None, None, None), (None,)]

tôi sử dụng

def batchify(arr, batch_size):
  num_batches = math.ceil(len(arr) / batch_size)
  return [arr[i*batch_size:(i+1)*batch_size] for i in range(num_batches)]