Який правильний спосіб оголосити спеціальні класи виключень у сучасному Python? Моя основна мета - дотримуватися стандартних інших класів винятків, щоб (наприклад) будь-який додатковий рядок, який я включаю до винятку, був роздрукований будь-яким інструментом, що потрапив у виняток.

Під "сучасним Python" я маю на увазі те, що буде працювати в Python 2.5, але бути "правильним" для Python 2.6 та Python 3. * спосіб робити речі. Під "користувальницьким" я маю на увазі об'єкт "Виняток", який може включати додаткові дані про причину помилки: рядок, можливо, також якийсь інший довільний об'єкт, що має відношення до винятку.

Мене спрацьовувало таке попередження про знищення в Python 2.6.2:

>>> class MyError(Exception):
...     def __init__(self, message):
...         self.message = message
... 
>>> MyError("foo")
_sandbox.py:3: DeprecationWarning: BaseException.message has been deprecated as of Python 2.6

Здається, божевільним BaseExceptionє особливе значення для названих атрибутів message. Я знаходжу з PEP-352, що атрибут мав особливе значення в 2.5, яке вони намагаються знехтувати, тому я здогадуюсь, що це ім'я (і те саме) зараз заборонено? Тьфу.

Я також нечітко усвідомлюю, що Exceptionмає якийсь магічний параметр args, але я ніколи не знав, як ним користуватися. Я також не впевнений, що це правильний шлях робити справи вперед; Багато дискусій, які я знайшов в Інтернеті, припустили, що вони намагаються усунути аргументи в Python 3.

Оновлення: дві відповіді пропонують переосмислити __init__, та __str__/ __unicode__/ __repr__. Це здається, що багато друкувати, це потрібно?

Можливо, я пропустив питання, але чому б ні:

class MyException(Exception):
    pass

Редагувати: щоб щось замінити (або пропустити додаткові аргументи), зробіть це:

class ValidationError(Exception):
    def __init__(self, message, errors):

        # Call the base class constructor with the parameters it needs
        super(ValidationError, self).__init__(message)

        # Now for your custom code...
        self.errors = errors

Таким чином, ви можете передати дік повідомлень про помилки до другого параметра і дійти до нього пізніше e.errors

Python 3 Update: У Python 3+ ви можете використовувати це трохи більш компактне використання super():

class ValidationError(Exception):
    def __init__(self, message, errors):

        # Call the base class constructor with the parameters it needs
        super().__init__(message)

        # Now for your custom code...
        self.errors = errors

В сучасних винятків Python, вам не потрібно зловживати .message, або перевизначити .__str__()або .__repr__()або який - або з нього. Якщо все, що ви хочете, - це інформативне повідомлення при підвищенні вашого винятку, зробіть це:

class MyException(Exception):
    pass

raise MyException("My hovercraft is full of eels")

Це дасть прослідку, що закінчується MyException: My hovercraft is full of eels.

Якщо ви хочете отримати більшу гнучкість від винятку, ви можете передати словник як аргумент:

raise MyException({"message":"My hovercraft is full of animals", "animal":"eels"})

Однак дістатись до цих деталей у exceptблоці трохи складніше. Деталі зберігаються в argsатрибуті, який є списком. Вам потрібно буде зробити щось подібне:

try:
    raise MyException({"message":"My hovercraft is full of animals", "animal":"eels"})
except MyException as e:
    details = e.args[0]
    print(details["animal"])

Ще можна передати декілька предметів до винятку та отримати доступ до них за допомогою індексів кортежу, але це вкрай не рекомендується (і навіть було призначене для депресії на деякий час назад). Якщо вам потрібно більше однієї інформації, і описаний вище метод недостатній для вас, вам слід підкласи, Exceptionяк описано в підручнику .

class MyError(Exception):
    def __init__(self, message, animal):
        self.message = message
        self.animal = animal
    def __str__(self):
        return self.message

"Правильний спосіб оголосити спеціальні винятки в сучасному Python?"

Це добре, якщо виняток не є типом більш конкретного винятку:

class MyException(Exception):
    pass

Або краще (можливо, ідеально), замість того, щоб passнадати доктрину:

class MyException(Exception):
    """Raise for my specific kind of exception"""

Підкласи винятків підкласів

Від док

Exception

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

Це означає, що якщо ваш виняток є типом більш конкретного винятку, підклас цього винятку замість загального Exception(і результат буде таким, який ви все ще отримуєте з Exceptionрекомендацій, які рекомендують документи). Крім того, ви можете принаймні надати docstring (і не бути змушеним використовувати passключове слово):

