Python 识别列表中的连续数字组

我想确定列表中连续数字的组，以便：

myfunc([2, 3, 4, 5, 12, 13, 14, 15, 16, 17, 20])

返回：

[(2,5), (12,17), 20]

我想知道做这件事最好的方法是什么（特别是如果Python中内置了一些东西的话）

---

编辑：注意，我最初忘了提到单个数字应该作为单个数字返回，而不是作为范围返回。

这并没有使用标准函数-它只是对输入进行编辑，但它应该可以工作：

def myfunc(l):
    r = []
    p = q = None
    for x in l + [-1]:
        if x - 1 == q:
            q += 1
        else:
            if p:
               if q > p:
                   r.append('%s-%s' % (p, q))
               else:
                   r.append(str(p))
            p = q = x
    return '(%s)' % ', '.join(r)

---

注意，它要求输入只包含升序的正数。您应该验证输入，但为了清晰起见，此代码被省略。

假设您的列表已排序：

>>> from itertools import groupby
>>> def ranges(lst):
    pos = (j - i for i, j in enumerate(lst))
    t = 0
    for i, els in groupby(pos):
        l = len(list(els))
        el = lst[t]
        t += l
        yield range(el, el+l)


>>> lst = [2, 3, 4, 5, 12, 13, 14, 15, 16, 17]
>>> list(ranges(lst))
[range(2, 6), range(12, 18)]

---

编辑2：回答OP新要求

ranges = []
for key, group in groupby(enumerate(data), lambda (index, item): index - item):
    group = map(itemgetter(1), group)
    if len(group) > 1:
        ranges.append(xrange(group[0], group[-1]))
    else:
        ranges.append(group[0])

输出：

[xrange(2, 5), xrange(12, 17), 20]

[2, 3, 4, 5]
[12, 13, 14, 15, 16, 17]

[(2, 5), (12, 17), 20]

 [[ 2  5]   
  [12 17]   
  [20 20]]

[(2, 5), (12, 17), 20]

您可以将xrange替换为range或任何其他自定义类

---

Python文档对此有一个非常简洁的定义：

from operator import itemgetter
from itertools import groupby
data = [2, 3, 4, 5, 12, 13, 14, 15, 16, 17]
for k, g in groupby(enumerate(data), lambda (i,x):i-x):
    print map(itemgetter(1), g)

输出：

[xrange(2, 5), xrange(12, 17), 20]

[2, 3, 4, 5]
[12, 13, 14, 15, 16, 17]

[(2, 5), (12, 17), 20]

 [[ 2  5]   
  [12 17]   
  [20 20]]

[(2, 5), (12, 17), 20]

如果要获得完全相同的输出，可以执行以下操作：

ranges = []
for k, g in groupby(enumerate(data), lambda (i,x):i-x):
    group = map(itemgetter(1), g)
    ranges.append((group[0], group[-1]))

输出：

[(2, 5), (12, 17)]

---

编辑：文档中已经解释了该示例，但也许我应该进一步解释：

解决方案的关键是 用一个范围进行差分，以便 连续的数字都以相同的格式出现 小组

如果数据是：

[2,3,4,5,12,13,14,15,16,17]

然后，

groupby（枚举（数据），lambda（i，x）：i-x）

等价于以下各项：

groupby(
    [(0, 2), (1, 3), (2, 4), (3, 5), (4, 12),
    (5, 13), (6, 14), (7, 15), (8, 16), (9, 17)],
    lambda (i,x):i-x
)

lambda函数从元素值中减去元素索引。因此，当您在每个项目上应用lambda时。您将获得groupby的以下键：

[-2, -2, -2, -2, -8, -8, -8, -8, -8, -8]

groupby按相等的键值对元素进行分组，因此前4个元素将分组在一起，以此类推

我希望这能让它更具可读性

python3

版本可能对初学者有所帮助

首先导入所需的库

from itertools import groupby
from operator import itemgetter

ranges =[]

for k,g in groupby(enumerate(data),lambda x:x[0]-x[1]):
    group = (map(itemgetter(1),g))
    group = list(map(int,group))
    ranges.append((group[0],group[-1]))

“天真”的解决方案，我觉得至少有点可读性

x = [2, 3, 4, 5, 12, 13, 14, 15, 16, 17, 22, 25, 26, 28, 51, 52, 57]

def group(L):
    first = last = L[0]
    for n in L[1:]:
        if n - 1 == last: # Part of the group, bump the end
            last = n
        else: # Not part of the group, yield current group and start a new
            yield first, last
            first = last = n
    yield first, last # Yield the last group


>>>print list(group(x))
[(2, 5), (12, 17), (22, 22), (25, 26), (28, 28), (51, 52), (57, 57)]

---

这是我想出的答案。我写的代码是为了让其他人理解，所以我对变量名和注释非常详细

首先是快速助手功能：

