निरंतर-आकार के टुकड़ों में एक पुनरावृत्ति को कैसे विभाजित किया जाए

Question 1

संभव डुप्लिकेट:
आप पायथन में समान रूप से आकार के विखंडू में एक सूची को कैसे विभाजित करते हैं?

मुझे आश्चर्य है कि मुझे एक "बैच" फ़ंक्शन नहीं मिला जो इनपुट के रूप में एक पुनरावृत्ति ले और पुनरावृत्तियों के पुनरावृत्ति को वापस कर सके।

उदाहरण के लिए:

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

या:

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

अब, मैंने लिखा है कि मुझे लगा कि एक बहुत ही सरल जनरेटर था:

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]
[0, 1]
[0, 1, 2]
[3]
[3, 4]
[3, 4, 5]
[6]
[6, 7]
[6, 7, 8]
[9]

इसलिए, मैंने कुछ याद किया है और यह संभवतः अजगर जनरेटर की समझ की पूरी कमी को दर्शाता है। कोई भी मुझे सही दिशा में इंगित करने के लिए परवाह करेगा?

[संपादित करें: मैंने अंततः महसूस किया कि उपरोक्त व्यवहार केवल तब होता है जब मैं इसे अजगर के बजाय इसे अजगर के भीतर चलाता हूं]

Question 2

यह शायद अधिक कुशल (तेज) है

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

सूची का उपयोग करके उदाहरण

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]

यह नई सूची बनाने से बचता है।

Question 3

FWIW, itertools मॉड्यूल में व्यंजनों इस उदाहरण प्रदान करता है:

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

यह इस तरह काम करता है:

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

Question 4

जैसा कि दूसरों ने नोट किया है, आपके द्वारा दिया गया कोड वही होता है जो आप चाहते हैं। एक अन्य दृष्टिकोण के लिए itertools.isliceआप निम्नलिखित नुस्खा का एक उदाहरण देख सकते हैं :

from itertools import islice, chain

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

Question 5

मैंने सिर्फ एक जवाब दिया। हालाँकि, अब मुझे लगता है कि सबसे अच्छा समाधान हो सकता है कि कोई नया कार्य न लिखा जाए। अधिक-इटर्टूल में बहुत सारे अतिरिक्त टूल शामिल हैं, और chunkedउनमें से एक है।

Question 6

अजीब लगता है, मेरे लिए पायथन 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]

Question 7

यह एक बहुत छोटा कोड स्निपेट है जो मैं जानता हूं कि lenपायथन 2 और 3 (मेरी रचना नहीं) के तहत उपयोग और काम नहीं करता है:

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

Question 8

पायथन 3.8 के लिए समाधान यदि आप पुनरावृत्तियों के साथ काम कर रहे हैं जो एक lenफ़ंक्शन को परिभाषित नहीं करता है , और थक गया है:

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

उदाहरण का उपयोग:

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]

बेशक वालरस ऑपरेटर के बिना भी लागू किया जा सकता है।

Question 9

यह मैं अपने प्रोजेक्ट में उपयोग करता हूं। यह पुनरावृत्तियों या सूचियों को यथासंभव कुशलता से संभालता है।

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()]

Question 10

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]]

Question 11

यह किसी भी चलने के लिए काम करेगा।

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))

यह इस तरह काम करेगा:

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

पुनश्च: यह काम नहीं करेगा अगर चलने योग्य कोई भी मूल्य नहीं है।

Question 12

यहाँ reduceफ़ंक्शन का उपयोग करके एक दृष्टिकोण है।

एक लाइन:

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, [[]])

या अधिक पठनीय संस्करण:

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, [[]])

परीक्षा:

>>> 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]]

Question 13

आप केवल उनके बैच इंडेक्स द्वारा चलने योग्य आइटम समूह कर सकते हैं।

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

अक्सर ऐसा होता है जब आप आंतरिक पुनरावृत्तियों को इकट्ठा करना चाहते हैं, इसलिए यहां अधिक उन्नत संस्करण है।

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

उदाहरण:

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]]

Question 14

संबंधित कार्यक्षमता जिसकी आपको आवश्यकता हो सकती है:

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

उपयोग:

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

इसे अनुक्रम से i'th बैच मिलता है और यह अन्य डेटा संरचनाओं के साथ-साथ पांडा df.iloc[batch(100,0)]डेटाफ्रेम ( ) या संख्यात्मक सरणी ( array[batch(100,0)]) की तरह काम कर सकता है ।

Question 15

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,)]

Question 16

मैं उपयोग करता हूं

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)]

Question 17

तब तक लेते रहें, जब तक यह खत्म न हो जाए।

def chop(n, iterable):
    iterator = iter(iterable)
    while chunk := list(take(n, iterator)):
        yield chunk


def take(n, iterable):
    iterator = iter(iterable)
    for i in range(n):
        try:
            yield next(iterator)
        except StopIteration:
            return