[python] Можно ли у исключения получить объект, который его создал?

Ты прав, подход кривой. Не надо проверять наличие элементов ловлей эксепшенов :)

Это же python-way, разве не так?

Поясни? Эксепшен не должен использоваться в штатных ситуациях. Исключений для этого правила я не знаю.

ТС: озвучь плиз задачу и мы ее попробуем решить.

> Эксепшен не должен использоваться в штатных ситуациях. Исключений для этого правила я не знаю.

StopIteration.

Но ТС хочет странного, это факт.

Я знаю про StopIteration. И? Нужно его использовать во все поля?

python-way — использовать исключения для прерывания цикла? o_O

>Поясни?

http://docs.python.org/glossary.html#term-eafp

> Я знаю про StopIteration. И?

Ты просил исключение из правила - я его тебе привел. Что не так?

Нужно его использовать во все поля?

Не понимаю, почему ты задаешь этот вопрос мне. Для протокола: нет, StopIteration не надо использовать во всех полях.

Да пошли они в ...

> http://docs.python.org/glossary.html#term-eafp

Идиотизм.

Что мешает оборачивать каждый .next() в try/except?

Можно, но получается куча кода и сложно добавлять итераторы.

Есть куча итераторов (пока два, но интересно вообще общий путь). Они потенциально очень большие. Этот цикл - часть генератора. Получается есть генератор, в который передаются итераторы, а генератор возвращает элементы из разных итераторов на основании условия (у меня просто сравнение <=).

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

Впрочем, у меня есть подозрение, что вообще не туда иду.

Есть несколько методов. Можно через задницу:

i=j=k=None #лучше не использовать None т.к. итератор тогда не сможет его возвращать
iter=(x for x in range(2))
try:
    i = iter.next() 
    j = iter.next()
    k = iter.next()
except StopIteration as e:
    if i is None: print "i"
    elif j is None: print "j"
    else: print "k"

Способ 2: наверняка можно посмотреть в стэке, но это уже совсем некрасиво.

Но лучше переделать код.

ещё одна альтернатива: нужно занумеровать все итераторы и запоминать у какого из них вызывается next(). Что-то типа такой обёртки

class wrap(object):
    def __init__(s):
        s.__iters = []
        s.__cur = 0

    def add(s, it):
        s.__iters.append(it)

    def __iter__(s): return s

    def last(s): return s.__iters[s.__cur]

    def next(s):
        r = s.__iters[s.__cur].next()

        s.__cur = (s.__cur + 1) % len(s.__iters)

        return r 

Цикл по списку итераторов?

Такое сойдет?

def merge(*iterables):

    def safe_next(it):
        try:
            return it.next()
        except StopIteration:
            return None

    def head_tail(it):
        return (safe_next(it), it)

    iterators = map(iter, iterables)
    head_tails = map(head_tail, iterators)

    while True:
        head_tails = filter(lambda ht: ht[0], head_tails)
        if len(head_tails) == 0:
            break
        head_tails = sorted(head_tails, key=lambda ht: ht[0])
        yield head_tails[0][0]
        head_tails[0] = head_tail(head_tails[0][1])


print [x for x in merge([1,2,3], [4,5,15], [2,6,10,12])]

Есть куча итераторов (пока два, но интересно вообще общий путь). Они потенциально очень большие. Этот цикл - часть генератора. Получается есть генератор, в который передаются итераторы, а генератор возвращает элементы из разных итераторов на основании условия (у меня просто сравнение <=).

Очень большие это насколько большие? И что за элементы? Если в память суммарно все влезает и элементы простые (числа, строки) то ИМНО гораздо быстрее будет слить несколько списков в один и отсортировать.

Если элементы (алгоритм сравнения) сложный и хочется все ручками чесать... заводим список пар (последнее возвращенное значение,итератор), на каждой итерации сортируем список, берем значение из первой пары, у итератора try-except берем след значение и пару суем назад в список. Если был эксепшн - не суем (море кончилось). Крутим пока список пар не пуст, как пуст выкидываем эксешепн

class myiterator :
   def __init__( self, *L ) : self.L = [ (i.next(),i) for i in L if i ]
   def next( self ) : 
      self.L.sort()
      r, i = self.L.pop(0)
      try: self.L.append(( i.next(), i ))
      except StopIteration, e : pass
      return r

как то так на самом деле. Эксешепн можно и не кидать - pop его сам выкинет, циклы IndexError понимают.

Это будет фейлить, если None - допустимое значение.

http://docs.python.org/library/inspect.html не подошёл?

замечание интересное — рантайм знает адрес кода, откуда выскочило исключение, но ни за что его не скажет в пригодной для использования форме

З.Ы. я бы накатал что-то вроде i,j,k = my_next([ iter1, iter2, iter3 ])

Сейчас пытаюсь реализовать. В общих чертах - делаю pop из списка итераторов, потом делаю next, если нет StopIteration, то получаю значение, а сам итератор добавляю в конец списка.

Ещё не знаю. Просто есть ощущение простого решения, но нащупать его пока не удалось.

Выглядит слишком сложным да и другую идею сейчас пробую.

В общих чертах - делаю pop из списка итераторов, потом делаю next, если нет StopIteration, то получаю значение, а сам итератор добавляю в конец списка.

У тебя, видимо, уникальный дар — делать самую черезопную реализацию. Интересно глянуть на пузырьковую сортировку или факториал в твоем исполнении.

Это экземпляры django.models. Итераторы потому, что количество элементов может быть потенциально большим и тянуть их все в память может быть затратным. А по поводу списка пар - интересно, как-то не подумал, спасибо.

Затратным в каком смысле?

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

Огромное количество мифов бродят в головах по поводу производительности, что может быть проще - взять и проверить?

Вытягивать весь queryset в список мне кажется плохой практикой. Но согласен, тут у меня явно преждевременная оптимизация. Поэтому оставил работающее решение, но описал в комменте его проблемы. Если упрёмся в то, что проблема в нём, то будем искать подход лучше.

Решил влоб и создать свой итератор который будет выбрасывать специально обученное исключение:

class MyStopIteration(StopIteration):
    def __init__(self, iterator, *args, **kwargs):
        self.iterator = iterator
        super(MyStopIteration, self).__init__(*args, **kwargs)

class MyIterator(iter):
    def next(self):
        try:
            return super(MyIterator, self).next()
        except StopIteration:
            raise MyStopIteration(self)