Python try catch: Исключения в python. Конструкция try — except для обработки исключений

Как лучше всего использовать Try Except в Python

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

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

Зачем использовать конструкции Try-Except / Try-Except-else? С помощью Try-Except и Try-Except-Else вы можете избежать многих неизвестных проблем, которые могут возникнуть из вашего кода.

Вызов исключений также допустимо в Python. Это означает, что вы можете бросить или вызвать исключение, когда это необходимо. Вы можете сделать это, просто вызвав в вашем коде raise Exception(‘Test error!’). Возникнувшее исключение прекратит текущее выполнение как обычно и пойдет дальше в стек вызовов, пока не будет обработано

Зачем использовать исключения? Они не только помогают решать популярные проблемы, такие как состояние race, но также очень полезны для контроля ошибок в таких областях, как циклы, обработка файлов, обмен данными с базой данных, доступ к сети и т.

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

Python: советы по использованию Try-Except, Try-Except-Else и многое другое

1. Как обращаться с произвольным исключением

Иногда вам может понадобиться способ разрешить любое произвольное исключение, а также иметь возможность отображать сообщение об ошибке или исключении.

Это легко достижимо с помощью исключений Python. Проверьте код ниже. Во время тестирования вы можете поместить код внутри блока try как в следующем примере.

try:
    #your code
except Exception as ex:
    print(ex)

2. Поймать несколько исключений в одном блоке Except

except (Exception1, Exception2) as e:
    pass

Обратите внимание, что вы можете отделить исключения от переменной запятой, которая применима в Python 2. 6 / 2.7. Но вы не можете сделать это в Python 3. Поэтому вы должны использовать ключевое слово as.

3. Обработка нескольких исключений одним блоком Except

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

try:
    file = open('input-file', 'open mode')
except (IOError, EOFError) as e:
    print("Testing multiple exceptions. {}".format(e.args[-1]))

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

try:
    file = open('input-file', 'open mode')
except EOFError as ex:
    print("Caught the EOF error.")
    raise ex
except IOError as e:
    print("Caught the I/O error.")
    raise ex

Последнее, но не менее важное, это использовать исключение без упоминания какого-либо атрибута исключения.

try:
    file = open('input-file', 'open mode')
except:
    raise

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

4. Повторный проброс исключений в Python

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

Смотрите приведенный ниже пример кода.

try:
    # Преднамеренно бросить исключение.
    raise Exception('I learn Python!')
except:
    print("Entered in except.")
    # Возобновить исключение.
    raise

Вывод:

Entered in except.
Traceback (most recent call last):
  File "python", line 3, in 
Exception: I learn Python!

5. Когда использовать Else

Используйте предложение else сразу после блока try-except. Предложение else будет получено, только если не сгенерировано исключение. Оператор else всегда должен предшествовать блокам except.

В блоки else вы можете добавить код, который хотите запустить, если ошибок не было.

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

while True:
    x = int(input())

    try:
        result = 1 / x
    except:
        print("Error case")
        exit(0)
    else:
        print("Pass case")
        exit(1)

6. Используйте Finally

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

Ошибка поймана в блоке try. После того, как код в блоке except будет выполнен, инструкции в блоке finally будут выполнены.

Обратите внимание, что блок finally будет ВСЕГДА работать, даже если вы вернулись раньше него.

Смотрите пример ниже.

try:
    x = 1 / 0
except:
    print("Error occurred")
finally:
    print("The [finally clause] is hit")

Вывод:

Error occurred
The [finally clause] is hit

7. Используйте ключевое слово As для отлова определенных типов исключений.

С помощью вы можете создать новый объект. В приведенном ниже примере мы создаем объект IOError и затем используем.

try:
    f = open("no-file")
except IOError as err:
    print("Error:", err)
    print("Code:", err. errno)

Результат:

('Error:', IOError(2, 'No such file or directory'))
('Code:', 2)

8. Лучшая практика для создания исключений

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

Плохой пример:

def bad_exception():
    try:
        raise ValueError('Intentional - do not want this to get caught')
        raise Exception('Exception to be handled')
    except Exception as error:
        print('Inside the except block: ' + repr(error))
        
bad_exception()

Результат:

Inside the except block: ValueError('Intentional - do not want this to get caught',)

Пример получше:

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

try:
    raise ValueError('Testing exceptions: The input is in incorrect order', 'one', 'two', 'four') 
except ValueError as err:
    print(err.args)

Результат:

('Testing exceptions: The input is in incorrect order', 'one', 'two', 'four')

9. Как пропустить ошибки и продолжить выполнение

В идеале, вы не должны этого делать. Но если вы все еще хотите это сделать, следуйте приведенному ниже коду, чтобы проверить правильный подход.

try:
    assert False
except AssertionError:
    pass
print('Welcome to Prometheus!!!')

Результат:

Welcome to Prometheus!!!

Теперь рассмотрим некоторые из наиболее распространенных исключений Python и их примеры.

Наиболее распространенные Exception Errors:

• IOError — происходит при ошибках файловой системы, например, если файл не открывается.
• ImportError — Если модуль Python не может быть загружен или не найден.
• ValueError — происходит, если функция получает аргумент правильного типа, но не подходящего значения.
• KeyboardInterrupt — когда пользователь вводит ключ прерывания (т.е. Control-C или Del в консоли)
• EOFError — Возникает, если входные функции (input() / raw_input()) попадают в условие конца файла (EOF), но без чтения каких-либо данных.

Примеры наиболее распространенных исключений

except IOError:
print('Error occurred while opening the file.')

except ValueError:
print('Non-numeric input detected.')

except ImportError:
print('Unable to locate the module.')

except EOFError:
print('Identified EOF error.')

except KeyboardInterrupt:
print('Wrong keyboard input.')

except:
print('An error occurred.')

Резюме — Как лучше всего использовать Try-Except в Python

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

В любом случае, все это может быть обработано, если ваш код использует обработку исключений и реализует ее с помощью таких конструкций, как try-except или try-except-else, try-except-finally.

Python | Обработка исключений

Обработка исключений

Последнее обновление: 27.04.2017

При программировании на Python мы можем столкнуться с двумя типами ошибок. Первый тип представляют синтаксические ошибки (syntax error). Они появляются в результате нарушения синтаксиса языка программирования при написании исходного кода. При наличии таких ошибок программа не может быть скомпилирована. При работе в какой-либо среде разработки, например, в PyCharm, IDE сама может отслеживать синтаксические ошибки и каким-либо образом их выделять.

