Я хотів би визначити групи безперервних чисел у списку, щоб:
myfunc([2, 3, 4, 5, 12, 13, 14, 15, 16, 17, 20])
Повернення:
[(2,5), (12,17), 20]
І цікавився, який найкращий спосіб це зробити (особливо якщо в Python є щось вбудоване).
Редагувати: Примітка. Я спочатку забув згадати, що окремі номери слід повертати як окремі номери, а не як діапазони.
Відповіді:
more_itertools.consecutive_groups було додано у версії 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_itertoolsце сторонній пакет, який можна встановити через pip install more_itertools.
EDIT 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)]
EDIT: Приклад вже пояснено в документації, але, можливо, мені слід пояснити його більше:
Ключ до рішення - це розходження з діапазоном, так що послідовні числа відображаються в одній групі.
Якщо дані були: [2, 3, 4, 5, 12, 13, 14, 15, 16, 17]
Тоді groupby(enumerate(data), 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
)
Лямбда-функція віднімає індекс елемента від значення елемента. Отже, коли ви застосовуєте лямбду до кожного елемента. Ви отримаєте такі ключі для groupby:
[-2, -2, -2, -2, -8, -8, -8, -8, -8, -8]
groupby групує елементи за однаковим значенням ключа, тому перші 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]))
lambda x:x[0]-x[1].
[2,3,4,5] == xrange(2,6), ні xrange(2,5). Можливо, варто визначити новий тип даних про всеосяжний діапазон.
for key, group in groupby(enumerate(data), lambda i: i[0] - i[1]): group = list(map(itemgetter(1), group))
"Наївне" рішення, яке я вважаю дещо читабельним принаймні.
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)]
print([i if i[0] != i[1] else i[0] for i in group(x)])
Припускаючи, що ваш список відсортовано:
>>> 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)]
[j - i for i, j in enumerate(lst)]розумний :-)
Ось щось, що повинно працювати, без необхідності імпорту:
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не працює, як зазначено в Python 3, тому використовуйте це.
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]))
Тут не використовується стандартна функція - вона просто перебирає введені дані, але вона повинна працювати:
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 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]]
>>> getranges([2, 12, 13])Виходи: [[12, 13]]. Це було навмисно?
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)
Вихід:
[(2, 5), (12, 17), 20]
Використання groupbyта countвід itertoolsнадає нам коротке рішення. Ідея полягає в тому, що у зростаючій послідовності різниця між індексом та значенням залишатиметься незмінною.
Для того, щоб відстежувати індекс, ми можемо використовувати itertools.count , який робить код чистішим, використовуючи 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
Деякі зразки виводу:
print(intervals([0, 1, 3, 4, 6]))
# [[0, 1], [3, 4], [6, 6]]
print(intervals([2, 3, 4, 5]))
# [[2, 5]]
Використання списків розуміння numpy +: за
допомогою функції numpy diff можна ідентифікувати послідовні вхідні векторні записи про те, що їх різниця не дорівнює одиниці. Потрібно враховувати початок і кінець вхідного вектора.
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])
Вихід:
[[ 2 5]
[12 17]
[20 20]]
Примітка: Вимога про те, що до окремих номерів слід поводитися по-різному (повертаються як індивідуальні, а не діапазони), була пропущена. Цього можна досягти шляхом подальшої подальшої обробки результатів. Зазвичай це робить речі більш складними, не отримуючи ніякої вигоди.
Коротке рішення, яке працює без додаткового імпорту. Він приймає будь-який ітерабель, сортує несортовані вводи та видаляє повторювані елементи:
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))
Приклад:
>>> 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([])
[]
Це те саме, що рішення @ dansalmo, яке мені здалося дивовижним, хоча і трохи важким для читання та застосування (оскільки воно не подається як функція).
Зверніть увагу, що його можна легко модифікувати, щоб виплюнути "традиційні" відкриті діапазони [start, end), наприклад, змінивши оператор return:
return [(s, e+1) for s, e in zip(edges, edges)]
Я скопіював цю відповідь з іншого запитання , позначеного як дублікат цього, з метою полегшити пошук (після того, як я щойно знову шукав цю тему, спочатку знайшов тут лише питання і не був задоволений відповідями дано).
Версії від Mark Byers , Andrea Ambu , SilentGhost , Nadia Alramli та truppo прості та швидкі. Версія "truppo" спонукала мене написати версію, яка зберігає таку ж спритну поведінку під час обробки розмірів кроків, відмінних від 1 (і перераховує як одиничні елементи, що не розширюються більше ніж на 1 крок із заданим розміром кроку). Це подано тут .
>>> 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)]