class MyAppValueError(ValueError):
    '''Raise when my specific value is wrong'''

Встановлюйте атрибути, які ви створюєте самостійно за допомогою спеціального користування __init__. Уникайте передачі дикту як позиційного аргументу, майбутні користувачі вашого коду будуть вам вдячні. Якщо ви використовуєте атрибут застарілого повідомлення, призначаючи його самостійно, ви уникнете DeprecationWarning:

class MyAppValueError(ValueError):
    '''Raise when a specific subset of values in context of app is wrong'''
    def __init__(self, message, foo, *args):
        self.message = message # without this you may get DeprecationWarning
        # Special attribute you desire with your Error, 
        # perhaps the value that caused the error?:
        self.foo = foo         
        # allow users initialize misc. arguments as any other builtin Error
        super(MyAppValueError, self).__init__(message, foo, *args) 

Насправді не потрібно писати свій власний __str__або __repr__. Вбудовані дуже приємні, і ваше спільне спадщину гарантує, що ви ним користуєтесь.

Критика верхньої відповіді

Можливо, я пропустив питання, але чому б ні:

class MyException(Exception):
    pass

Знову ж таки, проблема вищезазначеного полягає в тому, що для того, щоб зловити його, вам доведеться або назвати його конкретно (імпортувати його, якщо створено в іншому місці), або вилучити виняток (але ви, мабуть, не готові обробляти всі типи винятків, і ви повинні виловлювати лише винятки, з якими ви готові впоратися). Аналогічна критика нижче, але крім того, це не спосіб ініціалізації через super, і ви отримаєте, DeprecationWarningякщо ви отримаєте доступ до атрибуту повідомлення:

Редагувати: щоб щось замінити (або пропустити додаткові аргументи), зробіть це:

class ValidationError(Exception):
    def __init__(self, message, errors):

        # Call the base class constructor with the parameters it needs
        super(ValidationError, self).__init__(message)

        # Now for your custom code...
        self.errors = errors

Таким чином, ви можете передати дік повідомлень про помилки до другого параметра та дістатись до нього пізніше за допомогою ererrors

Він також вимагає передавати рівно два аргументи (окрім self.) Не більше, не менше. Це цікаве обмеження, яке майбутні користувачі можуть не оцінити.

Бути прямим - це порушує замість Ліскова .

Я продемонструю обидві помилки:

>>> ValidationError('foo', 'bar', 'baz').message

Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    ValidationError('foo', 'bar', 'baz').message
TypeError: __init__() takes exactly 3 arguments (4 given)

>>> ValidationError('foo', 'bar').message
__main__:1: DeprecationWarning: BaseException.message has been deprecated as of Python 2.6
'foo'

У порівнянні з:

>>> MyAppValueError('foo', 'FOO', 'bar').message
'foo'

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

>>> raise Exception('bad thing happened')
Exception: bad thing happened

>>> raise Exception('bad thing happened', 'code is broken')
Exception: ('bad thing happened', 'code is broken')

тож, можливо, ви хочете мати якийсь " шаблон винятку ", який працює як сам виняток, сумісним чином:

>>> nastyerr = NastyError('bad thing happened')
>>> raise nastyerr
NastyError: bad thing happened

>>> raise nastyerr()
NastyError: bad thing happened

>>> raise nastyerr('code is broken')
NastyError: ('bad thing happened', 'code is broken')

це можна легко зробити за допомогою цього підкласу

class ExceptionTemplate(Exception):
    def __call__(self, *args):
        return self.__class__(*(self.args + args))
# ...
class NastyError(ExceptionTemplate): pass

і якщо вам не подобається це стандартне подання за кордоном, просто додайте __str__метод до ExceptionTemplateкласу, наприклад:

    # ...
    def __str__(self):
        return ': '.join(self.args)

і ти матимеш

>>> raise nastyerr('code is broken')
NastyError: bad thing happened: code is broken