Второй тип ошибок представляют ошибки выполнения (runtime error). Они появляются в уже скомпилированной программе в процессе ее выполнения. Подобные ошибки еще называются исключениями. Например, в прошлых темах мы рассматривали преобразование числа в строку:

string = "5"
number = int(string)
print(number)

Данный скрипт успешно скомпилируется и выполнится, так как строка «5» вполне может быть конвертирована в число. Однако возьмем другой пример:

string = "hello"
number = int(string)
print(number)

При выполнении этого скрипта будет выброшено исключение ValueError, так как строку «hello» нельзя преобразовать в число. С одной стороны, здесь очевидно, сто строка не представляет число, но мы можем иметь дело с вводом пользователя, который также может ввести не совсем то, что мы ожидаем:

string = input("Введите число: ")
number = int(string)
print(number)

При возникновении исключения работа программы прерывается, и чтобы избежать подобного поведения и обрабатывать исключения в Python есть конструкция try. .except, которая имеет следующее формальное определение:

try:
	инструкции
except [Тип_исключения]:
	инструкции

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

После ключевого слова except опционально можно указать, какое исключение будет обрабатываться (например, ValueError или KeyError). После слова except на следующей стоке идут инструкции блока except, выполняемые при возникновении исключения.

Рассмотрим обработку исключения на примере преобразовании строки в число:

try:
    number = int(input("Введите число: "))
    print("Введенное число:", number)
except:
    print("Преобразование прошло неудачно")
print("Завершение программы")

Вводим строку:

Введите число: hello
Преобразование прошло неудачно
Завершение программы

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

Вводим правильное число:

Введите число: 22
Введенное число: 22
Завершение программы

Теперь все выполняется нормально, исключение не возникает, и соответственно блок except не выполняется.

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

try:
    number = int(input("Введите число: "))
    print("Введенное число:", number)
except ValueError:
    print("Преобразование прошло неудачно")
print("Завершение программы")

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

try:
    number1 = int(input("Введите первое число: "))
    number2 = int(input("Введите второе число: "))
    print("Результат деления:", number1/number2)
except ValueError:
    print("Преобразование прошло неудачно")
except ZeroDivisionError:
    print("Попытка деления числа на ноль")
except Exception:
    print("Общее исключение")
print("Завершение программы")

Если возникнет исключение в результате преобразования строки в число, то оно будет обработано блоком except ValueError. Если же второе число будет равно нулю, то есть будет деление на ноль, тогда возникнет исключение ZeroDivisionError, и оно будет обработано блоком except ZeroDivisionError.

Тип Exception представляет общее исключение, под которое попадают все исключительные ситуации. Поэтому в данном случае любое исключение, которое не представляет тип ValueError или ZeroDivisionError, будет обработано в блоке except Exception:.

Блок finally

При обработке исключений также можно использовать необязательный блок finally. Отличительной особенностью этого блока является то, что он выполняется вне зависимости, было ли сгенерировано исключение:

try:
    number = int(input("Введите число: "))
    print("Введенное число:", number)
except ValueError:
    print("Не удалось преобразовать число")
finally:
    print("Блок try завершил выполнение")
print("Завершение программы")

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

Получение информации об исключении

С помощью оператора as мы можем передать всю информацию об исключении в переменную, которую затем можно использовать в блоке except:

try:
    number = int(input("Введите число: "))
    print("Введенное число:", number)
except ValueError as e:
    print("Сведения об исключении", e)
print("Завершение программы")

Пример некорректного ввода:

Введите число: fdsf
Сведения об исключении invalid literal for int() with base 10: 'fdsf'
Завершение программы

Генерация исключений

Иногда возникает необходимость вручную сгенерировать то или иное исключение. Для этого применяется оператор raise.

try:
    number1 = int(input("Введите первое число: "))
    number2 = int(input("Введите второе число: "))
    if number2 == 0:
        raise Exception("Второе число не должно быть равно 0")
    print("Результат деления двух чисел:", number1/number2)
except ValueError:
    print("Введены некорректные данные")
except Exception as e:
    print(e)
print("Завершение программы")

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

Введите первое число: 1
Введите второе число: 0
Второе число не должно быть равно 0
Завершение программы

Это хорошая практика, чтобы использовать try-except-else в Python?

В чем причина существования try-except-else?

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

Предложение else будет выполняться, если не было ошибок, и, не выполняя этот код в блоке try , вы избежите неожиданной ошибки. Опять же, перехват неожиданной ошибки может скрыть ошибки.

Пример

Например:

try:
    try_this(whatever)
except SomeException as the_exception:
    handle(the_exception)
else:
    return something

В наборе «try, except» есть два необязательных пункта, else и finally . Так что на самом деле это try-except-else-finally .

else будет вычисляться только в том случае, если нет исключения из блока try . Это позволяет нам упростить более сложный код ниже:

no_error = None
try:
    try_this(whatever)
    no_error = True
except SomeException as the_exception:
    handle(the_exception)
if no_error:
    return something

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

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

Разбивкой с псевдо-код

Это может помочь разбить это на части, в самой маленькой возможной форме, которая демонстрирует все функции, с комментариями. Предположим, что этот синтаксически правильный (но не выполняемый, если имена не определены) псевдокод находится в функции.

Например:

try:
    try_this(whatever)
except SomeException as the_exception:
    handle_SomeException(the_exception)
    # Handle a instance of SomeException or a subclass of it.
except Exception as the_exception:
    generic_handle(the_exception)
    # Handle any other exception that inherits from Exception
    # - doesn't include GeneratorExit, KeyboardInterrupt, SystemExit
    # Avoid bare `except:`
else: # there was no exception whatsoever
    return something()
    # if no exception, the "something()" gets evaluated,
    # but the return will not be executed due to the return in the
    # finally block below. 
finally:
    # this block will execute no matter what, even if no exception,
    # after "something" is eval'd but before that value is returned
    # but even if there is an exception.
    # a return here will hijack the return functionality. e.g.:
    return True # hijacks the return in the else clause above

Это правда, что мы могли бы включить код в блок else вместо этого в блок try , где он будет работать, если не будет исключений, но что, если этот код сам вызовет исключение того типа, который мы ловим? Оставив его в блоке try , можно было бы скрыть эту ошибку.

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

Насколько я понимаю, исключения-это не ошибки

В Python большинство исключений являются ошибками.

Мы можем просмотреть иерархию исключений с помощью pydoc. Например, в Python 2:

$ python -m pydoc exceptions

или Python 3:

$ python -m pydoc builtins

