Modern Python'da özel istisna sınıfları bildirmenin doğru yolu nedir? Öncelikli hedefim, diğer istisna sınıflarının standartlarını takip etmek, böylece istisnayı eklediğim herhangi bir ekstra dize istisnayı yakalayan herhangi bir araç tarafından yazdırılmaktır.

"Modern Python" ile Python 2.5'te çalışacak, ancak Python 2.6 ve Python 3 * için 'doğru' olacak bir şeyleri kastediyorum. Ve "custom" demek Hatanın nedeni hakkında fazladan veri içerebilen bir Exception nesnesini kastediyorum: bir string, belki de istisna ile ilgili başka bir keyfi nesne.

Python 2.6.2'de aşağıdaki kullanımdan kaldırma uyarısı ile açıldım:

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

BaseExceptionAdlandırılmış özellikler için özel bir anlamı olan deli gibi görünüyor message. Ben toplamak PEP-352 I (ve yalnız biri o) artık yasak bu ismi tahmin böylece, nitelik onlar uzakta kaldırmayı çalışıyoruz 2.5 özel bir anlama sahip ki? Ugh.

Ayrıca Exceptionbazı sihirli parametrelere sahip olduğunu bilmiyorum args, ama nasıl kullanılacağını hiç bilmiyordum. Ayrıca eminim ki ileriye doğru bir şeyler yapmanın doğru yolu budur; İnternette bulduğum tartışmaların çoğu Python 3'teki argümanlarla uğraşmaya çalıştıklarını ileri sürdü.

Güncelleme: iki cevap geçersiz kılmayı önerdi __init__ve __str__/ __unicode__/ __repr__. Bu çok yazmak gibi görünüyor, gerekli mi?

Belki soruyu kaçırdım, ama neden olmasın:

class MyException(Exception):
    pass

Düzenleme: bir şeyi geçersiz kılmak (veya fazladan değişkenler iletmek) için şunu yapın:

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

Bu şekilde hata mesajlarını dikte etmeyi ikinci parametreye aktarabilir ve daha sonra e.errors

Python 3 Güncellemesi: Python 3 + 'da, bu biraz daha kompakt kullanımı kullanabilirsiniz 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

Modern Python İstisnalar ile, istismar gerekmez .messageveya geçersiz kılma .__str__()veya .__repr__()veya herhangi. İstediğiniz tek şey istisnanız ortaya çıktığında bilgilendirici bir mesajsa, bunu yapın:

class MyException(Exception):
    pass

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

Bu, biten bir iz bırakacaktır MyException: My hovercraft is full of eels.

İstisnadan daha fazla esneklik istiyorsanız, bir sözlüğü argüman olarak iletebilirsiniz:

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

Bununla birlikte, bir exceptblokta bu ayrıntılara ulaşmak biraz daha karmaşıktır. Ayrıntılar argsbir liste olan öznitelikte saklanır . Bunun gibi bir şey yapmanız gerekir:

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

İstisnaya birden fazla öğe aktarmak ve bunlara tuple indeksleri aracılığıyla erişmek hala mümkündür, ancak bu son derece cesaret kırılmıştır (ve bir süre önce kullanımdan kaldırılmak üzere tasarlanmıştır). Tek bir bilgiden daha fazlasına ihtiyacınız varsa ve yukarıdaki yöntem sizin için yeterli değilse Exception, öğreticide açıklandığı gibi alt sınıf yapmalısınız .

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

İnternethaber.com "Modern Python'da özel istisnalar bildirmenin uygun yolu var mı?"

İstisneniz gerçekten daha spesifik bir istisna türü değilse, bu iyidir:

class MyException(Exception):
    pass

Veya daha iyi (belki de mükemmel), passbir doktora vermek yerine :

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

Alt Sınıf İstisna Alt Sınıfları

Gönderen docs

Exception

