A detailed description of Python exception handling

Source: Internet
Author: User
Tags error handling exception handling terminates in python

Once thrown and no systemexit exception is caught, program execution terminates. If an interactive session encounters an Systemexit exception that is not caught, the session terminates.
One, the catch of the exception
There are several ways to catch exceptions:
1: Use try and except statements

The code is as follows Copy Code

Try
Block
Except [Exception,[data ...]]:
Block

Try
Block
Except [Exception,[data ...]]:
Block
Else
Block

The rules for this exception handling syntax are:
• Executes the statement under try, and if an exception is thrown, the execution skips to the first except statement.
• If the exception defined in the first except matches the thrown exception, the statement in the except is executed.
• If the exception that is thrown does not match the first except, the second except is searched, and the number of except allowed to be written is unlimited.
• If all except do not match, the exception is passed to the next top-level try code that calls this code.
• If no exception occurs, the else block code is executed.
Sample code:

The code is as follows Copy Code
Try
f = open ("file.txt", "R")
Except IOError, E:
Print E

The detailed reason for the caught IOError error is placed in Object E, and then the except code block of the exception is run, or you can catch all the exceptions by using the following methods:

The code is as follows Copy Code
Try
A=b
B=c
Except Exception,ex:
Print Exception, ":", ex

What you need to be aware of with the EXCEPT clause is that when multiple except clauses intercept an exception, if there is an inheritance relationship between each exception class, the subclass should be written in the front, otherwise the parent class will intercept the subclass exception directly, and the subclass exception that is placed in the following category will not be executed.

2: Use try and finally

The code is as follows Copy Code
Try
Block
Finally
Block

The execution rules for this statement are:
• Executes the code under try.
• If an exception occurs, the code in finally is executed when the exception is passed to the next try.
• If no exception occurs, execute the code in finally.

The second try syntax is useful for executing code regardless of whether there is an exception, such as when we open a file in Python to read and write, and I end up shutting down the file regardless of whether an exception occurred during the operation.
These two forms conflict with each other, using one that does not permit the use of the other, and different functions.

Second, manual throw throws an exception
In Python, the simplest form to throw an exception is to enter the keyword raise followed by the name of the exception to be thrown. The exception name identifies the specific class: The Python exception is the object of those classes, and when you execute the Raise statement, Python creates an object of the specified exception class, and the raise statement can also specify parameters to initialize the exception object, After the name of the exception class, add a comma and a specified parameter (or a tuple of parameters).
Sample code:

The code is as follows Copy Code
Try
Raise Myerror #自己抛出一个异常
Except Myerror:
print ' A error '

Raise ValueError, ' invalid argument '
The captured content is:

The code is as follows Copy Code
Type = Vauleerror
message = Invalid argument

Third, tracking view exceptions
When an exception occurs, Python can "remember" the exception that is thrown and the current state of the program, and Python maintains the Traceback (tracking) object, which contains information about the function call stack when an exception occurs, and the exception may be raised in a series of nested function calls, when the program calls each function , Python inserts the function name at the beginning of the function call stack, and once the exception is thrown, Python searches for a corresponding exception handler.
If there is no exception handler in the current function, the current function terminates execution, Python searches for the calling function of the current function, and so on, until a matching exception handler is found, or Python arrives at the main program, the process of finding the appropriate exception handler is called "Stack Toss" (Stack unwinding). The interpreter maintains information about the functions in the drop stack on the one hand, and maintains information about functions that have been "tossed" from the stack on the other.

The code is as follows Copy Code
Try
Block
Except
Traceback.print_exc ()

Iv. using the SYS module to backtrack the final exception

The code is as follows Copy Code
Import Sys
Try
Block
Except
Info=sys.exc_info ()
Print info[0], ":", info[1]

Or in the following form:

The code is as follows Copy Code
Import Sys
TP,VAL,TD = Sys.exc_info ()
The return value of the Sys.exc_info () is a tuple, (type, value/message, Traceback)

The type here is the kind of exception, Value/message is the information or parameter of the exception, traceback the object that contains the call stack information, and this method can be seen as covering the traceback.

All of the above is the theoretical knowledge of error handling, next we have to design a own exception handling class, used to record the Exception log, the error log in accordance with the frequency of a file per hour, save to our designated location. The code is as follows:

The code is as follows Copy Code

#coding: Utf-8
#基于python2.6
Import Logging,os,time,traceback
class LOG:
    def __ Init__ (Self,logger):
        self.filehandlername = '
         Self.filehandler = None
        Self.loggername = Logger
        Self.logger = Logging.getlogger (logger)
& nbsp;       Self.logger.setLevel (logging. DEBUG)
        self.formatter = logging. Formatter ("=========================ntime:% (asctime) s nlogger:% (name) s nlevel:% (levelname) s nfile:% (filename) s nfun:% (FuncName) s nlineno:% (Lineno) d nmessage:% (message) s ")

# console
ch = logging. Streamhandler ()
Ch.setlevel (logging. DEBUG)
Ch.setformatter (Self.formatter)
Self.logger.addHandler (CH)

Path = Os.path.abspath (Os.path.dirname (__file__)) + '/log/' +self.loggername+ '/'
print ' Log path= ', path

def SETFH (self):
fname = Time.strftime ("%y%m%d%h")
If Fname!=self.filehandlername:
#移除原来的句柄
If Self.filehandler!=none:
Self.logger.removeHandler (Self.filehandler)
#设置日志文件保存位置
Path = Os.path.abspath (Os.path.dirname (__file__)) + '/log/' +self.loggername+ '/'
Print path
If Os.path.isdir (path) = = False:
Os.makedirs (PATH)
FH = logging. Filehandler (path+fname+ '. Log ')
Fh.setlevel (logging. DEBUG)
Fh.setformatter (Self.formatter)
Self.logger.addHandler (FH)

Self.filehandlername = fname
Self.filehandler = fh
#格式化日志内容
def _fmtinfo (self,msg):
If Len (msg) ==0:
msg = TRACEBACK.FORMAT_EXC ()
Return msg
Else
_tmp = [Msg[0]]
_tmp.append (Traceback.format_exc ())
Return ' N**********n '. Join (_TMP)
#封装方法
def debug (self,*msg):
_info = Self._fmtinfo (msg)
Try
SELF.SETFH ()
Self.logger.debug (_info)
Except
print ' MyLog debug: ' + _info
def error (SELF,*MSG):
_info = Self._fmtinfo (msg)
Try
SELF.SETFH ()
Self.logger.error (_info)
Except
print ' MyLog error: ' + _info
def info (self,*msg):
_info = Self._fmtinfo (msg)
Try
SELF.SETFH ()
Self.logger.error (_info)
Except
print ' MyLog info: ' + _info
Def warning (self,*msg):
_info = Self._fmtinfo (msg)
Try
SELF.SETFH ()
Self.logger.error (_info)
Except
print ' MyLog warning: ' + _info

If __name__== ' __main__ ':
    log = log (' fight ')
    try:
         Print 1/0
    except:
         Log.error () #使用系统自己的错误描述
    try:
        Print 2/0
    except:
        log.error (' mistaken, denominator cannot be 0 ') #使用自己的错误描述

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.