Даст нам иерархию. Мы видим, что большинство видов Exception являются ошибками, хотя Python использует некоторые из них для таких вещей, как завершение циклов for ( StopIteration ). это иерархия Python 3:

BaseException
    Exception
        ArithmeticError
            FloatingPointError
            OverflowError
            ZeroDivisionError
        AssertionError
        AttributeError
        BufferError
        EOFError
        ImportError
            ModuleNotFoundError
        LookupError
            IndexError
            KeyError
        MemoryError
        NameError
            UnboundLocalError
        OSError
            BlockingIOError
            ChildProcessError
            ConnectionError
                BrokenPipeError
                ConnectionAbortedError
                ConnectionRefusedError
                ConnectionResetError
            FileExistsError
            FileNotFoundError
            InterruptedError
            IsADirectoryError
            NotADirectoryError
            PermissionError
            ProcessLookupError
            TimeoutError
        ReferenceError
        RuntimeError
            NotImplementedError
            RecursionError
        StopAsyncIteration
        StopIteration
        SyntaxError
            IndentationError
                TabError
        SystemError
        TypeError
        ValueError
            UnicodeError
                UnicodeDecodeError
                UnicodeEncodeError
                UnicodeTranslateError
        Warning
            BytesWarning
            DeprecationWarning
            FutureWarning
            ImportWarning
            PendingDeprecationWarning
            ResourceWarning
            RuntimeWarning
            SyntaxWarning
            UnicodeWarning
            UserWarning
    GeneratorExit
    KeyboardInterrupt
    SystemExit

— Спросил комментатор:

Допустим, у вас есть метод, который пингует внешний API, и вы хотите обработать исключение в классе вне оболочки API, вы просто возвращаете e из метода в предложении except, где e — объект исключения?

Нет, вы не возвращаете исключение, просто повторите его с помощью голого raise , чтобы сохранить трассировку стека.

try:
    try_this(whatever)
except SomeException as the_exception:
    handle(the_exception)
    raise

Или, в Python 3, Вы можете создать новое исключение и сохранить обратную дорожку с цепочкой исключений:

try:
    try_this(whatever)
except SomeException as the_exception:
    handle(the_exception)
    raise DifferentException from the_exception

Здесь я подробно останавливаюсь на своем ответе .

try except finally в Python

Позволяет задать обработчики исключений, а также определить код «уборки» для некоторого набора инструкций.

class MyException1(Exception): pass
class MyChildException1(MyException1): pass
class MyException2(Exception): pass
class MyChildException2(MyException2): pass
class MyException3(Exception): pass
class MyChildException3(MyException3): pass
def make_exception(exception_type):
try:
raise exception_type()
except MyChildException1:
print('MyChildException1')
except (MyChildException2, MyException3):
print('MyChildException2, MyException3')
except:
print('broad except')
make_exception(MyChildException1)  # MyChildException1
make_exception(MyException2)  # broad except
make_exception(MyChildException3)  # MyChildException2, MyException3

Блок try

• Если в ходе исполнения данного блока исключений не будет, то ни один из обработчиков не задействуется.
• Если в ходе исполнения инструкций в этом блоке будет зафиксировано исключение, то начнётся поиск подходящего для него обработчика. Поиск производится по блокам except поочерёдно, поэтому более широкие типы исключений (базовые) имеет смысл ставить после более узких.

Блок except

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

• Если блок except используется без следующего за ним выражения, то он должен быть последним, потому что в нём производится обработка любых типов.
• Если за блоком следует выражение, то оно будет выполнено. Если полученным в результате выполнения объект «совместим» с исключением, которые мы собираемся обработать, то будут выполнены инструкции, находящиеся в данном блоке. Объект считается совместимым с поднятым исключением, если является классом (непосредственным, либо базовым) исключения, либо кортежем, содержащим элемент, совместимый с исключением.
• Если в ходе поиска обработчик найден не будет, то поиск будет продолжен среди обработчиков окружающего кода по стеку.

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

• Если в ходе выполнения выражения в блоке except будет случится исключение, то поиск обработчика прерывается. При этом начинается поиск нового обработчика в окружающем коде и по стеку вызова. При этом считается, что вся инструкция try except породила исключение.
• Если найден подходящий блок except, то исключению назначается имя указанное после ключевого слова as (до +py.2.5 вместо ключевого слова использоваталсь запятая ,). После чего выполняется код в теле блока.

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

try:
raise Exception('arg1', 'arg2')
except Exception as e:
print(e)
# >> ('arg1', 'arg2')

До +py2.5 нельзя было использовать except совместно с finally, то есть, существовали две формы инструкции: try ... except и try ... finally.

Блок else

def make_exception():
try:
return 'try'
except:
return 'except'
else:
return 'else'
make_exception()  # 'try'

Блок finally

В существующих реализациях употребление continue в блоке finally не поддерживается.

def make_exception():    
try:
1/0
finally:
return 'finally'
make_exception()  # 'finally'

Скорость выполнения

До версии +py2.0 можно было часто видеть конструкцию следующего вида:

try:
value = mydict[key]
except KeyError:
mydict[key] = getvalue(key)
value = mydict[key]

if key in mydict:
value = mydict[key]
else:
value = mydict[key] = getvalue(key)

goto

При помощи инструкции можно соорудить достаточно функциональное подобие go и goto из других языков программирования.

class label(Exception): pass  # метка для goto
try:
...
if condition: raise label()  # переход к метке
...
except label:  # реализация по метке
pass
...

Обработка ошибок с помощью Python—ArcGIS Pro

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

Когда инструмент записывает сообщение об ошибке, ArcPy создает исключение arcpy.ExecuteError. Python позволяет написать модуль, который будет запускаться автоматически при возникновении системной ошибки. С помощью этого модуля для обработки ошибок вы сможете получать сообщения об ошибках от ArcPy и реагировать на них. Если скрипт не имеет модуля для обработки ошибок, он завершает выполнение немедленно, что уменьшает его надежность. Модуль обработки ошибок можно использовать для управления ошибками и повышения надежности скриптов.

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

Выражение try-except

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

В следующем коде Буфер прекращает работу из-за того, что не был указан обязательный параметр buffer_distance_or_field. Вместо завершения без объяснения причин, выражение except используется для поиска ошибки, ее перехвата и вывода сообщения об ошибке, созданной инструментом Буфер. Обратите внимание, что блок except выполняется только в случае, если в инструменте Буфер происходит ошибка.

import arcpy
import sys
try:
    # Execute the Buffer tool
    arcpy.Buffer_analysis("c:/transport/roads.shp", "c:/transport/roads_buffer.shp")
