Apa cara yang tepat untuk mendeklarasikan kelas pengecualian khusus dalam Python modern? Tujuan utama saya adalah mengikuti standar apa pun yang dimiliki kelas pengecualian lain, sehingga (misalnya) string tambahan apa pun yang saya sertakan dalam pengecualian dicetak oleh alat apa pun yang menangkap pengecualian.

Dengan "Python modern" Maksud saya sesuatu yang akan berjalan dalam Python 2.5 tetapi menjadi 'benar' untuk Python 2.6 dan Python 3. * cara melakukan sesuatu. Dan dengan "kebiasaan" yang saya maksud adalah objek Pengecualian yang dapat menyertakan data tambahan tentang penyebab kesalahan: string, mungkin juga beberapa objek arbitrer lain yang relevan dengan pengecualian.

Saya tersandung oleh peringatan penghentian berikut di 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

Tampaknya gila yang BaseExceptionmemiliki makna khusus untuk atribut yang dinamai message. Saya kumpulkan dari PEP-352 bahwa atribut memang memiliki arti khusus dalam 2.5 yang mereka coba hilangkan, jadi saya kira nama itu (dan itu saja) sekarang dilarang? Ugh.

Saya juga tidak sadar yang Exceptionmemiliki beberapa parameter ajaib args, tetapi saya tidak pernah tahu cara menggunakannya. Saya juga tidak yakin itu cara yang tepat untuk melakukan berbagai hal ke depan; banyak diskusi yang saya temukan online menyarankan mereka mencoba untuk menghilangkan args dengan Python 3.

Pembaruan: dua jawaban telah menyarankan penggantian __init__, dan __str__/ __unicode__/ __repr__. Sepertinya banyak mengetik, apakah perlu?

Mungkin saya melewatkan pertanyaan itu, tetapi mengapa tidak:

class MyException(Exception):
    pass

Edit: untuk mengganti sesuatu (atau memberikan argumen tambahan), lakukan ini:

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

Dengan begitu Anda bisa mengirimkan dikt dari pesan kesalahan ke param kedua, dan sampai nanti dengan e.errors

Pembaruan Python 3: Dalam Python 3+, Anda dapat menggunakan penggunaan yang sedikit lebih ringkas dari 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

Dengan Pengecualian Python modern, Anda tidak perlu penyalahgunaan .message, atau menimpa .__str__()atau .__repr__()atau apapun itu. Jika semua yang Anda inginkan adalah pesan informatif ketika pengecualian Anda muncul, lakukan ini:

class MyException(Exception):
    pass

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

Itu akan memberikan traceback yang diakhiri dengan MyException: My hovercraft is full of eels.

Jika Anda menginginkan lebih banyak fleksibilitas dari pengecualian, Anda bisa meneruskan kamus sebagai argumen:

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

Namun, untuk mendapatkan rincian itu dalam sebuah exceptblok sedikit lebih rumit. Rinciannya disimpan dalam argsatribut, yang merupakan daftar. Anda perlu melakukan sesuatu seperti ini:

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

Masih dimungkinkan untuk mengirimkan beberapa item ke pengecualian dan mengaksesnya melalui indeks tuple, tetapi ini sangat tidak disarankan (dan bahkan dimaksudkan untuk penghentian beberapa waktu yang lalu). Jika Anda membutuhkan lebih dari satu informasi dan metode di atas tidak cukup untuk Anda, maka Anda harus subkelas Exceptionseperti yang dijelaskan dalam tutorial .

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

"Cara yang tepat untuk mendeklarasikan pengecualian khusus dengan Python modern?"

Ini baik-baik saja, kecuali pengecualian Anda benar-benar jenis pengecualian yang lebih spesifik:

class MyException(Exception):
    pass

Atau lebih baik (mungkin sempurna), daripada passmemberikan docstring:

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

Subkelas Pengecualian Subkelas

