Python Exception Handling Examples

First, what is an anomaly?
An exception is an event that occurs during program execution and affects the normal execution of the program.
In general, an exception occurs when Python does not handle the program properly.
The exception is a Python object that represents an error.
When a Python script exception occurs, we need to capture and process it, or the program terminates execution.
second, exception handling
You can use the Try/except statement to catch an exception.
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 do not want to end your program when an exception occurs, simply capture it in a try.

Exception Syntax:
The following is a simple syntax for try....except...else:
Copy the Code code as follows:

Try
<语句> #运行别的代码
Except <名字> ：
<语句> #如果在try部份引发了 ' Name ' exception
Except <名字> ， <数据> :
<语句> #如果引发了 ' name ' exception to get additional data
Else
<语句> #如果没有异常发生

Try works by starting a try statement, and Python is tagged in the context of the current program so that when an exception occurs, it can go back here, the TRY clause executes first, and what happens next depends on whether an exception occurs at execution time.

If an exception occurs when the statement after the try is executed, 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 will be 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 else), and then the control flow passes through the entire try statement.

Exception Handling Example 1:
Here is a simple example that opens a file where the contents of the file are written and the exception does not occur:
Copy the Code code as follows:

#!/usr/bin/python

Try
FH = open ("Testfile", "W")
Fh.write ("This was my 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:
Copy CodeThe code is as follows:

Written content in the file successfully

Exception Handling Example 2:
Here is a simple example that opens a file where the contents of the file are written, but the file does not have write permission, and an exception occurs:
Copy CodeThe code is as follows:

#!/usr/bin/python

Try
FH = open ("Testfile", "W")
Fh.write ("This was my 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:
Copy CodeThe code is as follows:

Error:can ' t find file or read data

Third, use except without any exception type

You can use except without any exception type, as in the following example:
Copy the Code code as follows:

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

The try-except statement above captures all occurrences of the exception. But this is not a good way to identify specific exception information through the program. Because it catches all the exceptions.
Iv. using except with multiple exception types
You can also use the same except statement to handle multiple exception information, as follows:
Copy CodeThe code is as follows:

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

v. try-finally statements
The try-finally statement executes the final code regardless of whether an exception occurs.
Copy CodeThe code is as follows:

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

Note: You can use the except statement or the finally statement, but both cannot be used at the same time. Else statement cannot be used in conjunction with the finally statement

try-finally Usage Examples:
Copy the Code code as follows:

#!/usr/bin/python

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

If the open file does not have writable permissions, the output is as follows:
Copy CodeThe code is as follows:

Error:can ' t find file or read data

The same example can be written in the following way:
Copy CodeThe code is as follows:

#!/usr/bin/python

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

Executes the finally block code immediately when an exception is thrown in the try block.
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 differ from the exception.

Vi. parameters of the exception
An exception can take a parameter that can be used as the output exception information parameter.
You can use the except statement to catch the parameters of the exception, as follows:
Copy the Code code as follows:

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

The exception value that the variable receives is usually contained in the exception's statement. In a tuple's form, a variable can receive one or more values.
Tuples typically contain error strings, error numbers, and error locations.
The following is an instance of a single exception:
Copy CodeThe code is as follows:

#!/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 program execution are as follows:
Copy CodeThe code is as follows:

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

To trigger an exception using raise:
We can use the raise statement to trigger the exception ourselves

The raise syntax format is as follows:
Copy the Code code as follows:

raise [Exception [, Args [, Traceback]]

The type of exception in the statement is an exception (for example, the Nameerror) parameter is an exception parameter value. This parameter is optional and if not provided, the exception parameter is "None".
The last parameter is optional (rarely used in practice) and, if present, is the tracking exception object.
Raise usage Examples:
An exception can be a string, a class, or an object. The Python kernel provides exceptions, most of which are instantiated classes, which are parameters of an instance of a class.
It is very simple to define an exception as follows:
Copy CodeThe code is as follows:

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

Note: To be able to catch exceptions, the "except" statement must have the same exception to throw the class object or string.
For example, we capture the above exception, and the "except" statement looks like this:
Copy CodeThe code is as follows:

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

VII. user-defined exception instances
By creating a new Exception class, programs can name their own exceptions. Exceptions should be typical of inheriting from the exception class, either directly or indirectly.
The following is an example of a runtimeerror-related instance in which a class is created and the base class is RuntimeError, which is used to output more information when the exception is triggered.
In the TRY statement block, after the user-defined exception executes the EXCEPT block statement, the variable e is used to create an instance of the Networkerror class.
Copy the Code code as follows:

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

After you define the above class, you can trigger the exception as follows:
Copy CodeThe code is as follows:

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

attached: Python standard exception
Baseexceptiona: base class for all exceptions
SYSTEMEXITB python: Interpreter request exit
KEYBOARDINTERRUPTC: User interrupt execution (usually input ^c)
Exceptiond: base class for general errors
Stopiteratione: There are no more values for iterators
Generatorexita: Generator (generator) exception occurred to notify exit
Systemexith:python Interpreter Request Exit
Standarderrorg: base class for all built-in standard exceptions
Arithmeticerrord: base class for all numeric calculations errors
Floatingpointerrord: Floating-point calculation error
Overflowerror: Numeric operation exceeds maximum limit
Zerodivisionerror: Except (or modulo) 0 (all data types)
Assertionerrord: Assertion statement failed
Attributeerror: Object does not have this property
Eoferror: No built-in input, EOF Mark reached
Environmenterrord: base class for operating system errors
IOError: Input/output operation failed
Oserrord: Operating system error
WINDOWSERRORH Windows: System call failed
Importerror: Failed to import module/object
KEYBOARDINTERRUPTF: User interrupt execution (usually input ^c)
Lookuperrord: base class for invalid data queries
Indexerror: This index is not in the sequence (index)
Keyerror: This key is not in the map
Memoryerror: Memory overflow error (not fatal for Python interpreter)
Nameerror: Object not declared/initialized (no attributes)
UNBOUNDLOCALERRORH: Access to uninitialized local variables
Referenceerrore: Weak reference (Weak reference) attempted to access an object that has been garbage collected
RuntimeError: General run-time error
Notimplementederrord: A method that has not been implemented
Syntaxerror:python syntax error
Indentationerrorg: Indentation Error
Taberrorg:tab and Spaces Mixed
Systemerror General Interpreter System error
TypeError: An operation that is not valid for type
ValueError: Invalid parameter passed in
Unicodeerrorh:unicode related errors
Unicodedecodeerrori:unicode decoding Error
Unicodeencodeerrori:unicode encoding Error
Unicodetranslateerrorf:unicode Conversion Error
WARNINGJ: base class for warnings
DEPRECATIONWARNINGJ: Warning about deprecated features
Futurewarningi: A warning that constructs future semantics will change
OVERFLOWWARNINGK: Old warning about auto-promotion to Long integer
Pendingdeprecationwarningi: Warnings about attributes that will be discarded
RUNTIMEWARNINGJ: Warning for suspicious runtime behavior (runtime behavior)
SYNTAXWARNINGJ: Warning of suspicious syntax
USERWARNINGJ: Warning generated by user code