except Exception:
    e = sys.exc_info()[1]
    print(e.args[0])
    # If using this code within a script tool, AddError can be used to return messages 
    #   back to a script tool. If not, AddError will have no effect.
    arcpy.AddError(e.args[0])

Выражение try содержит дополнительный оператор finally, использующийся для задач, которые должны выполняться в любом случае, вне зависимости от появления исключения. В следующем примере дополнительный модуль ArcGIS 3D Analyst включается в оператор finally, что обеспечивает постоянное включение модуля.

class LicenseError(Exception):
    pass
import arcpy
try:
    if arcpy.CheckExtension("3D") == "Available":
        arcpy.CheckOutExtension("3D")
    else:
        # Raise a custom exception
        raise LicenseError
    arcpy.env.workspace = "D:/GrosMorne"
    arcpy.HillShade_3d("WesternBrook", "westbrook_hill", 300)
    arcpy.Aspect_3d("WesternBrook", "westbrook_aspect")
except LicenseError:
    print "3D Analyst license is unavailable"  
except arcpy.ExecuteError:
    print(arcpy.GetMessages(2))
finally:
    # Check in the 3D Analyst extension
    arcpy.CheckInExtension("3D")

Выражение raise

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

class NoFeatures(Exception):
    pass
import arcpy
import os
import sys
arcpy.env.overwriteOutput = True
fc = arcpy.GetParameterAsText(0)
try:
    # Check that the input has features
    result = arcpy.GetCount_management(fc)
    if int(result[0]) > 0:
        arcpy.FeatureToPolygon_management(
            fc, os.path.join(os.path.dirname(fc), 'out_poly.shp'))
    else:
        # Raise custom exception
        raise NoFeatures(result)
except NoFeatures:
    # The input has no features
    print('{} has no features'.format(fc))
except:
    # By default any other errors will be caught here
    e = sys.exc_info()[1]
    print(e.args[0])

Класс ExecuteError

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

import arcpy
import sys
try:
    result = arcpy.GetCount_management("C:/invalid.shp")
  
# Return geoprocessing specific errors
except arcpy.ExecuteError:    
    arcpy.AddError(arcpy.GetMessages(2))    
# Return any other type of error
except:
    # By default any other errors will be caught here
    e = sys.exc_info()[1]
    print(e.args[0])

traceback

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

# Import the required modules
#
import arcpy
import sys
import traceback
arcpy.env.workspace = "C:/Data/myData.gdb"
try:
    arcpy.CreateSpatialReference_management()
    #--------------------------
    # Your code goes here
    #
    # See the table below for examples
    #--------------------------
except arcpy.ExecuteError: 
    # Get the tool error messages 
    msgs = arcpy.GetMessages(2) 
    # Return tool error messages for use with a script tool 
    arcpy.AddError(msgs) 
    # Print tool error messages for use in Python/PythonWin 
    print(msgs)
except:
    # Get the traceback object
    tb = sys.exc_info()[2]
    tbinfo = traceback.format_tb(tb)[0]
    # Concatenate information together concerning the error into a message string
    pymsg = "PYTHON ERRORS:\nTraceback info:\n" + tbinfo + "\nError Info:\n" + str(sys.exc_info()[1])
    msgs = "ArcPy ERRORS:\n" + arcpy.GetMessages(2) + "\n"
    # Return python error messages for use in script tool or Python window
    arcpy.AddError(pymsg)
    arcpy.AddError(msgs)
    # Print Python error messages for use in Python / Python window
    print(pymsg)
    print(msgs)

Если вышеуказанный код будет использован, и в нем возникнет ошибка геообработки, такая как некорректные входные данные, это вызовет arcpy.ExecuteError, и будет использовано первое выражение except. Это выражение выведет сообщение об ошибке с помощью функции GetMessages. Если в коде возникнет ошибка другого типа, будет использовано второе выражение except. Вместо вывода сообщения о процессе геообработки, будет получен объект traceback и выведено подходящее сообщение о соответствующей системной ошибке.

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

PYTHON ERRORS:
Traceback info:
  File "c:\temp\errortest.py", line 10, in <module>
    arcpy.GetCount_management("")
Error Info:
Failed to execute. Parameters are not valid.
ERROR 000735: Input Rows: value is required
Failed to execute (GetCount).
ArcPy ERRORS:
Failed to execute. Parameters are not valid.
ERROR 000735: Input Rows: value is required
Failed to execute (GetCount).

PYTHON ERRORS:
Traceback info:
  File "c:\temp\errortest.py", line 10, in <module>
    x = "a" + 1
Error Info:
cannot concatenate 'str' and 'int' objects

PYTHON ERRORS:
Traceback info:
  File "c:\temp\errortest.py", line 10, in <module>
    float("a text string")
Error Info:
invalid literal for float(): a text string

Получение сообщений об ошибках от объекта Result

Краткая информация об объекте Result, показанном ниже:

result = arcpy.GetCount_management("c:/data/rivers.shp")

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

import arcpy
try:
    result = arcpy.GetCount_management("c:/data/rivers.shp")
# Return Geoprocessing specific errors
# (this method is incorrect!)
except arcpy.ExecuteError:
    arcpy.AddError(result.getMessages(2))

Выполнение представленного выше кода прерывается с сообщением name ‘result’ is not defined. Это связано с тем, что объект Result не создается из-за ошибки инструмента. Поскольку объект Result не создается, при попытке использования метода getMessages возникает ошибка Python.

Объект Result, создаваемый посредством службы геообработки в ArcGIS Server, создается даже при ошибке инструмента. Объект Result не создается только тогда, когда инструмент запускается локально и выдает ошибку. Более подробную информацию об использовании объекта result смотрите в разделе Использование инструментов в Python.

Отзыв по этому разделу?

Работа с исключениями try/except/else/finally — Документация Python для сетевых инженеров 3.0

try/except

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

Как правило, Python довольно понятно реагирует на подобные ошибки, и их можно исправить.

Тем не менее, даже если код синтаксически написан правильно, могут возникать ошибки. В Python эти ошибки называются исключения (exceptions).

Примеры исключений:

In [1]: 2/0
-----------------------------------------------------
ZeroDivisionError: division by zero

In [2]: 'test' + 2
-----------------------------------------------------
TypeError: must be str, not int

В данном случае возникло два исключения: ZeroDivisionError и TypeError.

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

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

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

Примечание

Когда в программе возникает исключение, она сразу завершает работу.

Для работы с исключениями используется конструкция try/except:

