एक सूची को लगभग बराबर लंबाई के N भागों में विभाजित करना

Question

किसी सूची को मोटे तौर पर समान भागों में विभाजित करने का सबसे अच्छा तरीका क्या है ? उदाहरण के लिए, यदि सूची में 7 तत्व हैं और इसे 2 भागों में विभाजित किया गया है, तो हम एक भाग में 3 तत्व प्राप्त करना चाहते हैं, और दूसरे में 4 तत्व होने चाहिए।

मैं कुछ ऐसी चीजों की तलाश कर रहा हूं even_split(L, n)जो भागों Lमें टूटती हैं n।

def chunks(L, n):
    """ Yield successive n-sized chunks from L.
    """
    for i in range(0, len(L), n):
        yield L[i:i+n]

ऊपर दिया गया कोड 3 के बजाय 3 विखंडू देता है। मैं बस स्थानांतरित कर सकता था (इस पर पुनरावृति कर सकता हूं और प्रत्येक कॉलम का पहला तत्व ले सकता हूं, उस भाग को कॉल कर सकता हूं, फिर दूसरा ले सकता हूं और इसे भाग दो में डाल सकता हूं, आदि), लेकिन यह आइटम के क्रम को नष्ट कर देता है।

Answer 1

यह कोड गोलाई त्रुटियों के कारण टूट गया है। इसका प्रयोग न करें!!!

assert len(chunkIt([1,2,3], 10)) == 10  # fails

---

यहाँ एक है कि काम कर सकता है:

def chunkIt(seq, num):
    avg = len(seq) / float(num)
    out = []
    last = 0.0

    while last < len(seq):
        out.append(seq[int(last):int(last + avg)])
        last += avg

    return out

परिक्षण:

>>> chunkIt(range(10), 3)
[[0, 1, 2], [3, 4, 5], [6, 7, 8, 9]]
>>> chunkIt(range(11), 3)
[[0, 1, 2], [3, 4, 5, 6], [7, 8, 9, 10]]
>>> chunkIt(range(12), 3)
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]

Comments

आपका उदाहरण >>> chunkIt(range(8), 6)=>[[0], [1], [2, 3], [4], [5], [6], [7]]

— nopper

@ नोपर, मैंने एक "अगर संख्या == 1:" को जोड़ा, तो उस किनारे के मामले को संभालने के लिए सशर्त।

— पाउली ४

नए आगंतुक: कृपया इस कोड का उपयोग न करें या इसे बंद न करें , यह टूट गया है। उदाहरण के लिए chunkIt(range(10), 9)9 भागों को वापस करना चाहिए, लेकिन यह नहीं है।

— विम

यह टिप्पणी धागा वास्तव में भ्रमित करने वाला है क्योंकि उत्तर को कई बार संपादित किया गया है। क्या यह एक अच्छा जवाब है? अच्छा जवाब नहीं?

— सितंबर

@conchoecia एक अच्छा जवाब नहीं है, नीचे स्क्रॉल करते रहें। यह अभी तक केवल एक बार संपादित किया गया था, और यह केवल एक तुच्छ संपादन था (2 स्थान इंडेंट 4 में बदल गया)। दुर्भाग्य से ओपी "user248237dfsf" साइट पर 3 वर्षों से नहीं देखा गया है, इसलिए स्वीकृत उत्तर को बदलने की बहुत कम उम्मीद है।

— विम

Answer 2

आप इसे बस एक सूची जनरेटर के रूप में लिख सकते हैं:

def split(a, n):
    k, m = divmod(len(a), n)
    return (a[i * k + min(i, m):(i + 1) * k + min(i + 1, m)] for i in range(n))

उदाहरण:

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

Comments

n = min(n, len(a)) # don't create empty bucketsलाइन 1 पर सम्मिलित करें list(split(range(X, Y)))जहाँ पर खाली बाल्टियाँ बनाने से बचें जैसेX < Y

— abanana