Станом на Python 3.8 (2018, https://docs.python.org/dev/whatsnew/3.8.html ), рекомендований метод як і раніше:

class CustomExceptionName(Exception):
    """Exception raised when very uncommon things happen"""
    pass

Будь ласка, не забудьте задокументувати, чому необхідний спеціальний виняток!

Якщо вам потрібно, це шлях для винятку з більшою кількістю даних:

class CustomExceptionName(Exception):
    """Still an exception raised when uncommon things happen"""
    def __init__(self, message, payload=None):
        self.message = message
        self.payload = payload # you could add more args
    def __str__(self):
        return str(self.message) # __str__() obviously expects a string to be returned, so make sure not to send any other data types

і отримувати їх, як:

try:
    raise CustomExceptionName("Very bad mistake.", "Forgot upgrading from Python 1")
except CustomExceptionName as error:
    print(str(error)) # Very bad mistake
    print("Detail: {}".format(error.payload)) # Detail: Forgot upgrading from Python 1

payload=Noneважливо зробити його маринованим. Перш ніж скинути його, вам потрібно зателефонувати error.__reduce__(). Завантаження працюватиме як очікувалося.

Можливо, вам слід дослідити пошук рішення за допомогою returnоператора pythons, якщо вам потрібно багато даних для передачі до якоїсь зовнішньої структури. Це здається мені більш чітким / пітонічним. Розширені винятки сильно використовуються в Java, що іноді може дратувати, коли використовує рамки і потрібно вловлювати всі можливі помилки.

Вам слід замінити __repr__або __unicode__методи замість того, щоб використовувати повідомлення, аргументи, які ви надаєте під час створення винятку, будуть в argsатрибуті об'єкта виключення.

Ні, "повідомлення" не заборонено. Це просто застаріло. Ваша програма буде добре працювати з використанням повідомлення. Але, можливо, ви захочете позбутися помилки депресації, звичайно.

Коли ви створюєте власні класи винятків для вашої програми, багато з них не підкласи просто з винятку, а з інших, наприклад ValueError або подібних. Тоді вам доведеться адаптуватися до їх використання змінних.

І якщо у вашій програмі є багато винятків, зазвичай є хорошою ідеєю створити загальний для кожного з них базовий клас, щоб користувачі ваших модулів могли робити

try:
    ...
except NelsonsExceptions:
    ...

І в цьому випадку ви можете зробити це __init__ and __str__ необхідне там, тому вам не доведеться повторювати це за кожним винятком. Але просто виклик змінної повідомлення чимось іншим, ніж повідомлення, робить свою справу.

У будь-якому випадку, вам потрібно лише, __init__ or __str__якщо ви зробите щось інше, ніж те, що робить сам виняток. А тому що якщо депресія, то вам потрібно обоє, або ви отримаєте помилку. Це ще не багато зайвого коду, який вам потрібен для кожного класу. ;)

Дивіться дуже гарну статтю " Остаточний посібник з винятків Python ". Основні принципи:

• Завжди успадковуйте (принаймні) Виняток.
• Завжди дзвоніть BaseException.__init__лише з одним аргументом.
• Створюючи бібліотеку, визначте базовий клас, успадкований від Exception.
• Надайте детальну інформацію про помилку.
• Наслідуйте вбудовані типи винятків, коли це має сенс.

Також є інформація про впорядкування (у модулях) та обгортання винятків, рекомендую прочитати посібник.

Спробуйте цей приклад

class InvalidInputError(Exception):
    def __init__(self, msg):
        self.msg = msg
    def __str__(self):
        return repr(self.msg)

inp = int(input("Enter a number between 1 to 10:"))
try:
    if type(inp) != int or inp not in list(range(1,11)):
        raise InvalidInputError
except InvalidInputError:
    print("Invalid input entered")

Щоб правильно визначити власні винятки, є кілька найкращих практик, яких потрібно дотримуватися:

• Визначте базовий клас, який успадковується від Exception. Це дозволить знайти будь-які винятки, пов'язані з проектом (більш конкретні винятки повинні успадковувати його):

  class MyProjectError(Exception):
      """A base class for MyProject exceptions."""

  Організувати ці класи виключень в окремий модуль (наприклад exceptions.py), як правило, хороша ідея.

• Щоб передати додаткові аргументи (аргументи) до вашого винятку, визначте власний __init__()метод із змінною кількістю аргументів. Викличте базовий клас, __init__()передавши йому будь-які позиційні аргументи (пам’ятайте, що BaseException/Exception очікуйте будь-яку кількість позиційних аргументів ):

  class CustomError(MyProjectError):
      def __init__(self, *args, **kwargs):
          super(CustomError, self).__init__(*args)
          self.foo = kwargs.get('foo')

  Щоб підняти такий виняток за допомогою додаткового аргументу, ви можете використовувати:

  raise CustomError('Something bad happened', foo='foo')

  Ця конструкція фактично дотримується до принципу заміщення Лісков , так як ви можете замінити екземпляр базового класу винятків з екземпляром похідного класу винятку.