Python Learning note __8 error, debug, and test __8.1 error handling

# This is a learning note for the Liaoche teacher Python tutorial

1. Overview

When we run a program or write a function, the system returns an error message after an error occurs. We can make the error message clearer by some mechanism.

1.1. Try

The format of the try mechanism is try...except...finally.

Try: # try: Run this code, if the code is wrong, execute except

Print (' Try ... ')

r = 10/0

Print (' Result: ', R)

except Zerodivisionerror as E: # except: captures the specified error type and assigns a value to the variable e . except can have multiple

Print (' except: ', E)

finally: # When the try or except finishes executing, the finally

Print (' finally ... ')

Attention:

Python's errors are also class, and all of the error types inherit from baseexception , so in use except It is important to note that it not only captures this type of error, but also "clean sweep" its subclasses . For example:

Try:
Foo ()
exceptValueError ase:
Print (' ValueError ')
exceptUnicodeerror ase:
Print (' Unicodeerror ')

second except unicodeerror Span style= "Font-size:12px;color: #DD0055; background: #FAFAFA" >unicodeerror is ValueError except was captured.

1.2. Call stack

$ Python3 err.py

Traceback (most recent):

File "err.py", line one, in <module>

Main ()

File "err.py", line 9, in main

Bar (' 0 ')

File "err.py", line 6, in bar

return foo (s) * 2

File "err.py", line 3, in Foo

return 10/int (s)

Zerodivisionerror:division by Zero

The call stack is the error message returned by the system itself. Look at the call stack, from the top down. The last three lines indicate the source of the error

1.3. Error recording

If you do not catch an error, you can have the Python interpreter print out the error stack, but the program is finished.

We can also catch the error, print out the error stack, and then analyze the cause of the error and let the program continue.

Python's built-in logging module makes it very easy to log error messages.

Import logging

def foo (s):

return 10/int (s) # source of Errors

def bar (s):

return foo (s) * 2

def main ():

Try

Bar (' 0 ') # Main ( ) calls bar()andBar () calls foo ().

Except Exception as E:

logging.exception (e)

Main ()

Print (' END ')

Because there are logging.exception (e). After the. py file is executed. will continue to print out "END"

1.4. Throw Errors

The error is class, and capturing an error is capturing an instance of the class . Therefore, the error is not generated in a vacuum, but intentionally created and thrown . The thrown error can be defined either as a python built-in function or as defined by our own

1 , the first type throws:

# err_raise.py

Class Fooerror (ValueError): # defines an error class

Pass

def foo (s):

n = Int (s)

If n==0:

Raise Fooerror (' Invalid value:%s '% s) # throws its own defined error class

Return 10/n

foo (' 0 ') # calling Functions

2, the second kind throws:

# err_reraise.py

def foo (s):

n = Int (s)

If n==0:

raise ValueError (' Invalid value:%s '% s) # throws valueerror error

Return 10/n

def bar ():

Try

Foo (' 0 ')

except ValueError as E:  # Catch Error

Print (' valueerror! ')

Raise # Raise throws the current error without parameters. Because foo ()is called, it is thrown to foo ()

Bar () # calling Functions

valueerror! # except after catching the error Print

Traceback (most recent):   # throws an error as it is, in the form of a protocol stack

File "<stdin>", line 1, in <module>

File "<stdin>", line 3, in bar

File "<stdin>", line 4, in Foo

valueerror:invalid value:0 # foo () throws a catch error

1.5. Incorrect conversion

Raise an error in except to convert one type of mistake to another type

Try

10/0

Except Zerodivisionerror:

Raise ValueError (' Input error! ')

Python Learning note __8 error, debug, and test __8.1 error handling