Bir listeyi yaklaşık eşit uzunlukta N parçalara bölme

Bir listeyi kabaca eşit parçalara bölmenin en iyi yolu nedir ? Örneğin, listede 7 öğe varsa ve 2 parçaya bölünmüşse, bir parçada 3 öğe almak istiyoruz, diğerinde 4 öğe olmalıdır.

Ben böyle bir şey arıyorum even_split(L, n)o sonları Liçine nparçaları.

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

Yukarıdaki kod 3 parça yerine 3 parça verir. Basitçe devredebilirim (bunun üzerinde yineleme yapabilir ve her sütunun ilk öğesini alabilir, o bölüm birini çağırır, sonra ikincisini alır ve ikinci bölüme koyarım, vb), ancak bu öğelerin sırasını yok eder.

Bu kod yuvarlama hataları nedeniyle bozuldu. Bunu kullanma!!!

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

İşte işe yarayabilecek biri:

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

Test yapmak:

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

Bir liste üreticisi olarak oldukça basit bir şekilde yazabilirsiniz:

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

Misal:

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

Bu varlık amacı için 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. odada Sıfır Pire kredisi}

Sürekli parçalar gibi aptalca bir şey istemediğiniz sürece:

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

Kodun, aşağıdaki nparçalardan ziyade parçalar verecek şekilde değiştirilmesi 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()

hangi verir:

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

Bu, son gruba mükemmel olmayan ama "kabaca N eşit parça" belirtiminiz dahilinde fazladan elemanlar atayacaktır :-) Yani, 56 eleman (19,19,18) olarak daha iyi olurken (18,18,20).

Aşağıdaki kodla daha dengeli bir çıktı elde edebilirsiniz:

#!/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()

hangi çıktılar:

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

nElemanları kabaca kparçalara ayırırsanız n % k, ekstra elemanları dağıtmak için parçaları 1 parçadan diğer parçalardan daha büyük yapabilirsiniz .

Aşağıdaki kod, parçaların uzunluğunu verecektir:

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

Örnek: n=11, k=3sonuçları[4, 4, 3]

Daha sonra, parçalar için başlangıç ​​indekslerini kolayca hesaplayabilirsiniz:

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

Örnek: n=11, k=3sonuçları[0, 4, 8]

Kullanılması i+1sınır olarak inci yığın elde ederiz o ilistenin inci yığınl len ile nolan

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

Son adım olarak, liste kavrayışını kullanarak tüm parçalardan bir liste oluşturun:

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

Örnek: n=11, k=3, l=range(n)sonuçları[range(0, 4), range(4, 8), range(8, 11)]

Bu, bölünmeyi tek bir ifadeyle yapar:

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

Bu örnekteki liste 18 boyuta sahiptir ve 5 parçaya bölünmüştür. Parçaların boyutu birden fazla elemanda farklılık göstermez.

Bakınız 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]]

Yoluyla yükleyin > pip install more_itertools.

İşte ekler biridir Nonelisteleri eşit uzunluğa getirmek için

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

İşte benim çözümüm:

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

üretir

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

İşte herhangi bir pozitif (tamsayı) parça yığınını işleyebilen bir jeneratör. Parça sayısı giriş listesi uzunluğundan büyükse, bazı parçalar boş olacaktır. Bu algoritma, ayırmak yerine kısa ve uzun parçalar arasında değişir.

Ayrıca ragged_chunksişlevi test etmek için bazı kod dahil ettik .

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

Çarpmayı çağrıya aktararak bunu biraz daha verimli hale getirebiliriz range, ancak önceki sürümün daha okunabilir (ve DRYer) olduğunu düşünüyorum.

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

Numpy.split dosyasına bir göz atın :

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

Numpy.linspace yöntemi kullanılarak uygulama.

Dizinin bölünmesini istediğiniz parça sayısını belirtin. Bölmeler neredeyse eşit büyüklükte olacaktır.

Misal :

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

Verir:

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

Benim çözümüm, anlaşılması kolay

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

Ve bu sayfadaki en kısa tek astar (kızım tarafından yazılmıştır)

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

Liste kavrayışı kullanma:

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

Başka bir yol böyle bir şey olurdu, burada fikir orfoz kullanmak, ancak kurtulmaktır None. Bu durumda, listenin ilk bölümündeki öğelerden oluşan tüm 'küçük_partalar' ve listenin sonraki bölümündeki 'daha büyük_partalar' olacak. 'Büyük parçaların' uzunluğu len (küçük_parçalar) + 1'dir. X'i iki farklı alt parça olarak düşünmeliyiz.

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

Ben kurmak nasıl tuples bir listesini döndürür:

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

"Kalan" öğeleri, tüm parçalar arasında eşit olarak dağıtan başka bir varyant var. Bu uygulamada, daha büyük parçalar sürecin başında meydana gelir.

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

Örneğin, 14 öğeden oluşan bir listeden 4 parça oluşturun:

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

Aynı işin cevabı ancak chuncks sayısından daha küçük boyutta olan hesap listeleri dikkate alır.

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

n (parça sayısı) 7 ve lst (bölünecek liste) [1, 2, 3] ise parçalar [[0], [1 yerine [[0], [1], [2]] ], [2], [], [], [], []]

Ayrıca şunları kullanabilirsiniz:

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

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]

Misal:

l = [a for a in range(97)] 10 parçadan oluşmalı, her biri sonuncusu hariç 9 elemente sahip olmalıdır.

Çıktı:

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

Bir listeyi [1, 2, 3, 4, 5, 6, 7, 8] 3 öğe listesine bölmek istediğinizi varsayalım

gibi [[1,2,3], [4, 5, 6], [7, 8]] kalan son geri kalan elemanları 3 den az, birlikte gruplandırılmıştır ise.

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)

Çıktı: [[1,2,3], [4, 5, 6], [7, 8]]

Bir parçanın uzunluğunun 3. olduğu yer. 3'ü kendi yığın boyutunuzla değiştirin.

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)

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

işte benim versiyonum (Max'in esinlenerek)

Linspace'i yuvarlamak ve bir indeks olarak kullanmak, amit12690'ın önerdiğinden daha kolay bir çözümdür.

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

#!/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

Bu bağlantıdan seçildi ve bana yardımcı olan buydu. Önceden tanımlanmış bir listem vardı.

5 parçaya bölmek istediğinizi varsayalım:

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

Bu durumda kendim kod yazdım:

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) dönecekti

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

bu kod benim için çalışıyor (Python3 uyumlu):

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

örnek ( bytearray türü için, ancak listeler için de çalışır ):

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

Bu, <= n,> = 0 uzunluğunda parçalar sağlar

def

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

Örneğin

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

Çözümlerin çoğunu denedim, ancak benim durumum için işe yaramadı, bu yüzden çoğu durumda ve dizi herhangi bir türü için çalışan yeni bir işlev yapıyorum:

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