In [3]: try:
   ...:     2/0
   ...: except ZeroDivisionError:
   ...:     print("You can't divide by zero")
   ...:
You can't divide by zero

Конструкция try работает таким образом:

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

Обратите внимание, что строка Cool! в блоке try не выводится:

In [4]: try:
   ...:     print("Let's divide some numbers")
   ...:     2/0
   ...:     print('Cool!')
   ...: except ZeroDivisionError:
   ...:     print("You can't divide by zero")
   ...:
Let's divide some numbers
You can't divide by zero

В конструкции try/except может быть много except, если нужны разные действия в зависимости от типа ошибки.

Например, скрипт divide.py делит два числа введенных пользователем:

# -*- coding: utf-8 -*-

try:
    a = input("Введите первое число: ")
    b = input("Введите второе число: ")
    print("Результат: ", int(a)/int(b))
except ValueError:
    print("Пожалуйста, вводите только числа")
except ZeroDivisionError:
    print("На ноль делить нельзя")

Примеры выполнения скрипта:

$ python divide.py
Введите первое число: 3
Введите второе число: 1
Результат:  3

$ python divide.py
Введите первое число: 5
Введите второе число: 0
На ноль делить нельзя

$ python divide.py
Введите первое число: qewr
Введите второе число: 3
Пожалуйста, вводите только числа

В данном случае исключение ValueError возникает, когда пользователь ввел строку вместо числа, во время перевода строки в число.

Исключение ZeroDivisionError возникает в случае, если второе число было равным 0.

Если нет необходимости выводить различные сообщения на ошибки ValueError и ZeroDivisionError, можно сделать так (файл divide_ver2.py):

# -*- coding: utf-8 -*-

try:
    a = input("Введите первое число: ")
    b = input("Введите второе число: ")
    print("Результат: ", int(a)/int(b))
except (ValueError, ZeroDivisionError):
    print("Что-то пошло не так...")

Проверка:

$ python divide_ver2.py
Введите первое число: wer
Введите второе число: 4
Что-то пошло не так...

$ python divide_ver2.py
Введите первое число: 5
Введите второе число: 0
Что-то пошло не так...

Примечание

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

Это делать не рекомендуется!

Когда использовать исключения

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

Например, этот вариант кода:

while True:
    a = input("Введите число: ")
    b = input("Введите второе число: ")
    try:
        result = int(a)/int(b)
    except ValueError:
        print("Поддерживаются только числа")
    except ZeroDivisionError:
        print("На ноль делить нельзя")
    else:
        print(result)
        break

Можно переписать таким образом без try/except (файл try_except_divide.py):

while True:
    a = input("Введите число: ")
    b = input("Введите второе число: ")
    if a.isdigit() and b.isdigit():
        if int(b) == 0:
            print("На ноль делить нельзя")
        else:
            print(int(a)/int(b))
            break
    else:
        print("Поддерживаются только числа")

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

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

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

Обработка исключений в Python: отладка кода и перехват ошибок (try-except)

Иногда, во время работы программы случаются непредвиденные ситуации. Например, попытка поделить число на ноль или чтение несуществующего файла вызовут ошибку и остановят выполнение программы. Такие ситуации в программировании называют исключительными ситуациями, а ошибки — исключениями (exception). Для разных ситуаций есть свои типы исключений:

2 / 0  

open('non_existing_file.txt')  

Как вы могли заметить, названия исключений довольно точно описывают причину возникновения ошибки. Это часть плана: исключения нужны для того, чтобы рассказать программисту что произошло. Однако, когда выбрасывается исключение, вместе с его типом на экран выводится ещё целая куча сопутствующей информации. Давайте рассмотрим такой пример:

def average(numbers):
    return sum(numbers) / len(numbers)
    
average([1, 2, 3])  
average([])  

Выйдет такая ошибка:

Traceback (most recent call last):        # 6
  File "example.py", line 5, in <module>  # 5
    average([])                           # 4
  File "example.py", line 2, in average   # 3
    return sum(numbers) / len(numbers)    # 2
ZeroDivisionError: division by zero       # 1

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

Важно: трейсбек читают снизу вверх. Именно поэтому мы расставили такую нумерацию строчек в примере.

Давайте разберём каждую строчку в примере выше:

1) ZeroDivisionError: division by zero — тип исключения и сообщение с причиной ошибки. Если перевести на русский, сразу понятно: ОшибкаДеленияНаНоль: вы поделили на ноль.

2) return sum(numbers) / len(numbers) — строка, на которой произошла ошибка.

3) File "example.py", line 2, in average — где эту строку искать. В файле example.py, на второй строке, в функции average.

4 и 5) Начиная с этой строки и далее, Python будет указывать какие строки кода исполнялись до момента, с которого началась вся цепочка. Эта информация нужна, когда ошибка произошла где-то внутри чужого кода. Просматривая трейсбэк снизу вверх, можно найти строчку вашего кода, которая стала причиной ошибки.

6) Начало трейсбэка

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

Если возникшее исключение — часть плана или вы хотите обработать его особенном образом, то на такой случай в Python существует конструкция try-except:

filepath = user.get_avatar_filepath()
try:
    avatar = Image.open(filepath)
except FileNotFoundError:
    avatar = default_avatar

Внутри блока try(внутри — это с отступами) пишется код, который потенциально может вызвать ошибку. Если исключения не произойдёт, то Python проигнорирует блок except и пойдёт дальше. Если же возникла ошибка — сработает код внутри блока except.

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

Код, в котором не указан тип ошибки выглядит так:

filepath = user.get_avatar_filepath()
try:
    avatar = use_avatar(filepath)
except:
    avatar = default_avatar

Однажды может случится страшное: другая ошибка. Но код будет себя вести так, будто ничего страшного не произошло, будто он просто не нашёл файл. Python не покажет трейсбек и чинить код придется методом ненаучного тыка.

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

Python Попробуйте, кроме

Блок try позволяет протестировать блок кода ошибок.

Блок кроме позволяет обработать ошибку.

Блок finally позволяет выполнить код независимо от результата блоков try- и except.

Обработка исключений

Когда возникает ошибка или исключение, как мы это называем, Python обычно останавливается и генерировать сообщение об ошибке.

Эти исключения можно обработать с помощью оператора try :

Пример

Блок try сгенерирует исключение, поскольку x не определено:

попробуйте:
print (x)
except:
print («Произошло исключение»)

Поскольку блок try вызывает ошибку, блок исключений будет выполнен.

Без блока try программа выйдет из строя и выдаст ошибку:

