Cięcie listy na N prawie równej długości partycji [duplikat]

Tylko inne ujęcie, które działa tylko wtedy, gdy [[1,3,5],[2,4]] jest akceptowalną partycją, w twoim przykładzie.

def partition ( lst, n ):
    return [ lst[i::n] for i in xrange(n) ]

To odpowiada przykładowi podanemu w przykładzie @ Daniel Stutzbach:

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

Oto wersja podobna do Daniela: dzieli się tak równomiernie, jak to możliwe, ale umieszcza wszystkie większe partycje na początku:

def partition(lst, n):
    q, r = divmod(len(lst), n)
    indices = [q*i + min(i, r) for i in xrange(n+1)]
    return [lst[indices[i]:indices[i+1]] for i in xrange(n)]

Unika również użycia arytmetyki float, ponieważ zawsze sprawia mi to dyskomfort. :)

Edit: przykład, aby pokazać kontrast z rozwiązaniem Daniela Stutzbacha

>>> print [len(x) for x in partition(range(105), 10)]
[11, 11, 11, 11, 11, 10, 10, 10, 10, 10]

Poniżej jest jeden sposób.

def partition(lst, n):
    increment = len(lst) / float(n)
    last = 0
    i = 1
    results = []
    while last < len(lst):
        idx = int(round(increment * i))
        results.append(lst[last:idx])
        last = idx
        i += 1
    return results

Jeśli len (lst) nie może być równomiernie podzielony przez n, ta wersja rozdzieli dodatkowe elementy w mniej więcej równych odstępach czasu. Na przykład:

>>> print [len(x) for x in partition(range(105), 10)]
[11, 10, 11, 10, 11, 10, 11, 10, 11, 10]

Kod może być prostszy, jeśli nie masz nic przeciwko temu, że wszystkie 11 są na początku lub na końcu.

Ta odpowiedź zapewnia funkcję split(list_, n, max_ratio), dla ludzi którzy chcą podzielić swoją listę na n kawałki z co najwyżej max_ratio stosunek długości części. Pozwala na większą zmienność niż pytanie "co najwyżej 1 różnica w długości części".

Działa poprzez pobieranie próbek n długości części w pożądanym zakresie proporcji [1, max_ratio) , umieszczając je po sobie tworząc " łamaną trzymać "z właściwych odległości między "break points", ale źle Długość całkowita. Skalowanie złamany kij do pożądanej długości daje nam przybliżone pozycje punktów przerwania, które chcemy. Aby uzyskać liczbę całkowitą break points wymaga późniejszego zaokrąglenia.

Niestety, roundings mogą spiskować, aby kawałki były zbyt krótkie, i pozwól przekroczyć max_ratio. Zobacz na dole tej odpowiedzi dla przykład.

import random

def splitting_points(length, n, max_ratio):
    """n+1 slice points [0, ..., length] for n random-sized slices.

    max_ratio is the largest allowable ratio between the largest and the
    smallest part.
    """
    ratios = [random.uniform(1, max_ratio) for _ in range(n)]
    normalized_ratios = [r / sum(ratios) for r in ratios]
    cumulative_ratios = [
        sum(normalized_ratios[0:i])
        for i in range(n+1)
    ]
    scaled_distances = [
        int(round(r * length))
        for r in cumulative_ratios
    ]

    return scaled_distances


def split(list_, n, max_ratio):
    """Slice a list into n randomly-sized parts.

    max_ratio is the largest allowable ratio between the largest and the
    smallest part.
    """

    points = splitting_points(len(list_), n, ratio)

    return [
        list_[ points[i] : points[i+1] ]
        for i in range(n)
    ]

Możesz wypróbować tak:

for _ in range(10):
    parts = split('abcdefghijklmnopqrstuvwxyz', 4, 2)
    print([(len(part), part) for part in parts])

Przykład złego wyniku:

parts = split('abcdefghijklmnopqrstuvwxyz', 10, 2)

# lengths range from 1 to 4, not 2 to 4
[(3, 'abc'),  (3, 'def'), (1, 'g'),
 (4, 'hijk'), (3, 'lmn'), (2, 'op'),
 (2, 'qr'),  (3, 'stu'),  (2, 'vw'),
 (3, 'xyz')]