Исключительные ситуации и их обработка

Стандартная обработка исключительной ситуации

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

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

Трассировка говорит, что исключительная ситуация возникла в модуле Translate.py в строке 84 при вызове метода TranslateFromPtoQ. Вызванный метод находится в том же модуле. При выполнении этого метода в строке 64 оператор assert породил исключительную ситуацию, что привело к созданию объекта класса AssertionError. Сообщение, связанное с объектом, говорит о причине возникновения ситуации.

Охраняемый блок кода. Предусмотренная обработка исключительных ситуаций

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

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

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

class pattern(object):
    """образец"""
    def method():
        <фрагмент кода>

        try:
            < охраняемый фрагмент кода>

        except <имя класса исключений> as <имя объекта>:
            < код обработчика исключения>

            ...
       except <имя класса исключений> as <имя объекта>:
            < код обработчика исключения>

<фрагмент кода>

Как это работает? При запуске метода method на выполнение возможны следующие сценарии:

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

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

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

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

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

Зачастую, except-обработчик Python позволяет выдать более полную информацию об исключительной ситуации в сравнении со стандартным обработчиком. Самое главное, - он может исправить ситуацию обеспечив корректное продолжение работы.

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

Если в доме возник пожар, то мало кричать "пожар" и одновременно предлагать жителям дома спокойно продолжать свои дела. Пожар нужно тушить, жителей нужно спасать.

Давайте рассмотрим вариации синтаксиса в задании except-обработчиков:

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

import random
def f(x):
    return x + [1]
    
def g(x):
    return x + 1

def fg():
    #начальный блок
    x = random.randint(-1, 4)

    #охраняемый блок
    try:
        if x < 1:
            y = (x + 1)/ x
        elif x > 2:
            y = f(x)
        else:
            y = f([2])
    except ZeroDivisionError as e:
        print('ошибка: деление на ноль')
        print(e)
        
        # Исправление ситуации
        print('Исправление ситуации')
        x = x + 1
        y = (x + 1) / x
        
    except TypeError as e:
        print('ошибка: несовместимые типы операндов')
        print(e)

        # Исправление ситуации
        print('Исправление ситуации')
        y = g(x)
    
    #финальный блок
    print ('финальный результат: y =  ', y)
    return y

def test1():
    print('В охраняемом блоке возможны исключительные ситуации!')
    y = fg()  

test1()

При запуске теста на выполнение вызывается функция fg(). Эта функция построена в полном соответствии с приведенной выше схемой, - в ней есть начальный, охраняемый и заключительный блоки. В охраняемом блоке в зависимости от значения x, сгенерированного в начальном блоке, по-разному вычисляются значения переменной y. Вычисления могут успешно выполняться, но могут возникать и различные исключительные ситуации. Мы не хотим встраивать дополнительную проверку ситуаций в тело охраняемого блока. Исправление ситуаций возлагается на except-обработчиков, которые в зависимости от возникшей ситуации корректируют данные, чтобы работа функции корректно завершилась.

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

Приведу результаты работы нескольких сеансов работы этого теста, демонстрирующих различные ситуации, возникающие на этих сеансах:

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

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

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

Блоки finally и else

Блок try-except может дополняться еще двумя блоками - finally и else.

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

В приведенном выше примере финальный блок работает в двух случаях:

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