यह देखकर कि मैं अपनी टिप्पणी को संपादित नहीं कर सकता - मुझे यह जोड़ना चाहिए कि मेरा पिछला संशोधन संभवत: शून्य त्रुटि द्वारा एक विभाजन बढ़ा सकता है यदि सूची खाली है, तो इसे या तो बाहरी रूप से नियंत्रित किया जाना चाहिए या समाधान में जोड़ा जाना चाहिए।

— अबनाना

एसओ पर एन उत्तर से, यह एकमात्र ऐसा है जिसने मेरे सभी परीक्षण पास कर लिए हैं। जी जे!

— एविशाएप

stackoverflow.com/a/37414115/210971 एक ही विधि का उपयोग करता है, लेकिन खाली सूची और 0 विभाजन काउंटर के लिए भी काम करता है।

— लुकअहेडअटायरटाइप्स

सुंदर! इसके अलावा, n को रिटर्न स्टेटमेंट में k और n को स्वैप करके

— बैच_साइज के

Answer 3

यह * के लिए raison d'être है numpy.array_split:

>>> import numpy as np
>>> print(*np.array_split(range(10), 3))
[0 1 2 3] [4 5 6] [7 8 9]
>>> print(*np.array_split(range(10), 4))
[0 1 2] [3 4 5] [6 7] [8 9]
>>> print(*np.array_split(range(10), 5))
[0 1] [2 3] [4 5] [6 7] [8 9]

_{* कमरा 6 में जीरो पिरेस को श्रेय}

Comments

क्या है *में printके लिए?

— युक्ली

अरे @#qli, यह एक फ़ंक्शन में व्यक्तिगत तर्कों में किसी चीज़ की सूची को परिवर्तित करता है। कोशिश print(L)और `प्रिंट (* एल)। इसके अलावा stackoverflow.com/a/36908/2184122 देखें या "तारांकन के अजगर उपयोग" के लिए खोजें।

— रॉबर्ट लैग

Answer 4

जब तक आप लगातार चुस्कियों की तरह मूर्खतापूर्ण कुछ भी नहीं चाहते हैं:

>>> def chunkify(lst,n):
...     return [lst[i::n] for i in xrange(n)]
... 
>>> chunkify(range(13), 3)
[[0, 3, 6, 9, 12], [1, 4, 7, 10], [2, 5, 8, 11]]

Comments

मैं यह नहीं कहूंगा कि लगातार चूजे मूर्खतापूर्ण हैं। उदाहरण के लिए, शायद आप चंक्स को क्रमबद्ध रखना चाहते हैं (अर्थात। chunk [0] <chunk [१])।

— tixxit

मैं मज़ाक कर रहा था। लेकिन अगर आपने वास्तव में परवाह नहीं की है, तो सूची समझ के साथ यह तरीका अच्छा और संक्षिप्त है।

— जॉब

यह

— smci

इस आउटपुट को 'जिप' में भेजने से आपको अपनी ऑर्डर की गई सूची मिलती है: zip(*chunkify(range(13), 3))परिणाम[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11)]

— gens

यह समाधान ठीक काम करता है, जब तक कि आपको सूची के क्रम की आवश्यकता नहीं होती है।

— s7anley

Answer 5

कोड को बदलने के nबजाय विखंडू प्राप्त करने के लिए n:

def chunks(l, n):
    """ Yield n successive chunks from l.
    """
    newn = int(len(l) / n)
    for i in xrange(0, n-1):
        yield l[i*newn:i*newn+newn]
    yield l[n*newn-newn:]

l = range(56)
three_chunks = chunks (l, 3)
print three_chunks.next()
print three_chunks.next()
print three_chunks.next()

जो देता है:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]
[18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35]
[36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55]

यह अंतिम समूह को अतिरिक्त तत्व प्रदान करेगा जो कि "लगभग एन बराबर भागों" के आपके विनिर्देश के भीतर सही नहीं है, लेकिन अच्छी तरह से :-), मेरा मतलब है कि 56 तत्व बेहतर होंगे (19,19,18) जबकि यह देता है (18,18,20)।

