网站空间在那里买/百度商城官网

本问题已经有最佳答案，请猛点这里访问。

我正在寻找一种快速，干净，pythonic的方式将列表分为正好n个几乎相等的分区。

partition([1,2,3,4,5],5)->[[1],[2],[3],[4],[5]]

partition([1,2,3,4,5],2)->[[1,2],[3,4,5]] (or [[1,2,3],[4,5]])

partition([1,2,3,4,5],3)->[[1,2],[3,4],[5]] (there are other ways to slice this one too)

在这里，对列表切片的迭代有很多个答案，它们与我想要的非常接近，除了它们专注于列表的大小，而且我关心列表的数量(其中一些还填充了None)。 显然，这些都是微不足道的转换，但是我正在寻找最佳实践。

同样，人们在这里指出了很好的解决方案如何将列表分成大小均匀的块？ 对于一个非常类似的问题，但是我对分区的数量而不是特定大小更感兴趣，只要它在1之内即可。同样，这是微不足道的，但是我正在寻找一种最佳实践。

在您的示例中，仅采取不同的做法，仅当[[1,3,5],[2,4]]是可接受的分区时才有效。

def partition ( lst, n ):

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

这满足@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]]

这是一个很棒的pythonic解决方案

我觉得必须有一些巧妙的方法来获取原始的所需输入，但是zip( *partition(range(105),10) )无效，因为zip会被截断...仍然非常好。

哦，天哪，这太好了。

如果最长使用itertools.izip，它应该可以工作

这是一个与Daniel相似的版本：它尽可能均匀地划分，但将所有较大的分区放在开头：

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

它还避免了使用浮点运算，因为这总是让我感到不舒服。 :)

编辑：一个例子，只是为了展示与丹尼尔·斯图茨巴赫解决方案的对比

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

[11, 11, 11, 11, 11, 10, 10, 10, 10, 10]

def partition(lst, n):

division = len(lst) / float(n)

return [ lst[int(round(division * i)): int(round(division * (i + 1)))] for i in xrange(n) ]

>>> partition([1,2,3,4,5],5)

[[1], [2], [3], [4], [5]]

>>> partition([1,2,3,4,5],2)

[[1, 2, 3], [4, 5]]

>>> partition([1,2,3,4,5],3)

[[1, 2], [3, 4], [5]]

>>> partition(range(105), 10)

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

Python 3版本：

def partition(lst, n):

division = len(lst) / n

return [lst[round(division * i):round(division * (i + 1))] for i in range(n)]

对于不平凡的例子，这是行不通的。对于partition(range(105), 10)，最后一个子列表将只有6个元素。

您将如何拆分该列表？

@JG：10个项目的5个子列表和11个项目的5个子列表。

@Daniel：足够公平，尽管在最初的问题中这还不是很清楚。现在已"修复"。

@JG：我相信" n几乎相等"是指" n几乎相等"。即使含糊不清，"只要它在1之内"也是一个强烈的暗示。

下面是一种方法。

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

如果len(lst)无法被n平均除，则此版本将以大致相等的间隔分配额外的项。例如：

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

[11, 10, 11, 10, 11, 10, 11, 10, 11, 10]

如果您不介意所有11开头或结尾处的代码，则代码可能会更简单。

浮点数的使用可能导致与机器相关的结果：当增量* i(在数学上)恰好位于两个整数的中间时，根据引入的数值误差，舍入可以采用任何一种方法。如何使用类似idx = len(lst)*in的东西呢？或idx = (len(lst)*i + n2)n以获得类似于当前代码的结果。

仅供参考，这是著名的Bresenham算法。

此答案为人提供了功能split(list_, n, max_ratio)

谁想要将他们的名单分成最多max_ratio个n个

片长之比。它比

发问者的"件长最多相差1"。

通过在所需比例范围内采样n个工件长度来工作

[1，max_ratio)，将它们彼此依次放置以形成"断

坚持'在'断点'之间的正确距离，但错误

总长度。将折断的棍子缩放到所需的长度可以使我们

我们想要的断点的大概位置。得到整数

断点需要随后的舍入。

不幸的是，四舍五入可能会合计制作太短的片段，

并让您超过max_ratio。请参阅此答案的底部以获取

例。

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)

]

您可以这样尝试：

for _ in range(10):

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

print([(len(part), part) for part in parts])

错误结果示例：

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