Пример

Этот оператор вызовет ошибку, поскольку x не определено:

печать (x)

Множество исключений

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

Пример

Вывести одно сообщение, если блок try вызывает NameError и другое для других ошибок:

попробуйте:
print (x)
except NameError:
print («Переменная x не определено «)
за исключением:
print (» Что-то еще пошло неправильно «)

Остальное

Вы можете использовать ключевое слово else для определения блок кода, который будет выполнен, если ошибок не возникло:

Пример

В этом примере блок try не генерировать любую ошибку:

попробуйте:
print («Привет»)
except:
print («Что-то пошло неправильно «)
else:
print (» Ничего не случилось «)

Наконец

Будет выполнен блок finally , если он указан независимо от того, блок попыток выдает ошибку или нет.

Пример

попробуйте:
print (x)
except:
print («Что-то пошло неправильно «)
наконец:
print (» Попытка, кроме «завершена»)

Это может быть полезно для закрытия объектов и очистки ресурсов:

Пример

Попытайтесь открыть и записать в файл, который недоступен для записи:

попробуйте:
f = open («demofile.txt»)
f.write («Lorum Ipsum»)
за исключением:
print («Что-то пошло неправильно при записи в файл «)
наконец:
ф.закрыть ()

Программа может продолжаться, не оставляя файловый объект открытым.

Вызов исключения

Как разработчик Python вы можете генерировать исключение при возникновении условия.

Чтобы вызвать (или вызвать) исключение, используйте ключевое слово raise .

Пример

Вызов ошибки и остановка программы, если x меньше 0:

, если x <0:
вызывать исключение («К сожалению, ниже нет чисел ноль «)

Ключевое слово Повышение используется для повышения исключение.

Вы можете определить, какую ошибку выдавать, и текст для вывода пользователю.

Пример

Вызывает ошибку TypeError, если x не является целым числом:

, если не type (x) is int:
raise TypeError («Только целые числа разрешены «)

Python Try Except — GeeksforGeeks

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

• IOError: , если файл не может быть открыт
• KeyboardInterrupt: , когда пользователь нажимает ненужную клавишу.
• ValueError: , когда встроенная функция получает неверный аргумент.
• EOFError: , если достигается конец файла без чтения каких-либо данных.
• ImportError: , если это невозможно. чтобы найти модуль

Try Except в Python

Оператор Try and Except используется для обработки этих ошибок в нашем коде на Python.Блок try используется для проверки некоторого кода на наличие ошибок, т.е. код внутри блока try будет выполняться, когда в программе нет ошибок. В то время как код внутри блока except будет выполняться всякий раз, когда программа обнаруживает ошибку в предыдущем блоке try.

Синтаксис:

 попробуйте:
    # Немного кода
Кроме:
    # Выполняется, если ошибка в
    # try block 

Как работает try ()?

• Сначала выполняется предложение try i.е. код между попробуйте и , за исключением пункта .
• Если нет исключения, то будет выполняться только предложение try , , за исключением предложения , завершено.
• Если возникнет какое-либо исключение, предложение try будет пропущено и будет выполнено предложение за исключением .
• Если возникает какое-либо исключение, но предложение except в коде его не обрабатывает, оно передается во внешние операторы try . Если исключение осталось необработанным, выполнение останавливается.
• Оператор try может иметь более одного , за исключением предложения

Код 1: Без исключения, поэтому будет выполнено предложение try .

Python

 ('Да! Ваш ответ:', 1) 

 Извините! Вы делите на ноль 

 попробуйте:
    # Немного кода
Кроме:
    # Выполняется, если ошибка в
    # попробуйте заблокировать
еще:
    # выполнить, если нет исключений 

.0 Выход: -9000,0 a / b приводит к 0

finally Ключевое слово в Python

Python предоставляет ключевое слово finally, которое всегда выполняется после блоков try и except. Последний блок всегда выполняется после нормального завершения блока try или после завершения блока try из-за некоторых исключений.


Синтаксис:

 попробуйте:
    # Немного кода
Кроме:
    # Выполняется, если ошибка в
    # попробуйте заблокировать
еще:
    # выполнить, если нет исключения
наконец-то:
    # Некоторый код ..... (всегда выполняется) 

Код:

Python3

Вывод:

 Нельзя делить на ноль
Это всегда выполняется 

Статьи по теме:


Эта статья предоставлена ​​ Mohit Gupta_OMG 😀 .Если вам нравится GeeksforGeeks, и вы хотели бы внести свой вклад, вы также можете написать статью с помощью provide.geeksforgeeks.org или отправить ее по электронной почте на [email protected]. Посмотрите, как ваша статья появляется на главной странице GeeksforGeeks, и помогите другим гикам.
Пожалуйста, напишите комментарий, если вы обнаружите что-то неправильное, или вы хотите поделиться дополнительной информацией по теме, обсужденной выше.


Внимание компьютерщик! Укрепите свои основы с помощью курса Python Programming Foundation и изучите основы.

Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса Python DS . И чтобы начать свое путешествие по машинному обучению, присоединяйтесь к Машинное обучение — курс базового уровня

Введение — Real Python

Смотреть сейчас В этом руководстве есть связанный видеокурс, созданный командой Real Python. SyntaxError: недопустимый синтаксис

Стрелка указывает, где синтаксический анализатор обнаружил синтаксическую ошибку .В этом примере одной скобки слишком много. Удалите его и снова запустите свой код:

  >>> печать (0/0)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
ZeroDivisionError: целочисленное деление или по модулю нуля
  

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

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

Возникновение исключения

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

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

  х = 10
если x> 5:
    Raise Exception ('x не должно превышать 5.Значение x было: {} '. Format (x))
  

Когда вы запустите этот код, вы получите следующий результат:

  Traceback (последний звонок последний):
  Файл "", строка 4, в 
Исключение: x не должно превышать 5. Значение x было: 10.
  

Программа останавливается и отображает наше исключение на экране, предлагая подсказки о том, что пошло не так.

Ошибка

  импортных систем
assert ('linux' в sys.platform), «Этот код работает только в Linux."
  

  Traceback (последний звонок последний):
  Файл "", строка 2, в 
AssertionError: этот код работает только в Linux.
  

  def linux_interaction ():
    assert ('linux' в sys.platform), «Функция может работать только в системах Linux."
    print ('Делаю что-то.')
  

  попробуйте:
    linux_interaction ()
Кроме:
    проходить
  

  попробуйте:
    linux_interaction ()