आप निम्न कोड के साथ अधिक संतुलित आउटपुट प्राप्त कर सकते हैं:

#!/usr/bin/python
def chunks(l, n):
    """ Yield n successive chunks from l.
    """
    newn = int(1.0 * len(l) / n + 0.5)
    for i in xrange(0, n-1):
        yield l[i*newn:i*newn+newn]
    yield l[n*newn-newn:]

l = range(56)
three_chunks = chunks (l, 3)
print three_chunks.next()
print three_chunks.next()
print three_chunks.next()

कौन से आउटपुट:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
[19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37]
[38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55]

Comments

यह मुझे एक अजीब परिणाम देता है। पी में चोंच के लिए (रेंज (54), 3): प्रिंट लेन (पी) रिटर्न 18, 18, 51 ...

निश्चित, कि, यह अंतिम उपज थी।

— पैक्सिडाब्लो

लिंक

— जैकब क्रॉकर

व्यावहारिक विचारों के लिए यह सबसे उपयोगी उत्तर है। धन्यवाद!

— एमवीसीएचआर

जब मैं इसका उपयोग करता हूं for x in chunks(mylist,num): print x, तो मुझे वांछित विखंडन मिलता है, लेकिन उनके बीच मुझे एक खाली सूची मिलती है। कोई विचार क्यों? यही है, मैं बहुत से मिलता है, []प्रत्येक के बाद एक।

— सिनैप्टिक

Answer 6

यदि आप nतत्वों को मोटे तौर पर kविखंडू में विभाजित करते हैं, तो आप n % kअतिरिक्त तत्वों को वितरित करने के लिए अन्य तत्वों की तुलना में 1 तत्वों को बड़ा बना सकते हैं ।

निम्नलिखित कोड आपको विखंडू की लंबाई देगा:

