如何将列表分成n个相等的部分，python

给定（any）单词列表

lst

，我应该把它分成10个相等的部分

x = len(lst)/10

如何给这些部件指定变量名

在输出中，我需要10个变量（

part1，part2…part10

），其中包含

x

字数。

有关如何生成相等的列表块的信息，请参阅。然后，如果您确实需要将它们放在单独的变量中，您可以执行以下操作：

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

---

但我建议将代码更一般化，而不是将其硬编码为10个部分。

我将编写此代码，以便您学习该技术，但您不应该这样做。像

list

和

set

这样的容器数据类型的要点是，您可以拥有任意内容，而不必为每个元素创建变量。所以

不要这样做

---

（链接问题中的

chunks

配方来自。您不应该这样做的原因是修改

局部变量

（或者确实是

全局变量

或

变量

）这不是一个好的做法：它会导致难以确定的行为，并可能导致非常严重的错误。

一行程序返回列表列表，给定列表和块大小：

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

更新：

---

我认为真正要问的问题是一个函数，给定一个列表和一个数字，它返回一个包含$（数字）列表的列表，原始列表的项目均匀分布。因此，你的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

我相信这是可以改进的，但我觉得很懒。：-）

---

使用元组/列出结果-最合理的方法

如果需要定义新变量，可以

使用

setattr

并向任何

对象添加新属性。这是安全的，因为您不会覆盖现有变量：
res=对象（）
...
setattr（res，“part”+索引，生成part_）

根据代码运行的上下文，将生成的变量添加到

locals（）

或

globals（）

字典中

---

看到了几种解决方案，但无法帮助发布我的：

res = object() ... setattr(res, "part"+index, part_generated)

---

当然，可以进一步总结，但我认为这样读起来很清楚。

如果不需要强制执行连续的输出元素，那么下面的简单代码片段就可以完成这项工作：

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

基本上，代码是基于模剩余对元素进行分组。正因为如此，输出列表中的元素将不连续。例如，如果输入是

范围（21）

，而不是

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

你会得到

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

---

希望能有所帮助。

为了获得与Paulo的更新相同的结果（将列表分成n个大小仅相差1的块），下面是一个使用递归的优雅解决方案

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

例如：

def divide(lst, n):
    p = len(lst) // n
    if len(lst)-p > 0:
        return [lst[:p]] + divide(lst[p:], n-1)
    else:
        return [lst]

---

与数据帧的@henneray相同

lst = list(range(13))
print divide(lst,5) # [[0, 1], [2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]

---

你没有给出零件的名称。返回列表列表。如何拆分

[1,2,3,4,5，…100]

变成

[1,2,3，…]，[11,12,13，…]，…

或

[1,11,21，…]，[2,12,22，…]，…

或random或其他什么？为什么不是一个元组或另一个包含子列表的列表呢？然后使用该位置引用？它将比使用变量更具动态性。res=divide_list（l，10）print res[0]markrian提醒我这个问题不是重复的，所以我的答案是错误的。我渴望重新开张。问题是“如何将列表分成n个相等的部分”，而不是“如何将列表分成大小为n的块”

chunks

不会将l分成n个部分，而是将l分成

len（l）/n+1个部分，如果
len（l）%n！=0
或
len（l）/n
如果
len（l）%n==0
，那么问题实际上是问一个函数，给定一个列表和一个数字，它返回一个包含$（number）列表的列表，原始列表的项目均匀分布。因此，你的lol（x，7）示例应该返回[[20,21,22]，[23,24,25]，[26,27]，[28,29]，[30,31], [32,33], [34,35]]@markrian：提醒你，很多人误解了这个问题，这是它质量的一个指标——但你可能是对的，请看我的更新。哈，我写了一个JS函数，与你的Python函数几乎相同，在我写评论时，一行一行地写：）很好。如果你只想在一个范围内循环，而不是在一个范围内循环，使用xrange会更好操纵生成的列表。生成器表达式是冗余的
def divide(lst, n):
    p = len(lst) // n
    if len(lst)-p > 0:
        return [lst[:p]] + divide(lst[p:], n-1)
    else:
        return [lst]

lst = list(range(13))
print divide(lst,5) # [[0, 1], [2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]

def divide_df(df, n):    
    p = len(df.index) // n # size of one part is length / parts
    if len(df.index) - p > 0: # if a part of size p is still remaining
        return [df.iloc[0:p]] + divide(df.iloc[p:], n-1) # one part is from start to p, recursivly divide rest into n-1 pieces
    else:
        return [df]