Ответ 1

One-liner возвращает список списков, учитывая список и размер блока:

>>> lol = lambda lst, sz: [lst[i:i+sz] for i in range(0, len(lst), sz)]

Тестирование:

>>> x = range(20, 36)
>>> print x
[20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35]

>>> lol(x, 4)
[[20, 21, 22, 23], 
 [24, 25, 26, 27], 
 [28, 29, 30, 31], 
 [32, 33, 34, 35]]

>>> lol(x, 7)
[[20, 21, 22, 23, 24, 25, 26], 
 [27, 28, 29, 30, 31, 32, 33], 
 [34, 35]]

Update:

Я думаю, что действительно заданный вопрос - это функция, которая, учитывая список и число, возвращает список, содержащий списки $(number), причем элементы исходного списка распределены равномерно. Поэтому ваш пример lol (x, 7) должен действительно вернуться [[20,21,22], [23,24,25], [26,27], [28,29], [30,31], [32, 33], [34,35]]. - markrian

Ну, в этом случае вы можете попробовать:

def slice_list(input, size):
    input_size = len(input)
    slice_size = input_size / size
    remain = input_size % size
    result = []
    iterator = iter(input)
    for i in range(size):
        result.append([])
        for j in range(slice_size):
            result[i].append(iterator.next())
        if remain:
            result[i].append(iterator.next())
            remain -= 1
    return result

Я уверен, что это можно улучшить, но я чувствую себя ленивым.: -)

>>> slice_list(x, 7)
[[20, 21, 22], [23, 24, 25], 
 [26, 27], [28, 29], 
 [30, 31], [32, 33], 
 [34, 35]]

Ответ 2

См. этот вопрос о том, как создавать равные куски списка. Затем, если вы действительно нуждаетесь в них в отдельных переменных, вы можете сделать:

part1, part2, ..., part10 = (part for part in chunks(lst, len(lst)/10))

Но я бы рекомендовал сделать код более общим, а не жестко кодировать его на 10 частей.

Ответ 3

Я напишу этот код, чтобы вы узнали технику, но вы не должны этого делать. Точка типов данных контейнера, таких как list и set, состоит в том, что вы можете иметь произвольное содержимое без необходимости создавать переменные для каждого элемента. Таким образом,

Не делайте этого

>>> def chunks(l, n):
...     for i in xrange(0, len(l), n):
...         yield l[i:i+n]
...
>>> for i, chunk in enumerate(chunks(range(100), 10)):
...     locals()["part{0}".format(i)] = chunk
...
>>> part0
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> part1
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> part2
[20, 21, 22, 23, 24, 25, 26, 27, 28, 29]

(рецепт chunks от Ответ Ned Batchelder в связанном вопросе. Причина, по которой вы не должны этого делать, заключается в том, что изменение locals (или действительно globals или vars) не является хорошей практикой: он вызывает трудноопределяемое поведение и, возможно, очень неприятные ошибки.

Ответ 4

Если вам не нужно принудительно использовать смежные элементы выходных элементов, следующий рабочий фрагмент выполнит следующее задание:

def even_divide(lst, num_piece=4):
    return [
        [lst[i] for i in range(len(lst)) if (i % num_piece) == r]
        for r in range(num_piece)
    ]

В основном код группирует элементы на основе по модулю остатков. И из-за этого элементы в выходном списке не будут смежными. Например, если вход range(21), вместо

[[0, 1, 2, 3, 4, 5],[6, 7, 8, 9, 10],[11, 12, 13, 14, 15],[16, 17, 18, 19, 20]]

вы получите

[[0, 4, 8, 12, 16, 20],[1, 5, 9, 13, 17],[2, 6, 10, 14, 18],[3, 7, 11, 15, 19]]

Надеюсь, что это поможет.

Ответ 5

Использовать кортеж/список результата - наиболее разумный подход

Если вам нужно определить новые переменные, вы можете

• используйте setattr и добавьте новые атрибуты в любой object. Это безопасно, поскольку вы не будете перезаписывать существующие переменные:

  res = объект()
  ...
  setattr (res, "part" + index, part_generated)
  

• добавить сгенерированные переменные в словарь locals() или globals() в зависимости от контекста, в котором работает ваш код.

Ответ 6

Увидел несколько решений, но не смог помочь мне:

# List
lst = range(103)

# number of slices
nSlices = 10

# splitted list
slices = [len(lst) // (nSlices)] * nSlices

# but points are still missing!
remainder = len(lst)-sum(slices)

# split missing points across slices
slices[:remainder] = [ii + 1 for ii in slices[:remainder]]

splittedList = [lst[sum(slices[:ii]):sum(slices[:ii+1])] for ii in                range(nSlices)]
print lst
print '\n'.join("{}".format(n) for n in splittedList)

Возможно, можно, конечно, обобщить, но я думаю, что это понятно, что читать.