The difference between python exceptions and errors

Error and exception concepts

Error:

1. Syntax error: The code does not conform to Interpreter or compiler syntax

2. Logic error: Incomplete or illegal input or calculation problem

Exception: Thousands of objects occur during execution, causing the program to fail to execute

1. The program encounters logic or algorithm problems

2. Computer errors during operation (insufficient memory or IO errors)

The difference between errors and exceptions

Error:

Syntax or logic errors before the code is run,

Syntax errors must be modified before execution, logic errors cannot be modified

Exceptions are divided into two steps:

1. Exception occurs, an error is detected and the interpreter thinks it is an exception, and an exception is thrown;

2. Exception handling, intercepts the exception, ignores or terminates the program to handle the exception

Common Errors in Python

Common Errors: under ipython

1. a: NameError

Directly referencing a variable when a variable is not defined

2. if True : SyntaxError

      Syntax error

3. f = open('1.txt') : IOError

       When trying to open a file that does not exist

4. 10/0 : ZeroDivisionError

5. a = int('dd') : ValueError

Error encountered when performing forced type conversion

try- -except exception handling (1)

try-except: exception handling

try:
    try_suite
except Exception [， e]:
    exception_block

1.try is used to capture errors in try_suite and hand them over to except for handling

2.except is used to handle exceptions. If the exception handling is consistent with setting the captured exception, use exception_block to handle the exception

Example:

try:
    a
except Exception, e:
    print e

try-except captured exception analysis:

Case 1:

try:
    undef
except:
    print 'catch an except'

Case 2:

try:
    if undef
except:
    print 'catch an except'

case 1: The exception can be caught because it is a runtime error

case 2: The exception cannot be caught because it is a syntax error. Run Previous error

Case 3:

try:
    undef
except NameError, e:
    print 'catch an except', e
Case 4：
try:
    undef
except IOError, e:
    print 'catch an except', e

case 3: The exception can be caught because the catch NameError exception is set

case 4: The exception cannot be caught because the IOError is set and will not be handled NameError

try--except exception handling (2)

try-except: handle multiple exceptions

try:
    try_suite
except Exception1 [e]:
    exception_block1
except Exception2 [e]:
    exception_block2
except ExceptionN [e]:
    exception_blockN

try-except--else use

try:
    try_suite
except Exception1 [e]:
    exception_block1
else:
    none_exception

If there is no exception, execute the code in the else statement

try--finally statement

try-finally statement:

try:
    try_suite
finally:
    do_finally

1. If try The statement does not capture the error, and the code executes the do_finally statement

2. If the try statement captures the error, the program first executes the do_finally statement, and then hands the captured error to the python interpreter for processing

try-finally Statement:

Rule: try-finally will execute the finally code regardless of whether an exception is detected

Function: Provide a cleanup mechanism for exception handling events, used to close files or release system resources

try-except-finally usage:

try:
    try_suite
except:
    do_except
finally:
    do_finally

1. If the try statement does not catch the exception, after executing the try code segment, execute finally

2. If the try catches the exception, execute it first except handles the error, and then executes finally

try-except-else-finally use:

try:
    try_suite
except:
    do_except
else:
    do_else
finally:
    do_finally

1. If the try statement does not catch the exception, after executing the try code block, execute the else code block, Finally execute finally

2. If try catches an exception, first execute except to handle the error, and then execute finally

with statement

with statement:

with context [as var]:

with_suite

1.The with statement is used to replace the try-except-finally statement, which makes the code more concise;

2.The context expression returns An object;

3.var is used to save the context return object, a single return value or a tuple;

4.with_suite uses the var variable to operate on the context return object

……

raise and assert

raise statement

raise statement is used to actively throw exceptions

Syntax format: raise [ exception [, args]]

exception: exception class

args: tuple describing exception information

Example:

raise TypeError
raise TypeError, 'Test Error'
raise IOError, 'File Not Exist'

assert statement

Assertion statement: The assert statement is used to check whether the expression is true. If it is false, an AssertionError is raised;

Grammar format: assert expression [, args]

expression: expression

args: Description information of judgment conditions

Example:

assert 7==6
assert 0, 'Test Error'

Python standard and custom exceptions

Standard exceptions: python built-in exceptions, program execution

Custom exceptions have existed before:

1. python allows custom exceptions, which are used to describe abnormal situations not involved in python

2. Custom exceptions must Inherit the Exception class

3. Custom exceptions can only be actively triggered

Custom exception examples:

class FileError(IOError):
    pass
raise FileError, 'Test FileError'
 
class CustomError(Exception):
    def __init__(self, info):
        Exception.__init__(self)
        self.errorinfo = info
    def __str__(self):
        return 'CustomError: %s' % self.errorinfo
try:
    raise CustomError('test CustomError')
except CustomError, e:
    print 'Error Info : %s' % e

Related recommendations: "Python Tutorial"

The above is the detailed content of The difference between python exceptions and errors. For more information, please follow other related articles on the PHP Chinese website!