формат pythonic для индексов

Для этого вам не нужна строка. Это настолько просто, насколько это возможно:

from types import SliceType

class sequence(object):
    def __getitem__(self, item):
        for a in item:
            if isinstance(a, SliceType):
                i = a.start
                step = a.step if a.step else 1
                while True:
                    if a.stop and i > a.stop:
                        break
                    yield i
                    i += step
            else:
                yield a

print list(sequence()[1:3,6,8:10,16])

Вывод:

[1, 2, 3, 6, 8, 9, 10, 16]

Я использую мощность среза Python для выражения диапазонов последовательностей . Я также использую генераторы для экономии памяти.

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

Он поддерживает шаги:

>>> list(sequence()[1:3,6,8:20:2])
[1, 2, 3, 6, 8, 10, 12, 14, 16, 18, 20]

И бесконечные последовательности:

sequence()[1:3,6,8:]
1, 2, 3, 6, 8, 9, 10, ...

Если вам нужно дать ему строку, вы можете комбинировать @ilya n. парсер с этим решением. Продлю @ilya n. синтаксический анализатор для поддержки индексов, а также диапазонов:

def parser(input):
    ranges = [a.split('-') for a in input.split(',')]
    return [slice(*map(int, a)) if len(a) > 1 else int(a[0]) for a in ranges]

Теперь вы можете использовать его так:

>>> print list(sequence()[parser('1-3,6,8-10,16')])
[1, 2, 3, 6, 8, 9, 10, 16]

import sys

class Sequencer(object):
    def __getitem__(self, items):
        if not isinstance(items, (tuple, list)):
            items = [items]
        for item in items:
            if isinstance(item, slice):
                for i in xrange(*item.indices(sys.maxint)):
                    yield i
            else:
                yield item


>>> s = Sequencer()
>>> print list(s[1:3,6,8:10,16])
[1, 2, 6, 8, 9, 16]

Обратите внимание, что я использую встроенную функцию xrange для генерации последовательности. Поначалу это кажется неудобным, потому что по умолчанию не включается верхнее количество последовательностей, однако это оказывается очень удобным. Вы можете делать что-то вроде:

>>> print list(s[1:10:3,5,5,16,13:5:-1])
[1, 4, 7, 5, 5, 16, 13, 12, 11, 10, 9, 8, 7, 6]

Это означает, что вы можете использовать step часть xrange .

Это, вероятно, примерно так же лениво, как это возможно, то есть это будет нормально даже для очень больших списков:

def makerange(s):
    for nums in s.split(","): # whole list comma-delimited
        range_ = nums.split("-") # number might have a dash - if not, no big deal
        start = int(range_[0])
        for i in xrange(start, start + 1 if len(range_) == 1 else int(range_[1]) + 1):
            yield i

s = "1-3,6,8-10,16"
print list(makerange(s))

output:

[1, 2, 3, 6, 8, 9, 10, 16]

Это выглядело как забавная головоломка, которую можно было бы добавить к кофе сегодня утром. Если вы остановитесь на заданном синтаксисе (который мне кажется нормальным, с некоторыми примечаниями в конце), вот конвертер pyparsing, который возьмет вашу входную строку и вернет список целых чисел:

from pyparsing import *

integer = Word(nums).setParseAction(lambda t : int(t[0]))
intrange = integer("start") + '-' + integer("end")
def validateRange(tokens):
    if tokens.from_ > tokens.to:
        raise Exception("invalid range, start must be <= end")
intrange.setParseAction(validateRange)
intrange.addParseAction(lambda t: list(range(t.start, t.end+1)))

indices = delimitedList(intrange | integer)

def mergeRanges(tokens):
    ret = set()
    for item in tokens:
        if isinstance(item,int):
            ret.add(item)
        else:
            ret += set(item)
    return sorted(ret)

indices.setParseAction(mergeRanges)

test = "1-3,6,8-10,16"
print indices.parseString(test)

Это также позаботится о любом перекрытии или повторяющиеся записи, такие как «3-8,4,6,3,4», и возвращает список только уникальных целых чисел.

Синтаксический анализатор заботится о проверке того, что диапазоны типа «10-3» не разрешены. Если вы действительно хотите разрешить это и получить что-то вроде «1,5-3,7», верните 1,5,4,3,7, тогда вы можете настроить действия синтаксического анализа intrange и mergeRanges, чтобы получить этот более простой результат (и вообще отказаться от действия синтаксического анализа validateRange).

Вы, скорее всего, получите пробелы в ваших выражениях, я предполагаю, что это несущественно. «1, 2, 3-6» будут обрабатываться так же, как «1,2,3-6». Pyparsing делает это по умолчанию, поэтому вы не видите специальной обработки пробелов в приведенном выше коде (но он есть ...)

Этот синтаксический анализатор не обрабатывает отрицательные индексы, но если это было необходимо, просто измените определение of integer to:

integer = Combine(Optional('-') + Word(nums)).setParseAction(lambda t : int(t[0]))

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

Python использует ':' в качестве разделителя диапазона, поэтому исходная строка могла выглядеть как «1: 3, 6,8: 10,16 ", а Паскаль использовал" .. "для диапазонов массива, давая" 1..3,6,8..10,