Python exceptions and how to handle instances tutorial

Python Exception Handling

Python provides two very important features to handle the exceptions and errors that appear in the running of Python programs. You can use this feature to debug a python program.

Exception handling: This site Python tutorial will be specifically introduced.
Assertion (Assertions): This site Python tutorial will be specifically introduced.

Python Standard exception

Exception Name Description
Baseexception the base class for all exceptions
Systemexit Interpreter Request Exit
Keyboardinterrupt user interrupts execution (usually input ^c)
Exception base class for general errors
No more values for stopiteration iterators
Generatorexit Generator (generator) has an exception to notify exit
StandardError the base class for all the built-in standard exceptions
Arithmeticerror base class for all numeric calculation errors
Floatingpointerror Floating-point calculation error
Overflowerror numeric operation exceeds maximum limit
Zerodivisionerror except (or modulo) 0 (all data types)
Assertionerror Assertion Statement failed
Attributeerror object does not have this property
Eoferror does not have built-in input, arrives EOF mark
EnvironmentError base class for operating system errors
IOError Input/output operation failed
OSError Operating system error
Windowserror system call failed
Importerror Import Module/object failed
Lookuperror the base class for invalid data queries
This index is not in the Indexerror sequence (index)
This key is not in the Keyerror map
Memoryerror Memory overflow error (not fatal for the Python interpreter)
Nameerror not declared/initialized (no attributes)
Unboundlocalerror access to uninitialized local variables
Referenceerror Weak reference (Weak reference) attempts to access objects that have been garbage collected
RuntimeError General Run-time Errors
Notimplementederror methods that have not yet been implemented
SyntaxError Python Syntax error
Indentationerror Indentation Error
Taberror Tab and Space mix
Systemerror General Interpreter System error
TypeError an operation that is not valid for a type
ValueError passed in invalid parameter
Unicodeerror Unicode-related errors
Error in Unicodedecodeerror Unicode decoding
Error Unicodeencodeerror Unicode encoding
Unicodetranslateerror Unicode Conversion Error
Base class for Warning warnings
Deprecationwarning warning about deprecated features
Futurewarning warning of changes in the construction of future semantics
overflowwarning old warning about automatic promotion to long int
Pendingdeprecationwarning warnings about features that will be discarded
Warning of suspicious run-time behavior (runtime behavior) runtimewarning
Warning of syntaxwarning suspicious syntax
Userwarning user code-generated warnings

What is an exception? An

exception is an event that occurs during program execution and affects the normal execution of the program.

Typically, an exception occurs when Python does not handle the program properly. The

exception is a Python object that represents an error.

When the Python script has an exception, we need to capture it, or the program terminates execution.

Exception handling

You can use the Try/except statement to catch exceptions.

The try/except statement is used to detect errors in a try statement block, allowing the except statement to catch exception information and handle it.

If you don't want to end your program in the event of an anomaly, just capture it in a try.

Grammar:

The following is a simple try....except...else syntax:


Try
< statements > #运行别的代码
Except < name:
< statement > #如果在try部份引发了 ' name ' exception
Except < name >,< data:
< statement > #如果引发了 ' name ' exception to obtain additional data
Else
< statements > #如果没有异常发生





Try works by saying that when a try statement is started, Python marks it in the context of the current program so that it can be returned when the exception appears, the TRY clause executes first, and what happens depends on whether the exception occurs at execution time.

If an exception occurs when a try statement executes, Python jumps back to the try and executes the first except clause that matches the exception, and the control flow passes through the entire try statement (unless a new exception is thrown when the exception is handled).

If an exception occurs in the statement after the try, but there is no matching except clause, the exception is submitted to the upper try, or to the top of the program (This will end the program and print the default error message).

If no exception occurs when the TRY clause executes, Python executes the statement after the Else statement (if there is an else), and then the control flow passes through the entire try statement.

instance

The following is a simple example that opens a file in which content is written and no exception occurs:


#!/usr/bin/python

Try
FH = open ("Testfile", "W")
Fh.write ("This is Me test file for exception handling!!")
Except IOError:
print "error:can\ ' t find file or read data"
Else
Print "Written content in the file successfully"
Fh.close ()



The above program output results:

Written content in the file successfully

Instance

