Chia một danh sách thành N phần có độ dài xấp xỉ bằng nhau

Cách tốt nhất để chia một danh sách thành các phần gần bằng nhau là gì? Ví dụ: nếu danh sách có 7 phần tử và được chia thành 2 phần, chúng tôi muốn nhận 3 phần tử trong một phần và phần còn lại phải có 4 phần tử.

Tôi đang tìm kiếm một cái gì đó như thế even_split(L, n)vỡ Lthành nnhiều phầ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]

Đoạn mã trên cho các khối 3, thay vì 3 khối. Tôi có thể chuyển đổi đơn giản (lặp lại phần này và lấy phần tử đầu tiên của mỗi cột, gọi phần đó, sau đó lấy phần thứ hai và đặt nó vào phần hai, v.v.), nhưng điều đó phá hủy thứ tự của các mục.

Mã này bị hỏng do lỗi làm tròn. Đừng sử dụng nó!!!

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

Đây là một trong đó có thể làm việc:

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

Kiểm tra:

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

Bạn có thể viết nó khá đơn giản như một trình tạo danh sách:

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

Thí dụ:

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

Đây là raison d'être cho 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]

_{* ghi có vào Zero Piraeus ở phòng 6}

Miễn là bạn không muốn bất cứ điều gì ngớ ngẩn như khối liên tục:

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

Thay đổi mã để mang lại nkhối thay vì khối 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()

cung cấp cho:

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

Điều này sẽ chỉ định các phần tử bổ sung cho nhóm cuối cùng không hoàn hảo nhưng cũng nằm trong đặc điểm kỹ thuật của bạn về "khoảng N phần bằng nhau" :-) Do đó, ý tôi là 56 phần tử sẽ tốt hơn (19,19,18) trong khi điều này mang lại (18,18,20).

Bạn có thể nhận được đầu ra cân bằng hơn với mã sau:

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

đầu ra nào:

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

Nếu bạn chia ncác phần tử thành các phần thô, kbạn có thể thực hiệnn % k phần 1 phần tử lớn hơn các phần khác để phân phối các phần tử phụ.

Đoạn mã sau sẽ cung cấp cho bạn độ dài cho các đoạn:

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

Ví dụ: n=11, k=3kết quả trong[4, 4, 3]

Sau đó, bạn có thể dễ dàng tính toán kích thước bắt đầu cho các khối:

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

Ví dụ: n=11, k=3kết quả trong[0, 4, 8]

Sử dụng i+1đoạn thứ hai làm ranh giới, chúng ta có được rằng iđoạn thứ nhất của danh sách lvới len nlà

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

Bước cuối cùng tạo một danh sách từ tất cả các khối bằng cách hiểu danh sách:

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

Ví dụ: n=11, k=3, l=range(n)kết quả trong[range(0, 4), range(4, 8), range(8, 11)]

Điều này sẽ phân chia bởi một biểu thức duy nhất:

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

Danh sách trong ví dụ này có kích thước 18 và được chia thành 5 phần. Kích thước của các bộ phận khác nhau không quá một yếu tố.

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

Cài đặt qua > pip install more_itertools.

Đây là một bổ sung Noneđể làm cho các danh sách có độ dài bằng nhau

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

Đây là giải pháp của tôi:

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

Sản xuất

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

Đây là một trình tạo có thể xử lý bất kỳ số lượng dương (số nguyên) nào. Nếu số lượng khối lớn hơn chiều dài danh sách đầu vào, một số khối sẽ trống. Thuật toán này xen kẽ giữa các đoạn ngắn và dài thay vì tách biệt chúng.

Tôi cũng đã bao gồm một số mã để kiểm tra ragged_chunkschức năng.

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

Chúng ta có thể thực hiện việc này hiệu quả hơn một chút bằng cách xuất phép nhân vào rangecuộc gọi, nhưng tôi nghĩ phiên bản trước dễ đọc hơn (và DRYer).

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

Có một cái nhìn tại numpy.split :

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

Thực hiện bằng phương pháp numpy.linspace.

Chỉ cần xác định số phần bạn muốn mảng được chia thành. Các phần sẽ có kích thước gần bằng nhau.

Thí dụ :

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

Cung cấp:

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

Giải pháp của tôi, dễ hiểu

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

Và một đoạn ngắn nhất trên trang này (được viết bởi cô gái của tôi)

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

Sử dụng hiểu danh sách:

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

Một cách khác sẽ là một cái gì đó như thế này, ý tưởng ở đây là sử dụng cá mú, nhưng loại bỏ None. Trong trường hợp này, chúng ta sẽ có tất cả 'small_parts' được hình thành từ các phần tử ở phần đầu tiên của danh sách và 'Large_parts' từ phần sau của danh sách. Độ dài của 'phần lớn hơn' là len (small_parts) + 1. Chúng ta cần coi x là hai phần phụ khác nhau.

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

Cách tôi thiết lập sẽ trả về một danh sách các bộ dữ liệu:

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

Đây là một biến thể khác trải đều các phần tử "còn lại" giữa tất cả các phần, từng phần một cho đến khi không còn phần nào. Trong quá trình thực hiện này, các khối lớn hơn xảy ra khi bắt đầu quá trình.

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

Ví dụ: tạo 4 khối từ danh sách 14 phần tử:

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

Giống như câu trả lời của công việc , nhưng đưa vào danh sách tài khoản với kích thước nhỏ hơn số lượng chuncks.

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

nếu n (số khối) là 7 và lst (danh sách cần chia) là [1, 2, 3] các khối là [[0], [1], [2]] thay vì [[0], [1 ], [2], [], [], [], []]

Bạn cũng có thể sử dụng:

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]

Thí dụ:

l = [a for a in range(97)] nên bao gồm 10 phần, mỗi phần có 9 phần tử trừ phần cuối cùng.

Đầu ra:

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

Giả sử bạn muốn chia một danh sách [1, 2, 3, 4, 5, 6, 7, 8] thành 3 danh sách thành phần

như [[1,2,3], [4, 5, 6], [7, 8]] , trong đó nếu các phần tử cuối cùng còn lại nhỏ hơn 3, chúng được nhóm lại với nhau.

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)

Đầu ra: [[1,2,3], [4, 5, 6], [7, 8]]

Trong đó độ dài của một phần là 3. Thay thế 3 bằng kích thước khối của riêng bạn.

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

đây là phiên bản của tôi (lấy cảm hứng từ Max)

Làm tròn không gian và sử dụng nó làm chỉ mục là một giải pháp dễ dàng hơn so với những gì amit12690 đề xuất.

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

Chọn từ liên kết này , và đây là những gì đã giúp tôi. Tôi đã có một danh sách được xác định trước.

nói rằng bạn muốn chia thành 5 phần:

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

Tôi đã tự viết mã trong trường hợp này:

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

split_ports (1, 10, 9) sẽ trở lại

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

mã này hoạt động với tôi (tương thích với Python3):

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

ví dụ (đối với loại bytearray , nhưng nó cũng hoạt động cho danh sách s):

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

Cái này cung cấp các đoạn có độ dài <= n,> = 0

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

ví dụ

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

Tôi đã thử hầu hết các giải pháp, nhưng chúng không hoạt động cho trường hợp của tôi, vì vậy tôi tạo một hàm mới hoạt động cho hầu hết các trường hợp và cho bất kỳ loại mảng nào:

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