Dari dokumen

Exception

Semua pengecualian built-in, non-sistem keluar dari kelas ini. Semua pengecualian yang ditentukan pengguna juga harus diturunkan dari kelas ini.

Itu berarti bahwa jika pengecualian Anda adalah jenis pengecualian yang lebih spesifik, subkelas pengecualian itu daripada generik Exception(dan hasilnya adalah Anda masih berasal dari Exceptionseperti yang direkomendasikan oleh dokumen). Juga, Anda setidaknya dapat memberikan dokumen (dan tidak dipaksa untuk menggunakanpass kata kunci):

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

Tetapkan atribut yang Anda buat sendiri dengan kustom __init__. Hindari melewatkan dikt sebagai argumen posisional, pengguna masa depan kode Anda akan berterima kasih. Jika Anda menggunakan atribut pesan yang tidak digunakan lagi, menetapkannya sendiri akan menghindari 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) 

Benar-benar tidak perlu menulis sendiri __str__atau__repr__ . Yang builtin sangat bagus, dan warisan koperasi Anda memastikan bahwa Anda menggunakannya.

Kritik atas jawaban teratas

Mungkin saya melewatkan pertanyaan itu, tetapi mengapa tidak:

class MyException(Exception):
    pass

Sekali lagi, masalah dengan hal di atas adalah bahwa untuk menangkapnya, Anda harus menyebutkannya secara khusus (mengimpornya jika dibuat di tempat lain) atau menangkap Pengecualian, (tetapi Anda mungkin tidak siap untuk menangani semua jenis Pengecualian, dan Anda seharusnya hanya menangkap pengecualian yang siap Anda tangani). Kritik serupa dengan yang di bawah ini, tetapi juga bukan cara untuk menginisialisasi melalui super, dan Anda akan mendapatkan DeprecationWarningjika Anda mengakses atribut pesan:

Edit: untuk mengganti sesuatu (atau memberikan argumen tambahan), lakukan ini:

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

Dengan begitu Anda bisa mengirimkan dikt dari pesan kesalahan ke param kedua, dan sampai nanti dengan e.errors

Ini juga membutuhkan tepat dua argumen untuk diteruskan (selain dari self .) Tidak lebih, tidak kurang. Itu adalah kendala yang menarik yang mungkin tidak dihargai oleh pengguna di masa depan.

Untuk menjadi langsung - itu melanggar substitusi Liskov .

Saya akan menunjukkan kedua kesalahan:

>>> 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'

Dibandingkan dengan:

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

lihat bagaimana pengecualian berfungsi secara default jika satu vs lebih banyak atribut digunakan (tracebacks dihilangkan):

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

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

jadi Anda mungkin ingin memiliki semacam " template pengecualian ", yang berfungsi sebagai pengecualian itu sendiri, dengan cara yang kompatibel:

>>> 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')

ini dapat dilakukan dengan mudah dengan subkelas ini

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

dan jika Anda tidak menyukai representasi standar seperti tuple, cukup tambahkan __str__metode ke ExceptionTemplatekelas, seperti:

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

dan kamu akan punya

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