def getpreviousitem(mylist,myitem):
    '''Given a list and an item, return previous item in list'''
    for position, item in enumerate(mylist):
        if item == myitem:
            # First item has no previous item
            if position == 0:
                return None
            # Return previous item    
            return mylist[position-1] 

然后是实际代码：

def getranges(cpulist):
    '''Given a sorted list of numbers, return a list of ranges'''
    rangelist = []
    inrange = False
    for item in cpulist:
        previousitem = getpreviousitem(cpulist,item)
        if previousitem == item - 1:
            # We're in a range
            if inrange == True:
                # It's an existing range - change the end to the current item
                newrange[1] = item
            else:    
                # We've found a new range.
                newrange = [item-1,item]
            # Update to show we are now in a range    
            inrange = True    
        else:   
            # We were in a range but now it just ended
            if inrange == True:
                # Save the old range
                rangelist.append(newrange)
            # Update to show we're no longer in a range    
            inrange = False 
    # Add the final range found to our list
    if inrange == True:
        rangelist.append(newrange)
    return rangelist

运行示例：

getranges([2, 3, 4, 5, 12, 13, 14, 15, 16, 17])

返回：

[[2, 5], [12, 17]]

---

在这里，它应该可以工作，而不需要任何导入：

def myfunc(lst):
    ret = []
    a = b = lst[0]                           # a and b are range's bounds

    for el in lst[1:]:
        if el == b+1: 
            b = el                           # range grows
        else:                                # range ended
            ret.append(a if a==b else (a,b)) # is a single or a range?
            a = b = el                       # let's start again with a single
    ret.append(a if a==b else (a,b))         # corner case for last single/range
    return ret

---

请注意，使用

groupby

的代码与Python3中给出的代码不一样，因此请使用此代码

for k, g in groupby(enumerate(data), lambda x:x[0]-x[1]):
    group = list(map(itemgetter(1), g))
    ranges.append((group[0], group[-1]))

输出：

[xrange(2, 5), xrange(12, 17), 20]

[2, 3, 4, 5]
[12, 13, 14, 15, 16, 17]

[(2, 5), (12, 17), 20]

 [[ 2  5]   
  [12 17]   
  [20 20]]

[(2, 5), (12, 17), 20]

已在版本4.0中添加

演示

import more_itertools as mit


iterable = [2, 3, 4, 5, 12, 13, 14, 15, 16, 17, 20]
[list(group) for group in mit.consecutive_groups(iterable)]
# [[2, 3, 4, 5], [12, 13, 14, 15, 16, 17], [20]]

代码

应用这个工具，我们制作了一个生成器函数，用于查找连续数字的范围

def find_ranges(iterable):
    """Yield range of consecutive numbers."""
    for group in mit.consecutive_groups(iterable):
        group = list(group)
        if len(group) == 1:
            yield group[0]
        else:
            yield group[0], group[-1]


iterable = [2, 3, 4, 5, 12, 13, 14, 15, 16, 17, 20]
list(find_ranges(iterable))
# [(2, 5), (12, 17), 20]

该实现模拟了一个实例（如@Nadia Alramli所示）

---

注意：

more\u itertools

是一个第三方软件包，可通过使用numpy+理解列表安装：
使用numpy diff函数，可以识别其差值不等于1的后续输入向量项。需要考虑输入向量的开始和结束

import numpy as np
data = np.array([2, 3, 4, 5, 12, 13, 14, 15, 16, 17, 20])

d = [i for i, df in enumerate(np.diff(data)) if df!= 1] 
d = np.hstack([-1, d, len(data)-1])  # add first and last elements 
d = np.vstack([d[:-1]+1, d[1:]]).T

print(data[d])

输出：

[xrange(2, 5), xrange(12, 17), 20]

[2, 3, 4, 5]
[12, 13, 14, 15, 16, 17]

[(2, 5), (12, 17), 20]

 [[ 2  5]   
  [12 17]   
  [20 20]]

[(2, 5), (12, 17), 20]

---

注：省略了个别数字应以不同方式处理的请求（作为个别而不是范围返回）。这可以通过对结果进行进一步的后处理来实现。通常这会使事情变得更复杂，而不会带来任何好处

一个简短的解决方案，无需额外导入即可工作。它接受任何iterable，对未排序的输入进行排序，并删除重复项：

def ranges(nums):
    nums = sorted(set(nums))
    gaps = [[s, e] for s, e in zip(nums, nums[1:]) if s+1 < e]
    edges = iter(nums[:1] + sum(gaps, []) + nums[-1:])
    return list(zip(edges, edges))

这与@dansalmo的相同，我发现它令人惊讶，尽管有点难以阅读和应用（因为它不是作为函数给出的）

请注意，它可以很容易地修改为吐出“传统”的开放范围

