Разбиение списка на 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 xrange(0, len(L), n):
        yield L[i:i+n]

Приведенный выше код дает 3 порции, а не 3 порции. Я мог бы просто транспонировать (перебрать это и взять первый элемент каждого столбца, вызвать эту часть первую, затем взять второй и поместить его во вторую часть и т. Д.), Но это разрушает порядок элементов.

Answer 1

Реализация с использованием метода 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 2

Вот генератор, который может обрабатывать любое положительное (целое) количество кусков. Если количество чанков превышает длину входного списка, некоторые чанки будут пустыми. Этот алгоритм чередует короткие и длинные чанки, а не разделяет их.

Я также включил некоторый код для тестирования функции 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, но я думаю, что предыдущая версия более читабельна (и 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

Answer 3

скажем, вы хотите разделить на 5 частей:

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

Answer 4

Это сделает разделение одним выражением:

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

Мое решение, простое для понимания

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

Answer 6

Использование списка понимания:

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

Answer 7

Я сам написал код для этого случая:

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

div_ports (1, 10, 9) вернет

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

Answer 8

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

Другим способом было бы что-то вроде этого, идея в том, чтобы использовать grouper, но избавиться от None. В этом случае у нас будут все 'small_parts', сформированные из элементов в первой части списка, и 'large_parts' из последней части списка. Длина «больших частей» равна len (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 10

Вот еще один вариант, который равномерно распределяет «оставшиеся» элементы по всем кускам, по одному, пока не останется ни одного. В этой реализации более крупные фрагменты появляются в начале процесса.

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

Например, сгенерировать 4 фрагмента из списка из 14 элементов:

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