By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
457,900 Members | 1,364 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 457,900 IT Pros & Developers. It's quick & easy.

What's new with Gnosis

P: n/a
At the suggestion of one of my correspondents, I slightly reluctantly
implemented an RSS feed for my website/writing. It is perhaps a bit
crude so far, but maybe I'll spiff it up. The RSS also has an HTML
front to it.

If you want to see the latest news about my _Charming Python_ or _XML
Matters_ columns, or about other articles (later, perhaps stuff about
my book), take a look at:


I'm new to this RSS stuff... so let me know (gently) if I've done
anything terribly wrong.

mertz@ _/_/_/_/ THIS MESSAGE WAS BROUGHT TO YOU BY: \_\_\_\_ n o
gnosis _/_/ Postmodern Enterprises \_\_ _/_/ \_\_ d o
Jul 18 '05 #1
Share this Question
Share on Google+
3 Replies

P: n/a
"Raymond Hettinger" <vz******> writes:
ACT I ---------------------------------------
s = list('abc')
try: ... result = s['a']
... except IndexError, TypeError:
... print 'Not found'

Traceback (most recent call last):
File "<pyshell#11>", line 2, in -toplevel-
result = s['a']
TypeError: list indices must be integers
The second 'argument' of except is the caught exception object, so
that code works as if you did

result = s['a']
except IndexError, e:
TypeError = e
print 'Not found'
-- which doesn't catch the TypeError.
ACT II -------------------------------------------- class MyMistake(Exception): ... pass
try: ... raise MyMistake, 'try, try again'
... except MyMistake, msg:
... print type(msg)

<type 'instance'>
Again, the second 'argument' of except gets the exception object, not
the string you used in the raise.

These two are equivalent [XXX er, I *think* they're always equivalent]:

raise SomeError, 'my error message'
raise SomeError('my error message')

The second form is more explicit, hence better.

Exception objects do have a __str__ method, though, so you can print
them as if they were strings:

result = s['a']
except IndexError, e:
print e
because print calls the e.__str__ method to do its work.

ACT III -------------------------------------------- class Prohibited(Exception): ... def __init__(self):
... print 'This class of should never get initialized'
... raise Prohibited() This class of should never get initialized

Traceback (most recent call last):
File "<pyshell#40>", line 1, in -toplevel-
raise Prohibited()
Prohibited: <unprintable instance object> raise Prohibited This class of should never get initialized

Traceback (most recent call last):
File "<pyshell#41>", line 1, in -toplevel-
raise Prohibited
Prohibited: <unprintable instance object>
These are equivalent:

raise Exception
raise Exception()

The second is more explicit, hence better.

Since exception classes always end up getting instantiated whichever
way you write the raise statement, you need to write __init__
correctly if you override it. The Exception base class has an
__init__ that it expects to be called, so you should call it:

[At this point, I had to look up the arguments to Exception.__init__.]

class Prohibited(Exception):
def __init__(self, *args):
Exception.__init__(self, *args)
print 'This class will get initialized'
In this case, the lack of that Exception.__init__ call is what's
causing the "<unprintable instance object>" message, but it could
cause other problems too.

[Actually, with your interactive example, I don't get the
"<unprintable..." bit -- maybe that's in 2.3b2...]
ACT IV ----------------------------------------------- module = 'Root'
try: ... raise module + 'Error'
... except 'LeafError':
... print 'Need leaves'
... except 'RootError':
... print 'Need soil'
... except:
... print 'Not sure what is needed'

Not sure what is needed
A raised string exception only matches the string in the except
statment if both strings are the same object. It's not enough for
them to have the same value. Two different string literals that have
the same value aren't necessarily the same object:

myerror = "myerror"
anothererror = "myerror" # not *necessarily* the same object as myerror
raise myerror
except anothererror:
# we only get here if it so happens that:
assert myerror is anothererror
except myerror:
# we always get here, because:
assert myerror is myerror
ACT V ----------------------------------------------- try:

... raise KeyError('Cannot find key')
... except LookupError, msg:
... print 'Lookup:', msg
... except OverflowError, msg:
... print 'Overflow:', msg
... except KeyError, msg:
... print 'Key:', msg
Lookup: 'Cannot find key'

except statements are checked in the order you write them. Class
instance exceptions are matched as if by

isinstance(raised_exception, caught_exception)

so exceptions can be caught by their base classes. LookupError is a
base class of KeyError, so the first except matches.
Jul 18 '05 #2

P: n/a
John J. Lee wrote:
"Raymond Hettinger" <vz******> writes:
ACT I ---------------------------------------


is it my newsreader going mad, or did you post in the wrong thread ?


Jul 18 '05 #3

P: n/a
Bruno Desthuilliers <bd***********> writes:
John J. Lee wrote:
"Raymond Hettinger" <vz******> writes:
ACT I ---------------------------------------


is it my newsreader going mad, or did you post in the wrong thread ?

I posted in the wrong thread.

Something about Gnus... haven't figured out why I occasionally do that yet.
Jul 18 '05 #4

This discussion thread is closed

Replies have been disabled for this discussion.