Tüm yerleşik, sistemden çıkmayan istisnalar bu sınıftan türetilir. Kullanıcı tanımlı tüm istisnalar da bu sınıftan türetilmelidir.

Bunun anlamı şu , eğer istisna bir daha spesifik bir istisna tipi, yerine jenerik bir istisna olduğu alt sınıfıdır Exception(hala kaynaklandığını ve sonuç olacak Exceptiondokümanlar tavsiye gibi). Ayrıca, en azından bir doktora sağlayabilir (ve passanahtar kelimeyi kullanmak zorunda kalmazsınız ):

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

Kendinizi bir özel ile oluşturduğunuz özellikleri ayarlayın __init__. Bir dikteyi konumsal bir argüman olarak iletmekten kaçının, kodunuzun gelecekteki kullanıcıları size teşekkür edecektir. Kullanımdan kaldırılmış ileti özniteliğini kullanırsanız, kendiniz atamanız aşağıdakilerden kaçınacaktır 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) 

Kendinizinkini yazmaya gerek yok __str__ya da __repr__. Yerleşik olanlar çok güzel ve kooperatif mirasınız onu kullanmanızı sağlar.

En iyi cevabın eleştirisi

Belki soruyu kaçırdım, ama neden olmasın:

class MyException(Exception):
    pass

Yine, yukarıdaki sorun, onu yakalamak için, onu özel olarak adlandırmanız (başka bir yerde oluşturulmuşsa içe aktarma) veya İstisna'yı yakalamanız gerekmesidir (ancak muhtemelen her türlü İstisna türünü ele almaya hazır değilseniz, ve yalnızca ele almaya hazır olduğunuz istisnaları yakalamanız gerekir). Aşağıda benzer eleştiri, fakat buna ek olarak en değil yolu üzerinden başlatmak için olduğunu superve bir alırsınız DeprecationWarningileti özelliğini erişmek eğer:

Düzenleme: bir şeyi geçersiz kılmak (veya fazladan değişkenler iletmek) için şunu yapın:

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

Bu şekilde hata mesajlarının diksiyonunu ikinci parametreye aktarabilir ve daha sonra e.errors ile alabilirsiniz.

Ayrıca, tam olarak iki argümanın iletilmesini (. Dışında self) gerektirir Daha fazla, daha az değil. Bu, gelecekteki kullanıcıların takdir edemeyeceği ilginç bir kısıtlamadır.

Doğrudan olmak - Liskov'un ikame edilebilirliğini ihlal ediyor .

Her iki hatayı da göstereceğim:

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

Nazaran:

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

biri varsa istisnalar varsayılan olarak nasıl çalıştığını görmek vs birden fazla özelliğe (tracebacks atlanmıştır) kullanılır:

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

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

bu nedenle , bir istisna olarak çalışan bir tür " istisna şablonu " nu uyumlu bir şekilde kullanmak isteyebilirsiniz :

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

bu, bu alt sınıfla kolayca yapılabilir

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

ve varsayılan grup benzeri gösterimi beğenmediyseniz __str__, ExceptionTemplatesınıfa aşağıdaki gibi bir yöntem ekleyin :

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

ve sahip olacaksın

>>> 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 ) itibarıyla önerilen yöntem hala:

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

Lütfen özel bir istisnanın neden gerekli olduğunu belgelemeyi unutmayın!

Gerekirse, daha fazla veri içeren istisnalara gitmenin yolu budur:

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

ve aşağıdaki gibi getirin:

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=Noneturşu yapabilmesi önemlidir. Boşaltmadan önce aramalısınızerror.__reduce__() . Yükleme beklendiği gibi çalışacaktır.

returnBazı dış yapılara aktarılacak çok fazla veriye ihtiyacınız varsa, pythons deyimini kullanarak bir çözüm bulma konusunda araştırma yapmalısınız . Bu benim için daha açık / pitonik görünüyor. Gelişmiş istisnalar, bir çerçeve kullanırken ve olası tüm hataları yakalamak zorunda kaldığında, bazen rahatsız edici olabilecek Java'da yoğun olarak kullanılır.

