Comparing Exception Objects in Python

Question

I am new at Python and I'm stuck at this problem. I am trying to compare two "exception objects", example:

try:
    0/0
except Exception as e:
    print e
>> integer division or modulo by zero

try:
    0/0
except Exception as e2:
    print e2
>> integer division or modulo by zero

e == e2
>> False

e is e2
>> False

How should I perform this comparison to obtain a "True"?

What I am trying to do:

class foo():
    def bar(self, oldError = None):
        try:
            return urllib2.urlopen(someString).read()                   
        except urllib2.HTTPError as e:
            if e.code == 400: 
               if e != oldError: print 'Error one'
            else: 
               if e != oldError: print "Error two"
            raise
         except urllib2.URLError as e:
             if e != oldError: print 'Error three'
             raise

class someclass():        
    # at some point this is called as a thread
    def ThreadLoop(self, stopThreadEvent):
        oldError = None
        while not stopThreadEvent.isSet():
            try:
                a = foo().bar(oldError = oldError)
            except Exception as e:
                oldError = e
            stopThreadEvent.wait(3.0)

(probably some syntax error)

Why I am doing that? Because I don't want to print the same error twice

What are you actually trying to do here? I have given an answer, but I imagine there is a better way to go about this. — Gareth Latty
– Gareth Latty, Commented Apr 5, 2013 at 21:49
I updated the question, your answer was perfect to my (generic) original question, but unfortunately it will not work on my problem (if I have two exceptions of the same type, but different attributes, I need a "true" for equality comparison) — Pedro
– Pedro, Commented Apr 5, 2013 at 22:30
Sorry I'm rephrasing: e1 == e2 -> e1.attributes == e2.attributes AND e1.type == e2.type, e1 != e2 -> e1.attributes != e2.attributes OR e1.type != e2.type [not python, just generic code] — Pedro
– Pedro, Commented Apr 5, 2013 at 22:44
That's the opposite of what you stated. In which case, you want @nneonneo's answer. — Gareth Latty
– Gareth Latty, Commented Apr 5, 2013 at 22:46

nneonneo · Accepted Answer · 2013-04-05 22:02:21Z

31

With most exception classes, you can test for functional equality with

type(e) is type(e2) and e.args == e2.args

This tests that their classes are exactly identical, and that they contain the same exception arguments. This may not work for exception classes that don't use args, but to my knowledge, all standard exceptions do.

edited Apr 5, 2013 at 22:02

answered Apr 5, 2013 at 21:53

nneonneo

181k37 gold badges331 silver badges412 bronze badges

Sign up to request clarification or add additional context in comments.

11 Comments

Chris Krycho Over a year ago

I think this is slightly better than Lattyware's answer for the simple reason that this one actually tells you if the exceptions have equivalent arguments, which is not the same as whether they're both instances of the same class. You might have two exceptions of the same class that were raised with different arguments; this gives you more "equivalency" in that regard. My only comment is the same as @Lattyware's below: type() is better than __class__.

Gareth Latty Over a year ago

As a note, I really dislike the use of e.__class__ here - type() exists for a reason, and if you want the type of an object, it's the way to access it.

nneonneo Over a year ago

@Lattyware: OK, I will use type. Thanks for the tip.

Gareth Latty Over a year ago

@ChrisKrycho It entirely depends on what the OP wants - I can't think of a situation where you would want to do this, so I don't know if the OP wants equivalency to that level. The OP really needs to explain more about what he wants before anyone could say which answer is preferable.

nneonneo Over a year ago

@Lattyware: What about wanting to test whether two KeyErrors refer to the same missing key? Or whether two IOErrors are actually the same errno? (Yes, there are class-specific ways to do the check, but using .args gives you a nice generic way to do it).

|

Gareth Latty · Accepted Answer · 2013-04-05 21:48:26Z

7

You want to check the type of the exception:

>>> isinstance(e2, type(e))
True

Note, naturally, this will allow for subclasses - this is a weird thing to do, so I'm not sure what behaviour you are looking for.

answered Apr 5, 2013 at 21:48

Gareth Latty

89.5k18 gold badges183 silver badges187 bronze badges

1 Comment

Wesley Baugh Over a year ago

FWIW, autopep8 converts type(e) is type(e2) to isinstance(e, type(e2)). It's still probably worth adding another assert with e.args == e2.args though.

Les Grieve · Accepted Answer · 2019-08-13 13:04:30Z

0

In this case, comparing the exception message using str() would be useful.

...
        except urllib2.HTTPError as e:
            if e.code == 400: 
                if isinstance(oldError, type(e)) and str(e) != str(oldError): 
                    print 'Error one'
            else: 
                if isinstance(oldError, type(e)) and str(e) != str(oldError): 
                    print "Error two"
            raise
         except urllib2.URLError as e:
             if isinstance(oldError, type(e)) and str(e) != str(oldError): 
                 print 'Error three'
             raise
...

answered Aug 13, 2019 at 13:04

Les Grieve

83810 silver badges11 bronze badges

Collectives™ on Stack Overflow

Comparing Exception Objects in Python

3 Answers 3

11 Comments

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

11 Comments

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related