Ручное повышение (выброс) исключения в Python

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

Ответ 1

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

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

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

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

Не вызывать общие исключения

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

Проблема 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` statement

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

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 в BaseException был добавлен фактический атрибут message в пользу поощрения пользователей к подклассам Exceptions и прекращения использования args, но введение из message, и первоначальная устаревшая аргументация была отложена.

Рекомендации: `except`

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

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!

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

Вы можете сохранить stacktrace (и значение ошибки) с помощью 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]

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

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 вы можете связать Исключения, которые сохраняют tracebacks:

    raise RuntimeError('specific message') from error

Знайте:

это позволяет изменить тип ошибки, и
это несовместимо с Python 2.

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

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

Действителен в Python 2, но не в Python 3:

raise ValueError, 'message' # Don't do this, it 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)))

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

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

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

class MyAppLookupError(LookupError):
    '''raise this when there 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.')

Ответ 2

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

Не может быть намного больше pythonic, чем это:

raise Exception("I know python!")

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

Ответ 3

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

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

1. повысить исключение против 2. повысить исключение (args)

Если вы используете 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 Exception.

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. raise exception (args) from original_exception

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

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

Ответ 4

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

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

Ответ 5

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

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

Пример:

raise SystemExit

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

raise SystemExit("program exited")

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

Ответ 6

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

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

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

Ответ 7

Другой способ выбросить исключение - 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))

Ответ 8

использовать ключевое слово повышения

raise ValueError('Error Message.')