Pada Python 3.8 (2018, https://docs.python.org/dev/whatsnew/3.8.html ), metode yang disarankan masih:

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

Tolong jangan lupa untuk mendokumentasikan, mengapa pengecualian khusus diperlukan?

Jika perlu, inilah cara untuk pengecualian dengan lebih banyak data:

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

dan ambil mereka seperti:

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=NonePenting untuk membuatnya menjadi acar. Sebelum membuangnya, Anda harus menelepon error.__reduce__(). Memuat akan berfungsi seperti yang diharapkan.

Anda mungkin harus menyelidiki dalam menemukan solusi menggunakan returnpernyataan ular sanca jika Anda memerlukan banyak data untuk ditransfer ke beberapa struktur luar. Ini tampaknya lebih jelas / lebih pythonic bagi saya. Pengecualian tingkat lanjut banyak digunakan di Jawa, yang kadang-kadang bisa menjengkelkan, saat menggunakan kerangka kerja dan harus menangkap semua kemungkinan kesalahan.

Anda harus mengganti __repr__atau __unicode__metode alih-alih menggunakan pesan, argumen yang Anda berikan saat Anda membuat pengecualian akan berada dalam argsatribut objek pengecualian.

Tidak, "pesan" tidak dilarang. Itu sudah usang. Aplikasi Anda akan berfungsi dengan baik dengan menggunakan pesan. Tapi Anda mungkin ingin menyingkirkan kesalahan penghinaan, tentu saja.

Saat Anda membuat kelas pengecualian khusus untuk aplikasi Anda, banyak dari mereka tidak subkelas hanya dari pengecualian, tetapi dari yang lain, seperti ValueError atau serupa. Maka Anda harus beradaptasi dengan penggunaan variabel mereka.

Dan jika Anda memiliki banyak pengecualian dalam aplikasi Anda, biasanya ide yang baik untuk memiliki kelas dasar kustom umum untuk semuanya, sehingga pengguna modul Anda dapat melakukan

try:
    ...
except NelsonsExceptions:
    ...

Dan dalam hal ini Anda dapat melakukan __init__ and __str__ dibutuhkan di sana, sehingga Anda tidak perlu mengulanginya untuk setiap pengecualian. Tetapi hanya memanggil variabel pesan itu sesuatu yang lain dari pada pesanlah yang berhasil.

Bagaimanapun, Anda hanya perlu __init__ or __str__jika Anda melakukan sesuatu yang berbeda dari apa yang dilakukan oleh Pengecualian itu sendiri. Dan karena jika penghentian, Anda kemudian membutuhkan keduanya, atau Anda mendapatkan kesalahan. Itu tidak banyak kode tambahan yang Anda butuhkan per kelas. ;)

Lihat artikel yang sangat bagus " Panduan definitif untuk pengecualian Python ". Prinsip dasarnya adalah:

• Selalu mewarisi dari (setidaknya) Pengecualian.
• Selalu panggil BaseException.__init__dengan hanya satu argumen.
• Saat membangun perpustakaan, tentukan kelas dasar yang mewarisi dari Pengecualian.
• Berikan detail tentang kesalahan.
• Mewarisi dari builtin pengecualian ketika masuk akal.

Ada juga informasi tentang pengorganisasian (dalam modul) dan pengecualian pembungkus, saya sarankan untuk membaca panduan ini.

Coba Contoh ini

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")

Untuk menetapkan pengecualian Anda dengan benar, ada beberapa praktik terbaik yang perlu Anda ikuti:

• Tentukan kelas dasar yang diwarisi dari Exception. Ini akan memungkinkan untuk menangkap pengecualian yang terkait dengan proyek (pengecualian yang lebih spesifik harus diwarisi darinya):

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

  Mengatur kelas pengecualian ini dalam modul terpisah (mis. exceptions.py) Umumnya merupakan ide yang bagus.

• Untuk membuat pengecualian khusus, subkelas kelas pengecualian dasar.

• Untuk menambahkan dukungan untuk argumen tambahan ke pengecualian khusus, tentukan __init__()metode kustom dengan sejumlah variabel argumen. Panggil kelas dasar __init__(), serahkan argumen posisi apa pun ke sana (ingat bahwa BaseException/Exception harapkan sejumlah argumen posisional ):

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

  Untuk mengajukan pengecualian dengan argumen tambahan, Anda dapat menggunakan:

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

Desain ini mematuhi prinsip substitusi Liskov , karena Anda dapat mengganti instance kelas pengecualian dasar dengan instance kelas pengecualian turunan. Juga, ini memungkinkan Anda untuk membuat turunan dari kelas turunan dengan parameter yang sama dengan induknya.