Hope to continue to update through the blog park, share and record the basic knowledge of Python to the advanced application of the dots drop!
Third Wave: 8th Chapter Anomaly
[Overview] Learn how to create and raise custom exceptions, and the various ways to handle exceptions.
In order to be able to handle exception events, conditional statements can be used wherever such events may occur, but this may not only be inefficient and inflexible, but it will also make the program difficult to read. Python's exception objects provide a very powerful alternative solution.
[8.1] What is an exception
Python uses exception objects (exception object) to represent exception conditions. An exception is thrown when an error is encountered. If the exception object is not handled or captured, the program terminates execution with the so-called backtracking (Traceback, an error message).
In fact, each exception is an instance of some class that can be thrown, and can be captured in several ways, so that the program can catch the error and handle it, rather than having the entire program fail.
[8.2] make mistakes in your own way
Exceptions can be raised automatically when something goes wrong. Learn how to throw an exception---or even create your own exception type.
[8.2.1] Raise statement
To throw an exception, you can call the raise statement using either a class (which should be a subclass of exception) or an instance parameter. No program automatically creates an instance when you use a class. Use the built-in exception exception class as follows:
Raise Exception
Raise Exception (' hyperdrive overload ')
The first example raise exception throws a generic exception with no information about the error, and in the latter case, some hyperdive overload error messages are added.
There are many built-in exception classes, and built-in exceptions can be found in the exception module. Use the Dir function to list the contents of the module:
Import exception
Dir (Exception)
All of these exceptions can be used in the Raise statement:
Raise Arithmeticerror
Table 8-1 Some of the built-in exceptions
Class Name Description
Exception base class for all exceptions
Attributeerror attribute reference or assignment fails when a value is raised
IOError thrown when attempting to open a file that does not exist
Indexerror thrown when using an index that does not exist in the sequence
Keyerror thrown when using a key that does not exist in the map
Nameerror thrown when a name (variable) is not found
SyntaxError thrown when the code is in the wrong form
TypeError thrown when a built-in operation or function is applied to an object of the wrong type
ValueError is thrown when a built-in operation or function is applied to an object of the correct type, but the object uses an inappropriate value.
Zerodivisionerror The second argument of a division or modulo operation is 0 o'clock
[8.2.2] Custom Exception class
There are times when you create your own exception classes. So how do you create your own exception class? Just to make sure that you inherit from the exception class (either indirectly or directly, that is, inheriting other built-in exception classes is also possible), writing a custom exception class is basically the following:
Class Somecustomexception (Exception):p
[8.3] Catching exceptions
The most interesting thing about exceptions is that they can be handled (often called trapping or catching exceptions) and can be implemented using try/except.
To catch the exception and make some error handling, as follows:
Try
X=input (' Enter The first number: ')
Y=input (' Enter The second number: ')
Print x/y
Except Zerodivisionerror:
Print "The second number can ' t be zero!"
It seems easier to check the Y value with an if statement, but if you need to add more division to your program, you have to add an if statement for each division. Using try/except, however, requires only one error handler.
If you catch a CI, but want to re-throw it (that is, to pass an exception), you can call raise without parameters.
Class Muffledcalculator:
Muffled=false
Def calc (self,expr):
Try
return eval (expr)
Except Zerodivisionerror:
If self.muffled:
print ' Division by zero ' illegal '
Else
Raise
[8.4] More than one except clause
You can add another except clause after the same try/except statement.
Try
X=input (' Enter The first number: ')
Y=input (' Enter The second number: ')
Print x/y
Except Zerodivisionerror:
Print "The second number can ' t be zero!"
Except TypeError:
Print "That Wan ' t a number, is it?"
It should be noted that exception handling does not confuse the original code, and adding a lot of if statements to check for possible error conditions can make the code quite difficult.
[8.5] capturing two exceptions with one block
If you need to catch more than one type of exception with a block, you can list them as tuples, like this:
Try
X=input (' Enter The first number: ')
Y=input (' Enter The second number: ')
Print x/y
Except (Zerodivisionerror,typeerror,nameerror):
print ' Your number were bogus ... '
Note the parentheses outside the exception object in the EXCEPT clause are important. Ignoring them is a common mistake.
[8.6] Capturing objects
If you want to access the exception object itself in the EXCEPT clause, you can use two parameters. Note that even if you catch multiple exceptions, you only need to provide a parameter to the EXCEPT clause. This is useful if you want to keep the program running, but for some reason you want to record the error.
Try
X=input (' Enter The first number: ')
Y=input (' Enter The second number: ')
Print x/y
Except (Zerodivisionerror,typeerror), E:
Print E
[8.7] true full capture
If you really want to catch all the exceptions in a piece of code, you can omit all exception classes in the EXCEPT clause:
Try
......
Except
print ' Something wrong happened ... '
It is dangerous to catch all exceptions, because it hides errors that all programmers do not expect to be prepared to handle.
[8.8] Everything is OK
You can give the TRY/EXCEPT statement price ELSE clause as you would for a condition and a looping statement:
Try
print ' A simple task '
Except
print ' What? Something went wrong! '
Else
print ' Ah ... It went as planned! '
[8.9] finally ...
The last is the finally clause, which can be used to clean up after a possible exception, which is used in conjunction with a try clause:
X=none
Try
x=1/0
Finally
print ' Cleaning up ... '
del X
In the preceding code, the finally clause is bound to be executed, regardless of whether an exception occurs in the TRY clause. Because deleting a variable with the DEL statement is a very irresponsible cleanup, the finally clause is useful for closing a file or network socket. You can also combine use of try, except, finally, and else in the same statement.
Try
1/0
Except Nameerror:
print ' Unknown variable '
Else
Print "That went well!"
Finally
Print "Cleaning up ..."
[8.10] Exceptions and functions
Exceptions and functions can work very naturally together. If an exception is thrown inside a function without being processed, it propagates to the place where the function is called. If the exception is not handled there, it will continue to propagate and reach the main program (global scope). If there is no exception handler, the program will abort with the stack trace.
[8.11] Unusual Zen
Exception handling is not very complex. If you know that a piece of code may cause an exception, and you do not want the program to be terminated as a stack trace, you can add try/except or try/finally statements for processing as long as you want.
[8.12] Summary
Exception object: exception condition can be represented by an exception object.
Warning: warnings are similar to exceptions, but generally only print error messages.
Throw Exception: You can throw an exception using the Raise statement. It accepts an exception class or an exception instance as a parameter, and can provide two parameters (exception and error information).
Custom Exception classes: You can create your own exception classes by inheriting the methods of the exception class.
catch Exception: use the except clause of the TRY statement to catch the exception. Exceptions can be placed in tuples to implement multiple exception sets. If the except is given two parameters, the 2nd parameter is bound to the exception object. Similarly, you can include multiple except clauses in a try/except statement to handle different exceptions separately.
ELSE clause: If no exception is thrown in the main try block, the ELSE clause is executed.
finally: If you need to make sure that some code executes regardless of whether or not an exception is thrown, the code can be prevented in the finally clause.
Exceptions and functions: When an exception is thrown within a function, it is propagated to the place where the function is called.
Basic Python Tutorial "reading notes"-2016/7/5