| One, the catch of the exception
There are several ways to catch exceptions:
1: Use try and except statements 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:
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:
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 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: Try
Raise Myerror #自己抛出一个异常
Except Myerror:
print ' A error '
Raise ValueError, ' invalid argument 'The captured content is: 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. Try
Block
Except
Traceback.print_exc ()
Iv. using the SYS module to backtrack the final exception
Import Sys
Try
Block
Except
Info=sys.exc_info ()
Print info[0], ":", info[1]
Or in the following form:
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: #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)
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 ') #使用自己的错误描述 |
