Pythonic способ преобразовать список целых чисел в строку разделенных от запятой диапазонов

Для конкатенации строк следует использовать ','.join. Это устраняет второй цикл.

def createRangeString(zones):
        rangeIdx = 0
        ranges   = [[zones[0], zones[0]]]
        for zone in list(zones):
            if ranges[rangeIdx][1] in (zone, zone-1):
                ranges[rangeIdx][1] = zone
            else:
                ranges.append([zone, zone])
                rangeIdx += 1

       return ','.join(
                map(
                  lambda p: '%s-%s'%tuple(p) if p[0] != p[1] else str(p[0]),
                  ranges
                )
              )

Хотя я предпочитаю более общий подход:

from itertools import groupby

# auxiliary functor to allow groupby to compare by adjacent elements.
class cmp_to_groupby_key(object):
  def __init__(self, f):
    self.f = f
    self.uninitialized = True
  def __call__(self, newv):
    if self.uninitialized or not self.f(self.oldv, newv):
      self.curkey = newv
      self.uninitialized = False
    self.oldv = newv
    return self.curkey

# returns the first and last element of an iterable with O(1) memory.
def first_and_last(iterable):
  first = next(iterable)
  last = first
  for i in iterable:
    last = i
  return (first, last)

# convert groups into list of range strings
def create_range_string_from_groups(groups):
  for _, g in groups:
    first, last = first_and_last(g)
    if first != last:
      yield "{0}-{1}".format(first, last)
    else:
      yield str(first)

def create_range_string(zones):
  groups = groupby(zones, cmp_to_groupby_key(lambda a,b: b-a<=1))
  return ','.join(create_range_string_from_groups(groups))

assert create_range_string([0,1,2,3]) == '0-3'
assert create_range_string([0, 1, 2, 4, 8]) == '0-2,4,8'
assert create_range_string([1,2,3,4,6,7,8,9,12,13,19,20,22,22,22,23,40,44]) == '1-4,6-9,12-13,19-20,22-23,40,44'

def createRangeString(zones):
    """Create a string with integer ranges in the format of '%d-%d'
    >>> createRangeString([0, 1, 2, 4, 8])
    "0-2,4,8"
    >>> createRangeString([1,2,3,4,6,7,8,9,12,13,19,20,22,22,22,23,40,44])
    "1-4,6-9,12-13,19-20,22-23,40,44"
    """
    buffer = []

    try:
        st = ed = zones[0]
        for i in zones[1:]:
            delta = i - ed
            if delta == 1: ed = i
            elif not (delta == 0):
                buffer.append((st, ed))
                st = ed = i
        else: buffer.append((st, ed))
    except IndexError:
        pass

    return ','.join(
            "%d" % st if st==ed else "%d-%d" % (st, ed)
            for st, ed in buffer)

Является ли это питоническим, остается предметом споров. Но очень компактный. Настоящее мясо находится в функции Rangify () . Если вам нужна эффективность или питонизм, есть еще кое-что для улучшения.

def CreateRangeString(zones):
    #assuming sorted and distinct
    deltas = [a-b for a, b in zip(zones[1:], zones[:-1])]
    deltas.append(-1)
    def Rangify((b, p), (z, d)):
        if p is not None:
            if d == 1: return (b, p)
            b.append('%d-%d'%(p,z))
            return (b, None)
        else:
            if d == 1: return (b, z)
            b.append(str(z))
            return (b, None)
    return ','.join(reduce(Rangify, zip(zones, deltas), ([], None))[0])

Для описания параметров:

• дельты - это расстояние до следующего значения (на основе ответа здесь, на SO)
• Rangify () уменьшает эти параметры
  • b - база или аккумулятор
  • p - предыдущий начальный диапазон
  • z - номер зоны
  • d - дельта

Это более подробный текст, главным образом потому, что я использовал общие функции, которые у меня есть, и которые являются незначительными вариациями функций и рецептов itertools:

from itertools import tee, izip_longest
def pairwise_longest(iterable):
    "variation of pairwise in http://docs.python.org/library/itertools.html#recipes"
    a, b = tee(iterable)
    next(b, None)
    return izip_longest(a, b)

def takeuntil(predicate, iterable):
    """returns all elements before and including the one for which the predicate is true
    variation of http://docs.python.org/library/itertools.html#itertools.takewhile"""
    for x in iterable:
        yield x
        if predicate(x):
            break

def get_range(it):
    "gets a range from a pairwise iterator"
    rng = list(takeuntil(lambda (a,b): (b is None) or (b-a>1), it))
    if rng:
        b, e = rng[0][0], rng[-1][0]
        return "%d-%d" % (b,e) if b != e else "%d" % b

def create_ranges(zones):
    it = pairwise_longest(zones)
    return ",".join(iter(lambda:get_range(it),None))

k=[0,1,2,4,5,7,9,12,13,14,15]
print create_ranges(k) #0-2,4-5,7,9,12-15

Вот мое решение. Вам нужно отслеживать различные фрагменты информации, пока вы просматриваете список и создаете результат - для меня этот генератор криков. Итак, начнем:

def rangeStr(start, end):
    '''convert two integers into a range start-end, or a single value if they are the same''' 
    return str(start) if start == end else "%s-%s" %(start, end)

def makeRange(seq):
    '''take a sequence of ints and return a sequence
    of strings with the ranges
    '''
    # make sure that seq is an iterator
    seq = iter(seq)
    start = seq.next()
    current = start
    for val in seq:
        current += 1
        if val != current:
            yield rangeStr(start, current-1)
            start = current = val
    # make sure the last range is included in the output
    yield rangeStr(start, current)

def stringifyRanges(seq):
    return ','.join(makeRange(seq))

>>> l = [1,2,3, 7,8,9, 11, 20,21,22,23]
>>> l2 = [1,2,3, 7,8,9, 11, 20,21,22,23, 30]
>>> stringifyRanges(l)
'1-3,7-9,11,20-23'
>>> stringifyRanges(l2)
'1-3,7-9,11,20-23,30'

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

>>> stringifyRanges( [] )
''

makeRanges будет работать с любым итератором, который возвращает целые числа и лениво возвращает последовательность строк, поэтому может использоваться с бесконечными последовательностями.

править: Я обновил код, чтобы обрабатывать отдельные числа, не входящие в диапазон.

edit2: изменен диапазон rangeStr для удаления дублирования.