İleti kullanmak yerine geçersiz kılmanız __repr__veya __unicode__yöntemleri kullanmanız gerekir ; kural dışı durumu oluştururken sağladığınız argümanlar args, kural dışı durum nesnesinin özelliğinde olur.

Hayır, "mesaj" yasaktır. Sadece reddedildi. Uygulamanız mesaj kullanarak iyi çalışacaktır. Ancak, elbette, kullanımdan kaldırma hatasından kurtulmak isteyebilirsiniz.

Uygulamanız için özel İstisna sınıfları oluşturduğunuzda, birçoğu yalnızca İstisna'dan değil, ValueError veya benzeri başkalarından alt sınıflar oluşturur. O zaman değişkenlerin kullanımına uyum sağlamanız gerekir.

Ve uygulamanızda birçok istisna varsa, hepsi için ortak bir özel taban sınıfına sahip olmak iyi bir fikirdir, böylece modüllerinizin kullanıcıları yapabilir

try:
    ...
except NelsonsExceptions:
    ...

Ve bu durumda __init__ and __str__ gerekli olanı orada yapabilirsiniz, böylece her istisna için tekrarlamanız gerekmez. Ama sadece mesaj değişkeni mesajdan başka bir şey çağırmak hile yapar.

Her durumda, yalnızca __init__ or __str__İstisna'nın kendisinden farklı bir şey yaparsanız gerekir . Ve çünkü kullanımdan çıkarılma durumunda, ikisine de ihtiyacınız vardır veya bir hata alırsınız. Bu, sınıf başına ihtiyacınız olan bir sürü ekstra kod değildir. ;)

Çok iyi bir makaleye bakın " Python istisnaları için kesin kılavuz ". Temel ilkeler:

• Her zaman (en azından) İstisnadan miras alın.
• Her zaman BaseException.__init__sadece bir argümanla arayın .
• Bir kitaplık oluştururken, İstisnadan devralınan bir temel sınıf tanımlayın.
• Hata hakkında ayrıntılı bilgi verin.
• Mantıklı olduğunda yerleşik istisna türlerinden devralın.

Düzenleme (modüllerde) ve istisnalar hakkında bilgi de var, kılavuzu okumanızı tavsiye ederim.

Bu Örneği Deneyin

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

Kendi istisnalarınızı doğru bir şekilde tanımlamak için izlemeniz gereken birkaç en iyi uygulama vardır:

• Kaynağından devralınan bir temel sınıf tanımlayın Exception. Bu, proje ile ilgili herhangi bir istisnayı yakalamaya izin verecektir (daha spesifik istisnalar projeden miras almalıdır):

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

  Bu istisna sınıflarını ayrı bir modülde (örn. exceptions.py) Düzenlemek genellikle iyi bir fikirdir.

• Özel bir istisna oluşturmak için temel istisna sınıfını alt sınıflayın.

• Özel bir özel duruma fazladan bağımsız değişken (ler) desteği eklemek için, __init__()değişken sayıda bağımsız değişken içeren özel bir yöntem tanımlayın . __init__()Herhangi bir konum bağımsız değişkenini aktararak temel sınıfın çağrısını yapın ( herhangi bir sayıda konum bağımsız değişkenini unutmayın BaseException/ Exceptionbekleyin )

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

  Böyle bir istisnayı ekstra bir argümanla yükseltmek için şunları kullanabilirsiniz:

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

Bir temel istisna sınıfının bir örneğini, türetilmiş bir istisna sınıfının bir örneğiyle değiştirebileceğinizden, bu tasarım Liskov ikame ilkesine bağlı kalır . Ayrıca, üst öğe ile aynı parametrelere sahip türetilmiş bir sınıf örneği oluşturmanıza olanak tanır.