Identifique grupos de números contínuos em uma lista

Eu gostaria de identificar grupos de números contínuos em uma lista, para que:

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

Retorna:

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

E queria saber qual era a melhor maneira de fazer isso (principalmente se houver algo embutido no Python).

Edit: Nota Eu originalmente esqueci de mencionar que os números individuais devem ser retornados como números individuais, não intervalos.

more_itertools.consecutive_groups foi adicionado na versão 4.0.

Demo

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

Código

Aplicando esta ferramenta, criamos uma função geradora que encontra intervalos de números consecutivos.

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]

A implementação de origem emula uma receita clássica (conforme demonstrado por @Nadia Alramli).

Nota: more_itertoolsé um pacote de terceiros instalável via pip install more_itertools.

EDIT 2: Para responder ao novo requisito do 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])

Resultado:

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

Você pode substituir xrange por intervalo ou qualquer outra classe personalizada.

Os documentos Python têm uma receita muito legal para isso:

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)

Resultado:

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

Se você deseja obter exatamente a mesma saída, pode fazer o seguinte:

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

resultado:

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

EDITAR: O exemplo já está explicado na documentação, mas talvez eu deva explicá-lo mais:

A chave para a solução é diferenciar com um intervalo de forma que todos os números consecutivos apareçam no mesmo grupo.

Se os dados eram: [2, 3, 4, 5, 12, 13, 14, 15, 16, 17] Então groupby(enumerate(data), lambda (i,x):i-x)é equivalente ao seguinte:

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
)

A função lambda subtrai o índice do elemento do valor do elemento. Então, quando você aplica o lambda em cada item. Você obterá as seguintes chaves para groupby:

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

groupby agrupa elementos por um valor-chave igual, portanto, os primeiros 4 elementos serão agrupados e assim por diante.

Espero que isso o torne mais legível.

python 3 versão pode ser útil para iniciantes

importe as bibliotecas necessárias primeiro

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

A solução "ingênua" que acho pelo menos um pouco legível.

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

Supondo que sua lista esteja classificada:

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

Aqui está algo que deve funcionar, sem nenhuma importação necessária:

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

Observe que o código usando groupbynão funciona como fornecido no Python 3, então use isso.

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

Isso não usa uma função padrão - apenas repete a entrada, mas deve funcionar:

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)

Observe que isso requer que a entrada contenha apenas números positivos em ordem crescente. Você deve validar a entrada, mas este código foi omitido para maior clareza.

Aqui está a resposta que encontrei. Estou escrevendo o código para que outras pessoas entendam, por isso sou bastante prolixo com nomes de variáveis ​​e comentários.

Primeiro, uma função auxiliar rápida:

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] 

E então o código real:

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

Exemplo de execução:

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

retorna:

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

import numpy as np

myarray = [2, 3, 4, 5, 12, 13, 14, 15, 16, 17, 20]
sequences = np.split(myarray, np.array(np.where(np.diff(myarray) > 1)[0]) + 1)
l = []
for s in sequences:
    if len(s) > 1:
        l.append((np.min(s), np.max(s)))
    else:
        l.append(s[0])
print(l)

Resultado:

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

Usar groupbye countde itertoolsnos dá uma solução curta. A ideia é que, em sequência crescente, a diferença entre o índice e o valor permaneça a mesma.

Para acompanhar o índice, podemos usar um itertools.count , o que torna o código mais limpo, pois usa enumerate:

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

Alguns exemplos de saída:

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

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

Usando numpy + listas de compreensão:
Com a função numpy diff, entradas de vetor de entrada consequentes cuja diferença não é igual a um podem ser identificadas. O início e o fim do vetor de entrada precisam ser considerados.

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

Resultado:

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

Observação: a solicitação de que números individuais sejam tratados de maneira diferente (retornados como individuais, não como intervalos) foi omitida. Isso pode ser obtido por meio do pós-processamento dos resultados. Normalmente, isso tornará as coisas mais complexas sem obter nenhum benefício.

Uma solução curta que funciona sem importações adicionais. Ele aceita qualquer iterável, classifica entradas não classificadas e remove itens duplicados:

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

Exemplo:

>>> ranges([2, 3, 4, 7, 8, 9, 15])
[(2, 4), (7, 9), (15, 15)]

>>> ranges([-1, 0, 1, 2, 3, 12, 13, 15, 100])
[(-1, 3), (12, 13), (15, 15), (100, 100)]

>>> ranges(range(100))
[(0, 99)]

>>> ranges([0])
[(0, 0)]

>>> ranges([])
[]

Esta é a mesma solução de @dansalmo que eu achei incrível, embora um pouco difícil de ler e aplicar (já que não é fornecida como uma função).

Observe que ele pode ser facilmente modificado para cuspir intervalos abertos "tradicionais" [start, end), por exemplo, alterando a instrução de retorno:

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

Copiei esta resposta de outra pergunta que foi marcada como uma duplicata desta com a intenção de torná-la mais fácil de encontrar (depois de agora pesquisar novamente por este tópico, encontrando apenas a pergunta aqui no início e não ficando satisfeito com as respostas dado).

As versões de Mark Byers , Andrea Ambu , SilentGhost , Nadia Alramli e truppo são simples e rápidas. A versão 'truppo' me encorajou a escrever uma versão que retém o mesmo comportamento ágil enquanto lida com tamanhos de passo diferentes de 1 (e lista como elementos singletons que não estendem mais de 1 passo com um determinado tamanho de passo). É dado aqui .

>>> list(ranges([1,2,3,4,3,2,1,3,5,7,11,1,2,3]))
[(1, 4, 1), (3, 1, -1), (3, 7, 2), 11, (1, 3, 1)]