Кроме:
    print ('Функция Linux не была выполнена')
  

  Функция Linux не была выполнена
  

  попробуйте:
    linux_interaction ()
кроме AssertionError как ошибки:
    печать (ошибка)
    print ('Функция linux_interaction () не была выполнена')
  

  Функция может работать только в системах Linux.Функция linux_interaction () не была выполнена
  

  попробуйте:
    с открытым ('файл.log ') как файл:
        read_data = file.read ()
Кроме:
    print ('Не удалось открыть файл.log')
  

  попробуйте:
    с open ('file.log') как файл:
        read_data = file.read ()
кроме FileNotFoundError как fnf_error:
    печать (fnf_error)
  

  [Errno 2] Нет такого файла или каталога: 'file.log'
  

  попробуйте:
    linux_interaction ()
    с open ('file.log') как файл:
        read_data = file.read ()
кроме FileNotFoundError как fnf_error:
    печать (fnf_error)
кроме AssertionError как ошибки:
    печать (ошибка)
    print ('Функция Linux linux_interaction () не была выполнена')
  

  Функция может работать только в системах Linux.Функция Linux linux_interaction () не была выполнена
  

  [Errno 2] Нет такого файла или каталога: 'file.log'
  

  попробуйте:
    linux_interaction ()
кроме AssertionError как ошибки:
    печать (ошибка)
еще:
    print ('Выполнение предложения else.')
  

  Что-то делать.
Выполнение предложения else.
  

  попробуйте:
    linux_interaction ()
кроме AssertionError как ошибки:
    печать (ошибка)
еще:
    пытаться:
        с открытым ('файл.log ') как файл:
            read_data = file.read ()
    кроме FileNotFoundError как fnf_error:
        печать (fnf_error)
  

  Что-то делать.
[Errno 2] Нет такого файла или каталога: 'file.log'
  

  попробуйте:
    linux_interaction ()
кроме AssertionError как ошибки:
    печать (ошибка)
еще:
    пытаться:
        с открытым ('файл.log ') как файл:
            read_data = file.read ()
    кроме FileNotFoundError как fnf_error:
        печать (fnf_error)
наконец-то:
    print ('Очистка, независимо от каких-либо исключений.')
  

  Функция может работать только в системах Linux.Уборка, независимо от каких-либо исключений.
  

  # import module sys для получения типа исключения
import sys

randomList = ['а', 0, 2]

для записи в randomList:
    пытаться:
        print ("Запись есть", запись)
        r = 1 / int (запись)
        перерыв
    Кроме:
        print ("Ой!", sys.exc_info () [0], «произошло.»)
        print ("Следующая запись.")
        Распечатать()
print ("Обратное значение", entry, "равно", r)  

  Запись
Ой!  произошел.
Следующая запись.

Запись 0
Ой!  произошел.
Следующая запись.

Запись 2
Обратное 2 равно 0,5  

  # import module sys для получения типа исключения
import sys

randomList = ['а', 0, 2]

для записи в randomList:
    пытаться:
        print ("Запись есть", запись)
        r = 1 / int (запись)
        перерыв
    кроме исключения как e:
        print ("Ой!", e.__class__, «произошло».)
        print ("Следующая запись.")
        Распечатать()
print ("Обратное значение", entry, "равно", r)  

  попробуйте:
   # сделай что-нибудь
   проходить

кроме ValueError:
   # обрабатывать исключение ValueError
   проходить

except (TypeError, ZeroDivisionError):
   # обрабатывать несколько исключений
   # TypeError и ZeroDivisionError
   проходить

Кроме:
   # обрабатывать все остальные исключения
   проездной  

  >>> поднять KeyboardInterrupt
Отслеживание (последний вызов последний):
...
KeyboardInterrupt

>>> поднять MemoryError ("Это аргумент")
Отслеживание (последний вызов последний):
...
MemoryError: это аргумент

>>> попробуйте:
... a = int (input ("Введите положительное целое число:"))
...если a <= 0:
... поднять ValueError ("Это не положительное число!")
... кроме ValueError as ve:
... печать (ве)
...
Введите положительное целое число: -2
Это не положительное число!  

  # программа для печати обратной величины четных чисел

пытаться:
    num = int (input ("Введите число:"))
    утверждать число% 2 == 0
Кроме:
    print («Не четное число!»)
еще:
    обратный = 1 / число
    печать (обратная)  

  Введите номер: 1
Не четное число!  

  Введите число: 4
0,25  

  Введите число: 0
Отслеживание (последний вызов последний):
  Файл «<строка>», строка 7, в <модуле>
    обратный = 1 / число
ZeroDivisionError: деление на ноль  

  попробуйте:
   f = open ("test.txt", encoding = 'utf-8')
   # выполнять файловые операции
наконец-то:
   f.close ()  

 попробуйте:
ваш код...
Кроме:
ваш код ... 

 попробуйте:
печать (наша переменная)
Кроме:
print ('Ошибка возвращена') 

 попробуйте:
печать (наша переменная)
кроме NameError:
print ('наша переменная не определена')
Кроме:
print ('Ошибка возвращена') 

 попробуйте:
печать (наша переменная)
Кроме:
print ('наша переменная не определена')
наконец-то:
print ('Код был запущен.') 

 наша переменная не определена
Код был запущен.

 попробуйте:
print ('Тест')
Кроме:
print ('Возникла проблема.')
еще:
print ('Проблем нет.') 

  a = 10
б = 20

