18

我正在为此苦苦挣扎，因为我确信十几个 for 循环不是解决这个问题的方法：

有一个排序的数字列表，例如

numbers = [123, 124, 128, 160, 167, 213, 215, 230, 245, 255, 257, 400, 401, 402, 430]

我想创建一个带有数字列表的字典，其中数字的差异（彼此跟随）不超过 15。所以输出将是这样的：

clusters = {
    1 : [123, 124, 128],
    2 : [160, 167],
    3 : [213, 215, 230, 245, 255, 257],
    4 : [400, 401, 402],
    5 : [430]
}

我目前的解决方案有点难看（我必须在最后删除重复项......），我确信它可以以 python 的方式完成。

这就是我现在所做的：

clusters = {}  
dIndex = 0 
for i in range(len(numbers)-1) :
    if numbers[i+1] - numbers[i] <= 15 :
        if not clusters.has_key(dIndex) : clusters[dIndex] = []
        clusters[dIndex].append(numbers[i])
        clusters[dIndex].append(numbers[i+1])
    else : dIndex += 1
4

5 回答 5

26

如果您的列表很小，则不是绝对必要的，但我可能会以“流处理”方式处理此问题：定义一个生成器，该生成器将您的输入迭代，并产生分组为相差 <= 15 的数字运行的元素。然后您可以使用它轻松生成字典。

def grouper(iterable):
    prev = None
    group = []
    for item in iterable:
        if prev is None or item - prev <= 15:
            group.append(item)
        else:
            yield group
            group = [item]
        prev = item
    if group:
        yield group

numbers = [123, 124, 128, 160, 167, 213, 215, 230, 245, 255, 257, 400, 401, 402, 430]
dict(enumerate(grouper(numbers), 1))

印刷：

{1: [123, 124, 128],
 2: [160, 167],
 3: [213, 215, 230, 245, 255, 257],
 4: [400, 401, 402],
 5: [430]}

作为奖励，这甚至可以让您将运行分组为潜在的无限列表（当然，只要它们已排序）。您还可以将索引生成部分粘贴到生成器本身中（而不是使用enumerate）作为次要增强。

于 2013-04-04T01:48:35.077 回答
5 
import itertools
import numpy as np

numbers = np.array([123, 124, 128, 160, 167, 213, 215, 230, 245, 255, 257, 400, 401, 402, 430])
nd = [0] + list(np.where(np.diff(numbers) > 15)[0] + 1) + [len(numbers)]

a, b = itertools.tee(nd)
next(b, None)
res = {}
for j, (f, b) in enumerate(itertools.izip(a, b)):
    res[j] = numbers[f:b]

如果你可以使用 itertools 和 numpy. 适用pairwise于迭代器技巧。+1需要移动索引，将和0添加len(numbers)到列表中以确保正确包含第一个和最后一个条目。

你显然可以不用 out 来做到这一点itertools，但我喜欢tee。

于 2013-04-04T01:20:33.667 回答
3

您可以使用 numpy / pandas 在没有（显式）循环的情况下实现：

import pandas as pd    
import numpy as np

n = 15
numbers = [123, 124, 128, 160, 167, 213, 215, 230, 245, 255, 257, 400, 401, 402, 430]
nnumbers = np.array(numbers)
clusters = pd.DataFrame({
    'numbers': numbers,
    'segment': np.cumsum([0] + list(1*(nnumbers[1:] - nnumbers[0:-1] > n))) + 1
}).groupby('segment').agg({'numbers': set}).to_dict()['numbers']

诀窍是移动数字列表并将差异与您的阈值（15）进行比较，以找到段之间的“中断”。当然，第一个元素不会是中断。然后使用 cumsum 函数获取段并使用 set 函数进行分组（以防有重复项）。希望这对您有所帮助，即使自发布此问题以来已经过去了很多年。

于 2019-03-04T19:00:07.200 回答
2

使用生成器分离逻辑：（一个函数做一件事）

numbers = [123, 124, 128, 160, 167, 213, 215, 230, 245, 255, 257, 400, 401, 402, 430]

def cut_indices(numbers):
    # this function iterate over the indices that need to be 'cut'
    for i in xrange(len(numbers)-1):
        if numbers[i+1] - numbers[i] > 15:
            yield i+1

def splitter(numbers):
    # this function split the original list into sublists.
    px = 0
    for x in cut_indices(numbers):
        yield numbers[px:x]
        px = x
    yield numbers[px:]

def cluster(numbers):
    # using the above result, to form a dict object.
    cluster_ids = xrange(1,len(numbers))
    return dict(zip(cluster_ids, splitter(numbers)))

print cluster(numbers)

上面的代码给了我

{1: [123, 124, 128], 2: [160, 167], 3: [213, 215, 230, 245, 255, 257], 4: [400, 401, 402], 5: [430]}
于 2013-04-04T01:58:09.523 回答
1

这是一个适用于列表或生成器的相对简单的解决方案。它会懒惰地产生对(group_number, element)，因此如果需要，您必须单独进行实际分组。（或者也许你只需要组号。）

 from itertools import tee

 def group(xs, gap=15):
    # use `tee` to get two efficient iterators
    xs1, xs2 = tee(xs)

    # the first element is in group 0, also advance the second iterator
    group = 0
    yield (group, next(xs2))

    # after advancing xs2, this zip is pairs of consecutive elements
    for x, y in zip(xs1, xs2):
        # whenever the gap is too large, increment the group number
        if y - x > gap:
            group += 1
        # and yield the second number in the pair
        yield group, y
于 2016-04-01T23:20:07.400 回答