Вызов (выбрасывание) исключения в Python вручную

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

Как вручную сгенерировать / вызвать исключение в Python?

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

Будьте конкретны в своем сообщении, например:

raise ValueError('A very specific bad thing happened.')

Не выдвигайте общие исключения

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

Проблема 1: Сокрытие ошибок

raise Exception('I know Python!') # Don't! If you catch, likely to hide bugs.

Например:

def demo_bad_catch():
    try:
        raise ValueError('Represents a hidden bug, do not catch this')
        raise Exception('This is the exception you expect to handle')
    except Exception as error:
        print('Caught this error: ' + repr(error))

>>> demo_bad_catch()
Caught this error: ValueError('Represents a hidden bug, do not catch this',)

Проблема 2: не поймать

И более конкретные уловы не поймут общее исключение:

def demo_no_catch():
    try:
        raise Exception('general exceptions not caught by specific handling')
    except ValueError as e:
        print('we will not catch exception: Exception')


>>> demo_no_catch()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in demo_no_catch
Exception: general exceptions not caught by specific handling

Лучшие практики: raiseзаявление

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

raise ValueError('A very specific bad thing happened')

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

raise ValueError('A very specific bad thing happened', 'foo', 'bar', 'baz') 

К этим аргументам обращается argsатрибут Exceptionобъекта. Например:

try:
    some_code_that_may_raise_our_value_error()
except ValueError as err:
    print(err.args)

печать

('message', 'foo', 'bar', 'baz')    

В Python 2.5 messageбыл добавлен фактический атрибут, чтобы BaseExceptionпоощрять пользователей создавать подклассы исключений и прекращать их использование args, но введение messageи первоначальный устаревший аргументы были отменены .

Лучшие практики: exceptстатья

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

logger = logging.getLogger(__name__)

try:
    do_something_in_app_that_breaks_easily()
except AppError as error:
    logger.error(error)
    raise                 # just this!
    # raise AppError      # Don't do this, you'll lose the stack trace!

Не изменяйте свои ошибки ... но если вы настаиваете.

Вы можете сохранить трассировку стека (и значение ошибки) с помощью sys.exc_info(), но это более подвержено ошибкам и имеет проблемы совместимости между Python 2 и 3 , предпочитая использовать голое значение raiseдля повторного повышения.

Чтобы объяснить - sys.exc_info()возвращает тип, значение и трассировку.

type, value, traceback = sys.exc_info()

Это синтаксис в Python 2 - обратите внимание, что это не совместимо с Python 3:

    raise AppError, error, sys.exc_info()[2] # avoid this.
    # Equivalently, as error *is* the second object:
    raise sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]

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

def error():
    raise ValueError('oops!')

def catch_error_modify_message():
    try:
        error()
    except ValueError:
        error_type, error_instance, traceback = sys.exc_info()
        error_instance.args = (error_instance.args[0] + ' <modification>',)
        raise error_type, error_instance, traceback

И мы сохранили всю трассировку при модификации аргументов. Обратите внимание, что это не лучшая практика и недопустимый синтаксис в Python 3 (что делает совместимость намного сложнее).

>>> catch_error_modify_message()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in catch_error_modify_message
  File "<stdin>", line 2, in error
ValueError: oops! <modification>

В Python 3 :

    raise error.with_traceback(sys.exc_info()[2])

Опять же: избегайте ручного манипулирования трассировками. Это менее эффективно и более подвержено ошибкам. И если вы используете многопоточность, и sys.exc_infoвы можете даже получить неправильную трассировку (особенно если вы используете обработку исключений для потока управления - чего я бы лично избегал).

Python 3, цепочка исключений

В Python 3 вы можете связать исключения, которые сохраняют обратные трассировки:

    raise RuntimeError('specific message') from error

Быть в курсе:

• это действительно позволит изменить тип ошибки воскресают и
• это не совместимо с Python 2.

Устаревшие методы:

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

Допустимо в Python 2, но не в Python 3 :

raise ValueError, 'message' # Don't do this, it's deprecated!