если (a  

  a = 'foo'
b = 'бар'
print (a% b)  

  Traceback (последний вызов последним):
  Файл test.py ", строка 4, в 
    печать (a% b)
TypeError: не все аргументы преобразуются во время форматирования строки

Процесс завершен с кодом выхода 1  

  from datetime import datetime

current_date = datetime.сейчас()
print ("Текущая дата:" + current_date.strftime ('% Y-% m-% d'))

dateinput = input ("Введите дату в формате гггг-мм-дд:")
"" "Мы не проверяем формат ввода даты здесь" ""
date_provided = datetime.strptime (dateinput, '% Y-% m-% d')
print ("Указанная дата:" + date_provided.strftime ('% Y-% m-% d'))

если (date_provided.date ()  

  Текущая дата: 2021-01-24
Введите дату в формате гггг-мм-дд: 2021-01-22
Предоставлена ​​дата: 22 января 2021 г.
Отслеживание (последний вызов последний):
  Файл "test.py", строка 13, в 
    поднять исключение ("Указанная дата не может быть в прошлом")
Исключение: указанная дата не может быть в прошлом.

Процесс завершен с кодом выхода 1  

 ...

если (date_provided.date ()  

  ...
...

    Raise ValueError ("Указанная дата не может быть в прошлом")
ValueError: указанная дата не может быть в прошлом  

  from datetime import datetime

current_date = datetime.now ()
print ("Текущая дата:" + current_date.strftime ('% Y-% m-% d'))

dateinput = input ("Введите дату в формате гггг-мм-дд:")
"" "Мы не проверяем формат ввода даты здесь" ""
date_provided = datetime.strptime (dateinput, '% Y-% m-% d')
print ("Указанная дата:" + date_provided.strftime ('% Y-% m-% d'))

assert (date_provided.date ()> = current_date.date ()), «Указанная дата не может быть в прошлом»  

  Текущая дата: 2021-01-24
Введите дату в формате гггг-мм-дд: 2021-01-23
Отслеживание (последний вызов последний):
Предоставленная дата: 2021-01-23
  Файл "test.py ", строка 12, в 
    assert (date_provided.date ()> = current_date.date ()), «Указанная дата не может быть в прошлом»
AssertionError: указанная дата не может быть в прошлом

Процесс завершен с кодом выхода 1  

  <программный код>
...
пытаться:
    <программный код>
Кроме:
    <код обработки исключений>
<программный код>
...  

  import sys
assert (sys.version_info [0] == 3), «Версия Python должна быть 3»  

  Traceback (последний вызов последним):
  Файл "test.py", строка 2, в 
    assert (sys.version_info [0] == 3), "Версия Python должна быть 3"
AssertionError: версия Python должна быть 3

Процесс завершен с кодом выхода 1  

  импортных систем
пытаться:
    assert (sys.version_info [0] == 3), «Версия Python должна быть 3»
кроме исключения как e:
    print (e)  

  from datetime import datetime

current_date = datetime.now ()
print ("Текущая дата:" + current_date.strftime ('% Y-% m-% d'))

dateinput = input ("Введите дату в формате гггг-мм-дд:")

пытаться:
    date_provided = datetime.strptime (dateinput, '% Y-% m-% d')
кроме ValueError как e:
    печать (е)
    выход()

print ("Указанная дата:" + date_provided.strftime ('% Y-% m-% d'))
assert (date_provided.date ()> = current_date.date ()), «Указанная дата не может быть в прошлом»  

  ...
пытаться:
    <программный код>
кроме <Тип исключения 1>:
    <код обработки исключений>
кроме <Тип исключения 2>:
    <код обработки исключений>
кроме <Тип исключения 3>:
    <код обработки исключений>
...  

  num0 = 10

пытаться:
    num1 = input ("Введите 1-е число:")
    num2 = input ("Введите 2-е число:")
    результат = (int (num1) * int (num2)) / (num0 * int (num2))
кроме ValueError как ve:
    печать (ве)
    выход()
кроме ZeroDivisionError как zde:
    печать (здесь)
    выход()
кроме TypeError как te:
    печать (te)
    выход()
Кроме:
    print ('Неожиданная ошибка!')
    выход()

print (result)  

  nter 1st number: 1
Введите 2-е число: 0
деление на ноль

Введите 1-е число:
Введите 2-е число: 6
недопустимый литерал для int () с базой 10: ''

Введите 1-е число: 12.99
Введите 2-е число: 33
недопустимый литерал для int () с базой 10: '12 .99 ' 

  ...
пытаться:
    <программный код>
кроме <Тип исключения 1>:
    <код обработки исключений>
кроме <Тип исключения 2>:
    <код обработки исключений>
кроме <Тип исключения 3>:
    <код обработки исключений>
...
еще:
    <программный код для запуска, если блок "try" не обнаруживает ошибок>
...  

  num0 = 10

пытаться:
    num1 = int (input ("Введите 1-е число:"))
    num2 = int (input ("Введите 2-е число:"))
кроме ValueError как ve:
    печать (ве)
    выход()
кроме ZeroDivisionError как zde:
    печать (здесь)
    выход()
кроме TypeError как te:
    печать (te)
    выход()
Кроме:
    print ('Неожиданная ошибка!')
    выход()
еще:
    результат = (число1 * число2) / (число0 * число2)
    print (результат)  

  Введите 1-е число: 2
Введите 2-е число: 3
0.2  

  Введите 1-е число: s
недопустимый литерал для int () с базой 10: 's'

Введите 1-е число: 20
Введите 2-е число:
недопустимый литерал для int () с базой 10: ''

Введите 1-е число: 5
Введите 2-е число: 6.4
недопустимый литерал для int () с основанием 10: '6.4'  

  Введите 1-е число: 1
Введите 2-е число: 0
Отслеживание (последний вызов последний):
  Файл "test.py ", строка 19, в 
    результат = (число1 * число2) / (число0 * число2)
ZeroDivisionError: деление на ноль  

  num0 = 10

пытаться:
    num1 = int (input ("Введите 1-е число:"))
    num2 = int (input ("Введите 2-е число:"))
кроме ValueError как ve:
    печать (ве)
    выход()
кроме ZeroDivisionError как zde:
    печать (здесь)
    выход()
кроме TypeError как te:
    печать (te)
    выход()
Кроме:
    print ('Неожиданная ошибка!')
    выход()
еще:
    пытаться:
        результат = (число1 * число2) / (число0 * число2)
    кроме исключения как e:
        печать (е)
        выход()
    еще:
        print (result)  

  Введите 1-е число: 1
Введите 2-е число: 0
деление на ноль  

  ...
пытаться:
    <программный код>
кроме <Тип исключения 1>:
    <код обработки исключений>
кроме <Тип исключения 2>:
    <код обработки исключений>
кроме <Тип исключения 3>:
    <код обработки исключений>
...
еще:
    <программный код для запуска, если блок "try" не обнаруживает ошибок>
наконец-то:
    <программный код, который выполняется независимо от ошибок в блоке "try" или "else">
...  

  попробуйте:
    f = open ("testfile.txt", 'r')
кроме FileNotFoundError как fne:
    печать (fne)
    print ('Создание файла ...')
    f = open ("testfile.txt", 'w')
    f.write ('2')
еще:
    data = f.readline (1)
    печать (данные)
наконец-то:
    print ('Закрытие файла')
    f.close ()  

  import rollbar
штанга.init ('POST_SERVER_ITEM_ACCESS_TOKEN', 'разработчик')

пытаться:
    <код>
кроме TypeError:
    rollbar.report_message ('Несоответствие типа данных', 'фатальный')
Кроме:
    rollbar.report_exc_info ()