The following is a simple example that opens a file in which content is written to the content, but the file does not have write permission and an exception occurred:


#!/usr/bin/python

Try
FH = open ("Testfile", "W")
Fh.write ("This is Me test file for exception handling!!")
Except IOError:
print "error:can\ ' t find file or read data"
Else
Print "Written content in the file successfully"



The above program output results:

Error:can ' t find file or read data


Use except without any exception types

You can use except without any exception type, as in the following example:


Try
your operations here;
......................
Except
If there is no exception, then execute this block.
......................
Else
If there is no exception then execute this block.



The above method try-except the statement to catch all occurrences of the exception. But this is not a good way, we can not identify the specific exception information through the program. Because it captures all the exceptions.
Using except with multiple exception types

You can also use the same except statement to handle multiple exception information, as follows:


Try
your operations here;
......................
Except (exception1[, exception2[,... Exceptionn]]):
If there is any exception from the given exception list,
Then execute this block.
......................
Else
If there is no exception then execute this block.


try-finally statement

The try-finally statement executes the last code, regardless of whether an exception occurs.

Try
< statements >
Finally
< statements > #退出try时总会执行
Raise

Instance


#!/usr/bin/python

Try
FH = open ("Testfile", "W")
Fh.write ("This is Me test file for exception handling!!")
Finally
print "error:can\ ' t find file or read data"



If the file you open does not have writable permissions, the output looks like this:

Error:can ' t find file or read data

The same example can be written in the following ways:


#!/usr/bin/python

Try
FH = open ("Testfile", "W")
Try
Fh.write ("This is Me test file for exception handling!!")
Finally
Print "Going to close" file
Fh.close ()
Except IOError:
print "error:can\ ' t find file or read data"



When an exception is thrown in a try block, the finally block code is executed immediately.

After all the statements in the finally block are executed, the exception is raised again and the except block code is executed.

The contents of the parameter are different from the exception.
Parameters of the exception

An exception can be taken with parameters and can be used as an exception information parameter for the output.

You can use the except statement to catch the parameters of the exception, as follows:

Try
your operations here;
......................
Except Exceptiontype, Argument:
You can print value of Argument ...



The value of the exception that is received by the volume is usually contained in the statement of the exception. A variable in a tuple's form can receive one or more values.
Tuples usually contain error strings, error numbers, and error locations.

Instance

The following is an instance of a single exception:


#!/usr/bin/python

# Define a function here.
def Temp_convert (Var):
Try
return Int (VAR)
Except ValueError, Argument:
Print "The argument does not contain numbers\n", argument

# Call above function here.
Temp_convert ("xyz");



The results of the above procedures are as follows:

The argument does not contain numbers
Invalid literal for int () with base: ' XYZ '

Triggering an exception

We can use the raise statement to trigger the exception ourselves

The raise syntax format is as follows:

raise [Exception [, Args [, Traceback]]]



The exception in the statement is the type of the exception (for example, the Nameerror) parameter is an exception parameter value. The parameter is optional, and if not provided, the exception is "None".

The last parameter is optional (rarely used in practice) and, if present, is the tracking exception object.
Instance

An exception can be a string, a class, or an object. Most of the exceptions provided by the Python kernel are instantiated classes, which are parameters of an instance of a class.

Defining an exception is very simple, as follows:

def functionname (level):
If level < 1:
Raise "Invalid level!", Level
# The code below to this would is executed
# If we raise the exception

Note: To be able to catch exceptions, the "except" statement must use the same exception to throw the class object or string.

For example, we capture the above exception, and the "except" statement looks like this:

Try
Business Logic here ...
Except "Invalid level!":
Exception Handling here ...
Else
Rest of the code here ...

User-defined exceptions

By creating a new Exception class, the program can name their own exceptions. Exceptions should be typically inherited from exception classes, by direct or indirect means.

The following is an instance related to RuntimeError, in which a class is created and the base class is RuntimeError, which is used to output more information when an exception is triggered.

In a try statement block, a user-defined exception executes the EXCEPT block statement, and the variable e is the instance used to create the Networkerror class.

Class Networkerror (RuntimeError):
def __init__ (self, arg):
Self.args = arg

After you have defined the above class, you can trigger the exception as follows:

Try
Raise Networkerror ("bad hostname")
Except Networkerror,e:
Print E.args