Определите группы непрерывных чисел в списке

«наивное» решение, которое я нахожу несколько читаемого по крайней мере.

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

Отредактируйте 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]

Вы можете заменить XRANGE с диапазоном или любым другим пользовательским классом.

Документы 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)

Выход:

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

Если вы хотите получить точный же выход, вы можете сделать это:

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 (перечисление (данные), лямбда (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
)

Функция лямбда вычитает индекс элемента из значения элемента. Поэтому, когда вы применяете лямбду на каждый предмет. Вы получите следующие ключи для Groupby:

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

элементы групп групповых групп путем равного значения ключевое значение, поэтому первые 4 элемента будут сгруппированы вместе и так далее.

Я надеюсь, что это делает его более читаемым.

Python 3 версия может быть полезна для начинающих

Импорт библиотеки требуется первым

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

, Принимающий ваш список, сортирован:

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

Это не использует стандартную функцию - он просто видел над входом, но он должен работать:

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)

Обратите внимание, что это требует, чтобы ввод содержит только положительные числа в порядке возрастания. Вы должны подтвердить вход, но этот код опущен для ясности.

Здесь это то, что должно работать, без какого-либо импорта не требуется:

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

Вот ответ, который я придумал. Я пишу код для понимания другими людьми, поэтому я достаточно многословен с именами переменных и комментариями.

Сначала быстрая вспомогательная функция:

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