Python игнорирует исключение и возвращается к тому, где я был

Ответ 1

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

try:
    do_something1
except TheExceptionTypeThatICanHandleError, e:
    if e.strerror != 10001:
        raise
finally:
     clean_up

Обратите внимание также, что каждому оператору try требуется собственное предложение finally, если вы хотите, чтобы он был таким. Он не присоединяется к предыдущему оператору try. Оператор raise с чем-либо еще является правильным способом повторного создания последнего исключения. Не позволяйте никому говорить вам об этом.

То, что вы хотите, - это продолжения, которые python не обеспечивает. Кроме того, ответ на ваш вопрос зависит от того, что вы хотите сделать. Если вы хотите, чтобы do_something1 продолжался независимо от исключений, тогда он должен был поймать исключения и сам игнорировать их.

если вы просто хотите, чтобы do_something2 выполнялось независимо от того, завершено ли do_something1, для каждого из них требуется отдельный оператор try.

try:
   do_something1()
except:
   pass

try:
   do_something2()
except:
   pass

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

Ответ 2

Это почти не учитывает исключения.

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

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

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

Ответ 3

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

actions = (
    do_something1, do_something2, #...
    )
for action in actions:
    try:
        action()
    except Exception, error:
        pass

Ответ 4

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

Что делать, если вы пишете код, чтобы открыть файл и прочитать его? Что делать, если этот файл не существует?

Гораздо лучше сделать исключение. Вы не можете прочитать файл, в котором не существует. Что вы можете сделать, это обработать исключение, сообщите пользователю, что такого файла нет. Какое преимущество будет получено для продолжения чтения файла, когда файл вообще не может быть открыт.

Фактически, вышеприведенные ответы, представленные Аароном, работают по принципу обработки ваших исключений.

Ответ 5

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

work = [lambda: dosomething1(args), dosomething2, lambda: dosomething3(*kw, **kwargs)]

for each in work:
    try:
        each()
    except:
       pass

cleanup()

Ответ 6

Я опубликовал это недавно как ответ на другой вопрос. Здесь у вас есть функция, которая возвращает функцию, которая игнорирует ( "ловушки" ) указанные исключения при вызове любой функции. Затем вы вызываете нужную функцию косвенно через "ловушку".

def maketrap(*exceptions):
    def trap(func, *args, **kwargs):
        try:
            return func(*args, **kwargs)
        except exceptions:
            return None
    return trap

# create a trap that ignores all exceptions
trapall = maketrap(Exception) 

# create a trap that ignores two exceptions
trapkeyattrerr = maketrap(KeyError, AttributeError)

# Now call some functions, ignoring specific exceptions
trapall(dosomething1, arg1, arg2)
trapkeyattrerr(dosomething2, arg1, arg2, arg3)

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