Core Python Programming (2nd Edition)

try:
... float(['float() does not', 'like lists', 2])
... except TypeError, diag:# capture diagnostic info
... pass
...
>>> type(diag)
>>>
>>> print diag
float() argument must be a string or a number
The first thing we did was cause an exception to be raised from within the try statement. Then we
passed cleanly through by ignoring but saving the error information. Calling the type() built-in function,
we were able to confirm that our exception was indeed an instance of the TypeError exception class.
Finally, we displayed the error by calling print with our diagnostic exception argument.
To obtain more information regarding the exception, we can use the special __class__ instance attribute,
which identifies which class an instance was instantiated from. Class objects also have attributes, such
as a documentation string and a string name that further illuminate the error type:
>>> diag # exception instance object
>>> diag.__class__ # exception class object
>>> diag.__class__.__doc__ # exception class documentation string
'Inappropriate argument type.'
>>> diag.__class__.__name__ # exception class name
'TypeError'
As we will discover in Chapter 13Classes and OOP the special instance attribute __class__ exists for all
class instances, and the __doc__ class attribute is available for all classes that define their documentation
strings.
We will now update our safe_float() one more time to include the exception argument, which is passed
from the interpreter from within float()when exceptions are generated. In our last modification to
safe_float(), we merged both the handlers for the ValueError and TypeError exceptions into one
because we had to satisfy some requirement. The problem, if any, with this solution is that no clue is
given as to which exception was raised or what caused the error. The only thing returned is an error
string that indicated some form of invalid argument. Now that we have the exception argument, this no
longer has to be the case.
Because each exception will generate its own exception argument, if we chose to return this string
rather than a generic one we made up, it would provide a better clue as to the source of the problem. In
the following code snippet, we replace our single error string with the string representation of the
exception argument.
def safe_float(object):
try:
retval = float(object)
except (ValueError, TypeError), diag:
retval = str(diag)