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

时间:2010-11-07 18:35:43

标签: python list divide

给出(任何)单词列表lst我应该将它分成10个相等的部分。

x = len(lst)/10

如何给这些部分变量名?

在输出中,我需要10个变量(part1, part2... part10),其中包含x个字数。

8 个答案:

答案 0 :(得分:29)

在给定列表和块大小的情况下,单行返回列表列表:

>>> 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]]。 - 马克里安

嗯,在这种情况下,您可以尝试:

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

答案 1 :(得分:2)

请参阅this question了解如何生成列表的相等块。然后,如果你真的需要它们在单独的变量中,你可以这样做:

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

但我建议使代码更通用,而不是将代码硬编码为10个部分。

答案 2 :(得分:1)

我会写这段代码让你学习这门技巧,但是你不应该这样做。容器数据类型如listset的要点是,您可以拥有任意内容,而无需为每个元素创建变量。所以,

不要这样做

>>> 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's answer。您不应该这样做的原因是修改locals(或确实globals或{{ 1}})不是很好的做法:它会导致难以确定的行为,也可能是非常讨厌的错误。

答案 3 :(得分:1)

如果您不需要强制执行连续的输出元素,那么以下简单代码段将完成此任务:

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

希望它有所帮助。

答案 4 :(得分:1)

为了获得与Paulo更新相同的结果(将列表分成n个大小仅相差1的块),以下是使用递归的优雅解决方案。

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

答案 5 :(得分:0)

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

如果您需要定义新变量,可以

  1. 使用setattr并向任何object添加新属性。这是安全的,因为您不会覆盖现有变量:
    res = object()
    ...
    setattr(res, "part"+index, part_generated)
    
  2. 根据代码运行的上下文,将生成的变量添加到locals()globals()字典。

答案 6 :(得分:0)

看过几个解决方案,但无法帮助我发布:

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

当然可以进一步概括,但我认为这样很清楚。

答案 7 :(得分:0)

与数据帧的@henneray 相同

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]