[(n // k) + (1 if i < (n % k) else 0) for i in range(k)]

उदाहरण: n=11, k=3परिणाम में[4, 4, 3]

फिर आप आसानी से गणना के लिए प्रारंभ आकार की गणना कर सकते हैं:

[i * (n // k) + min(i, n % k) for i in range(k)]

उदाहरण: n=11, k=3परिणाम में[0, 4, 8]

i+1वें चंक का उपयोग सीमा के रूप में करने से हमें पता चलता है कि लेन के साथ iसूची का वें हिस्सा हैln

l[i * (n // k) + min(i, n % k):(i+1) * (n // k) + min(i+1, n % k)]

अंतिम चरण के रूप में सूची समझ का उपयोग करके सभी विखंडू से एक सूची बनाएं:

[l[i * (n // k) + min(i, n % k):(i+1) * (n // k) + min(i+1, n % k)] for i in range(k)]

उदाहरण: n=11, k=3, l=range(n)परिणाम में[range(0, 4), range(4, 8), range(8, 11)]

Answer 7

यह एक एकल अभिव्यक्ति द्वारा विभाजन करेगा:

>>> myList = range(18)
>>> parts = 5
>>> [myList[(i*len(myList))//parts:((i+1)*len(myList))//parts] for i in range(parts)]
[[0, 1, 2], [3, 4, 5, 6], [7, 8, 9], [10, 11, 12, 13], [14, 15, 16, 17]]

इस उदाहरण की सूची का आकार 18 है और इसे 5 भागों में विभाजित किया गया है। भागों का आकार एक से अधिक तत्वों में भिन्न नहीं होता है।

Answer 8

देखें more_itertools.divide:

n = 2

[list(x) for x in mit.divide(n, range(5, 11))]
# [[5, 6, 7], [8, 9, 10]]

[list(x) for x in mit.divide(n, range(5, 12))]
# [[5, 6, 7, 8], [9, 10, 11]]

के माध्यम से स्थापित करें > pip install more_itertools।

Answer 9

यहाँ एक है जो Noneसूचियों को समान लंबाई बनाने के लिए जोड़ता है

>>> from itertools import izip_longest
>>> def chunks(l, n):
    """ Yield n successive chunks from l. Pads extra spaces with None
    """
    return list(zip(*izip_longest(*[iter(l)]*n)))

>>> l=range(54)

>>> chunks(l,3)
[(0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51), (1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52), (2, 5, 8, 11, 14, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44, 47, 50, 53)]

>>> chunks(l,4)
[(0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52), (1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53), (2, 6, 10, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50, None), (3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, None)]

>>> chunks(l,5)
[(0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50), (1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51), (2, 7, 12, 17, 22, 27, 32, 37, 42, 47, 52), (3, 8, 13, 18, 23, 28, 33, 38, 43, 48, 53), (4, 9, 14, 19, 24, 29, 34, 39, 44, 49, None)]

Answer 10

यहाँ मेरा समाधान है:

def chunks(l, amount):
    if amount < 1:
        raise ValueError('amount must be positive integer')
    chunk_len = len(l) // amount
    leap_parts = len(l) % amount
    remainder = amount // 2  # make it symmetrical
    i = 0
    while i < len(l):
        remainder += leap_parts
        end_index = i + chunk_len
        if remainder >= amount:
            remainder -= amount
            end_index += 1
        yield l[i:end_index]
        i = end_index

का उत्पादन

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

Answer 11

यहां एक जनरेटर है जो किसी भी सकारात्मक (पूर्णांक) संख्या को चुन सकता है। यदि विखंडू की संख्या इनपुट सूची की लंबाई से अधिक है तो कुछ विखंड खाली हो जाएंगे। यह एल्गोरिथ्म उन्हें अलग करने के बजाय छोटी और लंबी विखंडू के बीच वैकल्पिक करता है।

मैंने ragged_chunksफ़ंक्शन के परीक्षण के लिए कुछ कोड भी शामिल किए हैं ।

''' Split a list into "ragged" chunks

    The size of each chunk is either the floor or ceiling of len(seq) / chunks

    chunks can be > len(seq), in which case there will be empty chunks

    Written by PM 2Ring 2017.03.30
'''

def ragged_chunks(seq, chunks):
    size = len(seq)
    start = 0
    for i in range(1, chunks + 1):
        stop = i * size // chunks
        yield seq[start:stop]
        start = stop

# test

def test_ragged_chunks(maxsize):
    for size in range(0, maxsize):
        seq = list(range(size))
        for chunks in range(1, size + 1):
            minwidth = size // chunks
            #ceiling division
            maxwidth = -(-size // chunks)
            a = list(ragged_chunks(seq, chunks))
            sizes = [len(u) for u in a]
            deltas = all(minwidth <= u <= maxwidth for u in sizes)
            assert all((sum(a, []) == seq, sum(sizes) == size, deltas))
    return True

if test_ragged_chunks(100):
    print('ok')

---

हम कॉल में गुणन को निर्यात करके इसे थोड़ा अधिक कुशल बना सकते हैं range, लेकिन मुझे लगता है कि पिछला संस्करण अधिक पठनीय है (और DRYR)।

def ragged_chunks(seq, chunks):
    size = len(seq)
    start = 0
    for i in range(size, size * chunks + 1, size):
        stop = i // chunks
        yield seq[start:stop]
        start = stop

Answer 12

Numpy.split पर एक नज़र डालें :

>>> a = numpy.array([1,2,3,4])
>>> numpy.split(a, 2)
[array([1, 2]), array([3, 4])]

Comments

और numpy.array_split () और भी पर्याप्त है क्योंकि यह लगभग विभाजित है।

— यरिव

यह काम नहीं करता है यदि सरणी आकार विभाजन की संख्या से विभाज्य नहीं है।

— डैन

यह गलत उत्तर है, आपका समाधान ndarrays की सूची देता है, सूचियों की सूची नहीं

— Chłop Z Lasu

Answer 13

Numpy.linspace विधि का उपयोग करके कार्यान्वयन।

बस उन भागों की संख्या निर्दिष्ट करें जिन्हें आप सरणी में विभाजित करना चाहते हैं। विभाजन लगभग बराबर आकार के होंगे।

उदाहरण :

import numpy as np   
a=np.arange(10)
print "Input array:",a 
parts=3
i=np.linspace(np.min(a),np.max(a)+1,parts+1)
i=np.array(i,dtype='uint16') # Indices should be floats
split_arr=[]
for ind in range(i.size-1):
    split_arr.append(a[i[ind]:i[ind+1]]
print "Array split in to %d parts : "%(parts),split_arr

देता है:

Input array: [0 1 2 3 4 5 6 7 8 9]
Array split in to 3 parts :  [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8, 9])]

Answer 14

मेरा समाधान, समझने में आसान

def split_list(lst, n):
    splitted = []
    for i in reversed(range(1, n + 1)):
        split_point = len(lst)//i
        splitted.append(lst[:split_point])
        lst = lst[split_point:]
    return splitted

और इस पृष्ठ पर सबसे छोटा एक लाइनर (मेरी लड़की द्वारा लिखित)

def split(l, n):
    return [l[int(i*len(l)/n):int((i+1)*len(l)/n-1)] for i in range(n)]

Comments

FYI करें: आपका वन-लाइनर टूट गया है, गलत परिणाम देता है। अन्य सुंदर काम करता है।

— पाउलो फ्रीटस

Answer 15

सूची समझ का उपयोग करना:

def divide_list_to_chunks(list_, n):
    return [list_[start::n] for start in range(n)]

Comments

यह सभी विखंडू को भी बनाने के मुद्दे को संबोधित नहीं करता है।

— SuperBiasedMan

Answer 16

एक और तरीका कुछ इस तरह होगा, यहाँ विचार को ग्रॉपर का उपयोग करना है, लेकिन छुटकारा पाएं None। इस मामले में हमारे पास सूची के पहले भाग में तत्वों से बने सभी 'small_parts' और बाद के भाग के 'big_parts' होंगे। 'बड़े भागों' की लंबाई लेन (small_parts) + 1. हमें दो अलग-अलग उप-भागों के रूप में x पर विचार करने की आवश्यकता है।

from itertools import izip_longest

import numpy as np

def grouper(n, iterable, fillvalue=None): # This is grouper from itertools
    "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
    args = [iter(iterable)] * n
    return izip_longest(fillvalue=fillvalue, *args)

def another_chunk(x,num):
    extra_ele = len(x)%num #gives number of parts that will have an extra element 
    small_part = int(np.floor(len(x)/num)) #gives number of elements in a small part

    new_x = list(grouper(small_part,x[:small_part*(num-extra_ele)]))
    new_x.extend(list(grouper(small_part+1,x[small_part*(num-extra_ele):])))

    return new_x

जिस तरह से मैंने इसे स्थापित किया है वह ट्यूपल्स की सूची देता है:

>>> x = range(14)
>>> another_chunk(x,3)
[(0, 1, 2, 3), (4, 5, 6, 7, 8), (9, 10, 11, 12, 13)]
>>> another_chunk(x,4)
[(0, 1, 2), (3, 4, 5), (6, 7, 8, 9), (10, 11, 12, 13)]
>>> another_chunk(x,5)
[(0, 1), (2, 3, 4), (5, 6, 7), (8, 9, 10), (11, 12, 13)]
>>> 

Answer 17

यहां एक और संस्करण है जो "शेष" तत्वों को सभी हिस्सों में समान रूप से फैलाता है, एक समय में जब तक कोई भी नहीं बचा है। इस कार्यान्वयन में, बड़ा हिस्सा प्रक्रिया की शुरुआत में होता है।

def chunks(l, k):
  """ Yield k successive chunks from l."""
  if k < 1:
    yield []
    raise StopIteration
  n = len(l)
  avg = n/k
  remainders = n % k
  start, end = 0, avg
  while start < n:
    if remainders > 0:
      end = end + 1
      remainders = remainders - 1
    yield l[start:end]
    start, end = end, end+avg

उदाहरण के लिए, 14 तत्वों की सूची से 4 विखंडू उत्पन्न करें:

>>> list(chunks(range(14), 4))
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10], [11, 12, 13]]
>>> map(len, list(chunks(range(14), 4)))
[4, 4, 3, 3]

Answer 18

नौकरी के जवाब के रूप में ही , लेकिन चॉन्क्स की संख्या से छोटे आकार के साथ खाता सूचियों को लेता है।

def chunkify(lst,n):
    [ lst[i::n] for i in xrange(n if n < len(lst) else len(lst)) ]

यदि n (विखंडू की संख्या) 7 है और lst (विभाजित करने की सूची) है [1, 2, 3] तो विखंडू [[0], [2], [2] के बजाय [[0], [1] हैं ], [२], [], [], [], []]

Answer 19

आप यह भी उपयोग कर सकते हैं:

split=lambda x,n: x if not x else [x[:n]]+[split([] if not -(len(x)-n) else x[-(len(x)-n):],n)][0]

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

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

Answer 20

def evenly(l, n):
    len_ = len(l)
    split_size = len_ // n
    split_size = n if not split_size else split_size
    offsets = [i for i in range(0, len_, split_size)]
    return [l[offset:offset + split_size] for offset in offsets]

उदाहरण:

l = [a for a in range(97)] 10 भागों से मिलकर होना चाहिए, प्रत्येक में पिछले एक को छोड़कर 9 तत्व हैं।

आउटपुट:

[[0, 1, 2, 3, 4, 5, 6, 7, 8],
 [9, 10, 11, 12, 13, 14, 15, 16, 17],
 [18, 19, 20, 21, 22, 23, 24, 25, 26],
 [27, 28, 29, 30, 31, 32, 33, 34, 35],
 [36, 37, 38, 39, 40, 41, 42, 43, 44],
 [45, 46, 47, 48, 49, 50, 51, 52, 53],
 [54, 55, 56, 57, 58, 59, 60, 61, 62],
 [63, 64, 65, 66, 67, 68, 69, 70, 71],
 [72, 73, 74, 75, 76, 77, 78, 79, 80],
 [81, 82, 83, 84, 85, 86, 87, 88, 89],
 [90, 91, 92, 93, 94, 95, 96]]

Answer 21

मान लीजिए कि आप एक सूची [1, 2, 3, 4, 5, 6, 7, 8] को 3 तत्व सूचियों में विभाजित करना चाहते हैं

जैसे [[१,२,३], [४, ५, ६], [,3,,]] , जहां यदि शेष बचे हुए तत्व ३ से कम हैं, तो उन्हें एक साथ रखा जाता है।

my_list = [1, 2, 3, 4, 5, 6, 7, 8]
my_list2 = [my_list[i:i+3] for i in range(0, len(my_list), 3)]
print(my_list2)

आउटपुट: [[१,२,३], [४, ५, ६], [2, 2]]

जहाँ एक भाग की लंबाई 3. 3. अपने स्वयं के चंक आकार के साथ 3 बदलें।

Answer 22

1>

import numpy as np

data # your array

total_length = len(data)
separate = 10
sub_array_size = total_length // separate
safe_separate = sub_array_size * separate

splited_lists = np.split(np.array(data[:safe_separate]), separate)
splited_lists[separate - 1] = np.concatenate(splited_lists[separate - 1], 
np.array(data[safe_separate:total_length]))

splited_lists # your output

2>

splited_lists = np.array_split(np.array(data), separate)

Answer 23

def chunk_array(array : List, n: int) -> List[List]:
    chunk_size = len(array) // n 
    chunks = []
    i = 0
    while i < len(array):
        # if less than chunk_size left add the remainder to last element
        if len(array) - (i + chunk_size + 1) < 0:
            chunks[-1].append(*array[i:i + chunk_size])
            break
        else:
            chunks.append(array[i:i + chunk_size])
            i += chunk_size
    return chunks

यहाँ मेरा संस्करण है (मैक्स से प्रेरित)

Answer 24

Linspace को गोल करना और इसे एक सूचकांक के रूप में उपयोग करना amit12690 के प्रस्ताव का एक आसान समाधान है।

function chunks=chunkit(array,num)

index = round(linspace(0,size(array,2),num+1));

chunks = cell(1,num);

for x = 1:num
chunks{x} = array(:,index(x)+1:index(x+1));
end
end

Answer 25

#!/usr/bin/python


first_names = ['Steve', 'Jane', 'Sara', 'Mary','Jack','Bob', 'Bily', 'Boni', 'Chris','Sori', 'Will', 'Won','Li']

def chunks(l, n):
for i in range(0, len(l), n):
    # Create an index range for l of n items:
    yield l[i:i+n]

result = list(chunks(first_names, 5))
print result

इस लिंक से उठाया , और यही मेरी मदद की। मेरी पूर्व-निर्धारित सूची थी।

Answer 26

आप 5 भागों में विभाजित करना चाहते हैं:

p1, p2, p3, p4, p5 = np.split(df, 5)

Comments

यह प्रश्न का उत्तर प्रदान नहीं करता है, उदाहरण के लिए यदि आप पहले से नहीं जानते हैं कि आप इसे पांच टुकड़ों में विभाजित करना चाहते हैं तो आप इसे कैसे लिखेंगे। इसके अलावा, आप (मैं अनुमान लगा रहा हूं) सुन्न और शायद एक पांडा डेटाफ्रेम मान रहे हैं। ओपी एक सामान्य सूची के बारे में पूछ रहा है।

— निकेड

Answer 27

मैंने खुद इस मामले में कोड लिखा है:

def chunk_ports(port_start, port_end, portions):
    if port_end < port_start:
        return None

    total = port_end - port_start + 1

    fractions = int(math.floor(float(total) / portions))

    results = []

    # No enough to chuck.
    if fractions < 1:
        return None

    # Reverse, so any additional items would be in the first range.
    _e = port_end
    for i in range(portions, 0, -1):
        print "i", i

        if i == 1:
            _s = port_start
        else:
            _s = _e - fractions + 1

        results.append((_s, _e))

        _e = _s - 1

    results.reverse()

    return results

divide_ports (1, 10, 9) वापस आएगा

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

Answer 28

यह कोड मेरे लिए काम करता है (पायथन 3-संगत):

def chunkify(tab, num):
    return [tab[i*num: i*num+num] for i in range(len(tab)//num+(1 if len(tab)%num else 0))]

उदाहरण ( bytearray प्रकार के लिए, लेकिन यह सूची के लिए भी काम करता है ):

b = bytearray(b'\x01\x02\x03\x04\x05\x06\x07\x08')
>>> chunkify(b,3)
[bytearray(b'\x01\x02\x03'), bytearray(b'\x04\x05\x06'), bytearray(b'\x07\x08')]
>>> chunkify(b,4)
[bytearray(b'\x01\x02\x03\x04'), bytearray(b'\x05\x06\x07\x08')]

Answer 29

यह एक लम्बाई प्रदान करता है <= n,> = 0

डीईएफ़

 chunkify(lst, n):
    num_chunks = int(math.ceil(len(lst) / float(n))) if n < len(lst) else 1
    return [lst[n*i:n*(i+1)] for i in range(num_chunks)]

उदाहरण के लिए

>>> chunkify(range(11), 3)
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10]]
>>> chunkify(range(11), 8)
[[0, 1, 2, 3, 4, 5, 6, 7], [8, 9, 10]]

Answer 30

मैंने अधिकांश समाधानों की कोशिश की, लेकिन उन्होंने मेरे मामले के लिए काम नहीं किया, इसलिए मैं एक नया कार्य करता हूं जो अधिकांश मामलों के लिए और किसी भी प्रकार के सरणी के लिए काम करता है:

import math

def chunkIt(seq, num):
    seqLen = len(seq)
    total_chunks = math.ceil(seqLen / num)
    items_per_chunk = num
    out = []
    last = 0

    while last < seqLen:
        out.append(seq[last:(last + items_per_chunk)])
        last += items_per_chunk

    return out