Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
26 views

Python-Exception-Handling and Try Block

Exception handling in Python uses try, except, else, and finally blocks. try blocks contain code that may raise exceptions, except blocks handle specific exceptions, else blocks run if no exceptions occur, and finally blocks always run for cleanup. Exceptions can be raised manually with raise or conditionally with assert. Exceptions are matched by class, so a parent class handler will catch child class exceptions. Care must be taken to properly scope exception handling and not catch too broad or too narrow of exceptions.

Uploaded by

MK JAYANTHI KANNAN
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
26 views

Python-Exception-Handling and Try Block

Exception handling in Python uses try, except, else, and finally blocks. try blocks contain code that may raise exceptions, except blocks handle specific exceptions, else blocks run if no exceptions occur, and finally blocks always run for cleanup. Exceptions can be raised manually with raise or conditionally with assert. Exceptions are matched by class, so a parent class handler will catch child class exceptions. Care must be taken to properly scope exception handling and not catch too broad or too narrow of exceptions.

Uploaded by

MK JAYANTHI KANNAN
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 21

Exception Handling

and try Block

By
Dr. MK Jayanthi Kannan, B.E.,M.E.,MS.,MBA.,M.Phil., Ph.D.,
Professor School of Computing Science and Engineering,
AB 104, 8.30am- 5.pm
VIT Bhopal University, Bhopal-Indore Highway,
Kothrikalan, Madhya Pradesh - 466114.
email: jayanthi.m@vitbhopal.ac.in, Emp Id : 100600
Ph: +91 6379397594
Exceptions
 Exceptions are events that can modify the flow or
control through a program.
 They are automatically triggered on errors.
 try/except : catch and recover from raised by you or
Python exceptions
 try/finally: perform cleanup actions whether
exceptions occur or not
 raise: trigger an exception manually in your code
 assert: conditionally trigger an exception in your
code
Exception Roles
 Error handling
 Wherever Python detects an error it raises exceptions

 Default behavior: stops program.

 Otherwise, code try to catch and recover from the


exception (try handler)
 Event notification
 Can signal a valid condition (for example, in search)

 Special-case handling
 Handles unusual situations

 Termination actions
 Guarantees the required closing-time operators (try/finally)

 Unusual control-flows
 A sort of high-level “goto”
Example
try/except/else
try:
<block of statements> #main code to run
except <name1>: #handler for exception
<block of statements>
except <name2>,<data>: #handler for exception
<block of statements>
except (<name3>,<name4>): #handler for exception
<block of statements>
except: #handler for exception
<block of statements>
else: # optional, runs if no exception occurs
<block of statements>
Example
>>>try:
action()
except NameError(): …
except IndexError(): …
except KeyError(): …
except (AttributeError,TypeError,SyntaxError):…
else: ….
 General catch-all clause: add empty except.

 It may catch unrelated to your code system


exceptions.
 It may catch exceptions meant for other handler
(system exit)
try/else
 else is used to verify if no exception occurred
in try.
 You can always eliminate else by moving its
logic at the end of the try block.
 However, if “else statement” triggers
exceptions, it would be misclassified as
exception in try block.
try/finally

 In try/finally, finally block is always run whether an


exception occurs or not

try:
<block of statements>
finally:
<block of statements>

 Ensure some actions to be done in any case


 It can not be used in the try with except and else.
Examples
raise
 raise triggers exceptions explicitly
raise <name>
raise <name>,<data> # provide data to handler
raise #re-raise last exception
>>>try:
raise „zero‟, (3,0)
except „zero‟: print “zero argument”
except „zero‟, data: print data
 Last form may be useful if you want to propagate
cought exception to another handler.
 Exception name: built-in name, string, user-defined
class
Example
assert
 assert is a conditional raise
assert <test>, <data>
assert <test>
 If <test> evaluates to false, Python raises
AssertionError with the <data> as the exception‟s
extra data.
Exception Objects
 String-based exceptions are any string object

 Class-based exceptions are identified with classes.


They also identify categories of exceptions.
 String exceptions are matched by object identity: is
 Class exceptions are matched by superclass identity:
except catches instances of the mentioned class and
instances of all its subclasses lower in the class tree.
Class Exception Example
>>>class General: pass
>>>class Specific1(General): pass
>>>class Specific2(General): pass
>>>def raiser0():
X = General() # raise superclass instance
raise X
>>>def raiser1():
raise Specific1 # raise subclass instance
>>>def raiser2():
X = Specific2() # raise different subclass instance
raise X
>>>for func in (raiser0, raiser1, raiser2):
try: func()
except General:
import sys; print 'caught:', sys.exc_type
Built-in Exception Classes
 Exception – top-level root superclass of exceptions.
 StandardError – the superclass of all built-in error
exceptions.
 ArithmeticError – the superclass of all numeric
errors.
 OverflowError – a subclass that identifies a specific
numeric error.

>>>import exceptions
>>>help(exceptions)
Nesting Exception Handlers

 Once the exception is caught, it‟s life is over.

 finally does not kill exception – just specify code to be


run on the way out.
Exception Idioms
 All errors are exceptions, but not all exceptions are
errors. It could be signals or warnings (warnings
module)
>>>while True:
try: line=raw_input()
except EOFError: break
else: # process next line
 Functions signal conditions with raise (to distinguish
success or failure)
 Debugging with outer try statement

try:
… # run program
except: import sys; print sys.exc_type,sys.exc_value
Exception Design Tips
 Operations that commonly fail are generally wrapped
in try statements(file opens, socket calls).
 However, you may want failures of such operations to
kill your program instead of being caught and ignored
if the failure is a show-stopper. Failure = useful error
message.
 Implement termination in try/finally to guarantee its
execution.
 It is sometimes convenient to wrap the call to a large
function in a single try statement rather than putting
many try statements inside of the function.
Do not Catch Too Much
 Do not catch too much (system exits, memory errors,
programming mistakes, iteration stops.)
import sys
def bye(): sys.exit(40)
try: bye()
except: print “got it”
print “continue”

Mydictionary={…}
try: x=Myditctionary[„ok‟]
except: x=None #KeyError
#continue
 Be specific in your handlers: empty except are handy, but
potentially error-prone.
Do not Catch Too Little
 Do not use too specific handlers: you will need to
add new exceptions to exception list in future.
 Instead, careful use of class-based exception can
help here.
>>>try: …
except(myer1,myer2): …
else …
>>>try:…
except SuccessCategoryName: …
else: …
By
Dr. MK Jayanthi Kannan, B.E.,M.E.,MS.,MBA.,M.Phil., Ph.D.,
Professor School of Computing Science and Engineering,
AB 104, 8.30am- 5.pm
VIT Bhopal University, Bhopal-Indore Highway,
Kothrikalan, Madhya Pradesh - 466114.
, Emp Id : 100600
Ph: +91 6379397594

You might also like