Действует только в гораздо более старых версиях Python (2.4 и ниже), вы все равно можете увидеть людей, поднимающих строки:

raise 'message' # really really wrong. don't do this.

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

Пример использования

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

def api_func(foo):
    '''foo should be either 'baz' or 'bar'. returns something very useful.'''
    if foo not in _ALLOWED_ARGS:
        raise ValueError('{foo} wrong, use "baz" or "bar"'.format(foo=repr(foo)))

Создайте свои собственные типы ошибок, когда уместно

«Я хочу нарочно сделать ошибку, чтобы она пошла в исключение»

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

class MyAppLookupError(LookupError):
    '''raise this when there's a lookup error for my app'''

и использование:

if important_key not in resource_dict and not ok_to_be_missing:
    raise MyAppLookupError('resource is missing, and that is not ok.')

НЕ ДЕЛАЙТЕ ЭТОГО . Поднять голое Exceptionабсолютно не правильно; см . отличный ответ Аарона Холла .

Не может быть намного более питоническим, чем это:

raise Exception("I know python!")

Посмотрите документы поднятия для python, если вам нужна дополнительная информация.

В Python3 есть 4 различных синтаксиса для выявления исключений:

1. raise exception 
2. raise exception (args) 
3. raise
4. raise exception (args) from original_exception

1. поднять исключение против 2. поднять исключение (аргументы)

Если вы используете, raise exception (args) чтобы вызвать исключение, оно argsбудет напечатано при печати объекта исключения - как показано в примере ниже.

  #raise exception (args)
    try:
        raise ValueError("I have raised an Exception")
    except ValueError as exp:
        print ("Error", exp)     # Output -> Error I have raised an Exception 



  #raise execption 
    try:
        raise ValueError
    except ValueError as exp:
        print ("Error", exp)     # Output -> Error 

3.raise

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

def somefunction():
    print("some cleaning")

a=10
b=0 
result=None

try:
    result=a/b
    print(result)

except Exception:            #Output ->
    somefunction()           #some cleaning
    raise                    #Traceback (most recent call last):
                             #File "python", line 8, in <module>
                             #ZeroDivisionError: division by zero

4. поднять исключение (аргументы) из оригинального исключения

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

class MyCustomException(Exception):
pass

a=10
b=0 
reuslt=None
try:
    try:
        result=a/b

    except ZeroDivisionError as exp:
        print("ZeroDivisionError -- ",exp)
        raise MyCustomException("Zero Division ") from exp

except MyCustomException as exp:
        print("MyException",exp)
        print(exp.__cause__)

Вывод:

ZeroDivisionError --  division by zero
MyException Zero Division 
division by zero

Для общего случая, когда вам нужно выдать исключение в ответ на некоторые непредвиденные условия, и который вы никогда не намереваетесь отловить, а просто быстро потерпеть неудачу, чтобы дать вам возможность отладки оттуда, если это когда-нибудь произойдет, - наиболее логичным кажется AssertionError:

if 0 < distance <= RADIUS:
    #Do something.
elif RADIUS < distance:
    #Do something.
else:
    raise AssertionError("Unexpected value of 'distance'!", distance)

Сначала прочтите существующие ответы, это всего лишь дополнение.

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

Пример:

raise SystemExit

Выход из программы, но вы можете знать, что произошло. Так что вы можете использовать это.

raise SystemExit("program exited")

это выведет "программу вышла" в stderr перед закрытием программы.

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

def avg(marks):
    assert len(marks) != 0,"List is empty."
    return sum(marks)/len(marks)

mark2 = [55,88,78,90,79]
print("Average of mark2:",avg(mark2))

mark1 = []
print("Average of mark1:",avg(mark1))

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

try:
    foo() 
except Exception as e:
    print(str(e)) # Print out handled error

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

Для этого вам следует изучить оператор повышения python. Он должен храниться внутри блока try. Пример -

try:
    raise TypeError            #remove TypeError by any other error if you want
except TypeError:
    print('TypeError raised')