[开始，结束）

，例如通过更改return语句：

    return [(s, e+1) for s, e in zip(edges, edges)]

---

我将这个答案复制过来，并将其标记为这个答案的副本，目的是使其更易于查找（在我刚刚再次搜索这个主题后，最初只在这里找到问题，并且对给出的答案不满意）.

使用

itertools

中的

groupby

和

count

为我们提供了一个简短的解决方案。其思想是，在递增顺序中，索引和值之间的差异将保持不变

为了跟踪索引，我们可以使用，这使得代码更干净，就像使用

枚举

：

from itertools import groupby, count

def intervals(data):
    out = []
    counter = count()

    for key, group in groupby(data, key = lambda x: x-next(counter)):
        block = list(group)
        out.append([block[0], block[-1]])
    return out

一些示例输出：

print(intervals([0, 1, 3, 4, 6]))
# [[0, 1], [3, 4], [6, 6]]

print(intervals([2, 3, 4, 5]))
# [[2, 5]]

由、、和编写的版本简单而快速。“truppo”版本鼓励我编写一个版本，该版本在处理除1以外的步长时保留相同的灵活行为（并列出为单例元素，在给定步长下扩展不超过1个步长）。它是给定的

---

不是最好的方法，但这是我的2美分

def getConsecutiveValues2(arr): 
    x = ""
    final = []
    end = 0
    start = 0
    for i in range(1,len(arr)) :
        if arr[i] - arr[i-1] == 1 :
            end = i
        else :
            print(start,end)
            final.append(arr[start:end+1])
            start = i
        if i == len(arr) - 1 :
            final.append(arr[start:end+1])
    return final

x = [1,2,3,5,6,8,9,10,11,12]
print(getConsecutiveValues2(x))

>> [[1, 2, 3], [5, 6], [8, 9, 10, 11]]

---

我认为这种方式比我在这里看到的任何答案都简单（编辑：根据Pleastry的评论修复）：

输出：

[xrange(2, 5), xrange(12, 17), 20]

[2, 3, 4, 5]
[12, 13, 14, 15, 16, 17]

[(2, 5), (12, 17), 20]

 [[ 2  5]   
  [12 17]   
  [20 20]]

[(2, 5), (12, 17), 20]

---

此实现适用于常规或非常规步骤

我需要实现同样的目标，但步骤可能不规则，这是我的实现

def ranges(l):
    if not len(l):
        return range(0,0)
    elif len(l)==1:
        return range(l[0],l[0]+1)
    # get steps
    sl    = sorted(l)
    steps = [i-j for i,j in zip(sl[1:],sl[:-1])]
    # get unique steps indexes range
    groups = [[0,0,steps[0]],]
    for i,s in enumerate(steps):
        if s==groups[-1][-1]:
            groups[-1][1] = i+1
        else:
            groups.append( [i+1,i+1,s] )
            g2 = groups[-2]
            if g2[0]==g2[1]:
                if sl[i+1]-sl[i]==s:
                    _=groups.pop(-2)
                    groups[-1][0] = i
    # create list of ranges 
    return [range(sl[i],sl[j]+s,s) if s!=0 else [sl[i]]*(j+1-i) for i,j,s in groups]

这里有一个例子

from timeit import timeit

# for regular ranges
l = list(range(1000000))
ranges(l)
>>> [range(0, 1000000)]
l = list(range(10)) + list(range(20,25)) + [1,2,3]
ranges(l)
>>> [range(0, 2), range(1, 3), range(2, 4), range(3, 10), range(20, 25)]
sorted(l);[list(i) for i in ranges(l)]
>>> [0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 20, 21, 22, 23, 24]
>>> [[0, 1], [1, 2], [2, 3], [3, 4, 5, 6, 7, 8, 9], [20, 21, 22, 23, 24]]

# for irregular steps list
l = [1, 3, 5, 7, 10, 11, 12, 100, 200, 300, 400, 60, 99, 4000,4001]
ranges(l)
>>> [range(1, 9, 2), range(10, 13), range(60, 138, 39), range(100, 500, 100), range(4000, 4002)]

## Speed test
timeit("ranges(l)","from __main__ import ranges,l", number=1000)/1000
>>> 9.303160999934334e-06

---

返回值是一个字符串吗？理想情况下，我们更喜欢对范围和独立数字使用单独的类型。

[j-i for i，j in enumerate（lst）]

很聪明：-）几乎可以在py3k中工作，除了它需要

lambda x:x[0]-x[1]

。您能使用多字符变量名吗？对于不熟悉map（）的人或groupby（），k g、i和x的含义不清楚。这是从具有相同变量名的Python文档中复制的。我现在更改了名称。您需要增加xrange/range中的第二个数字，因为它是非包容性的。换句话说，

[2,3,4,5]==xrange（2,6）

，而不是

xrange（2,5）

。定义一个新的包含范围数据类型可能是值得的。Python 3在第一个示例中抛出了一个语法错误。下面是为使用Python 3而更新的前两行：

对于key，groupby中的group（enumerate（data），lambda i:i[0]-i[1]）：group=list（map（itemgetter（1），group））

我非常喜欢这个答案，因为它很简洁