Python error and exception concepts

Python Error and Exception Concepts (General)

1. How to handle errors and exceptions

1. Common Errors

2. a: NameError

3. if True: SyntaxError

4. f = oepn('1.txt'): IOError

5. 10/0: ZeropisionError

6. a = int('d'): ValueError

7. Program Running interruption: KeyboardInterrupt

2.Python-use try_except to handle exceptions (1)

try:
    try_suite
except Exception [e]:
    exception_block

1. try is used to capture errors in try_suite, and Handle the error to except

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

# case 1
try:
    undef
except:
    print 'catch an except'

# case 2
try:
    if undef
except:
    print 'catch an except'

• case1: The exception can be caught because it is a runtime error

• case2: The exception cannot be caught because it is a syntax error and a pre-run 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

• case3: The exception can be caught because the catch NameError exception is set

• case4: The exception cannot be caught because Setting IOError will not handle NameError

Example

import random

num = random.randint(0, 100)

while True:
    try:
        guess = int(raw_input("Enter 1~100"))
    except ValueError, e:
        print "Enter 1~100"
        continue
    if guess > num:
        print "guess Bigger:", guess
    elif guess < num:
        print "guess Smaller:", guess
    elif guess == num:
        print "Guess OK,Game Over"
        break
    print &#39;\n&#39;

3. Python uses try_except to handle exceptions (2)

• try -except: handle multiple exceptions

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

4. Python-try_finally uses

try:
    try_suite
finally:
    do_finally

• If the try statement does not catch the error, the code executes the do_finally statement

• If the try statement catches an error, the program first executes the do_finally statement, and then hands the captured error to the python interpreter for processing

5. Python -try-except-else-finally

 try:
    try_suite
 except:
    do_except
 finally:
    do_finally

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

• If try catches the exception, first executes except to handle the error, and then executes finally

6. Python-with_as statement

with context [as var]:
    with_suite

• with statement is used to replace try_except_finall statement to make the code more concise

• The context expression returns an object

• var is used to save the context return object, a single return value or a tuple

• with_suite uses var variables to operate on the context return object

The essence of the with statement is context management:

1. Context management protocol: Contains methods __enter__() and __exit()__. Objects that support this protocol must implement these two methods

2. Context manager: defines the runtime context to be established when executing the with statement, and is responsible for executing the entry and exit operations in the context of the with statement block

3. Enter the context manager: call Manager __enter__ method, if the as var statement is set, the var variable accepts __enter__() method return value

4. Exit the context manager: call Manager__exit__Method

class Mycontex(object):
    def __init__(self, name):
        self.name = name

    def __enter__(self):
        print "__enter__"
        return self

    def do_self(self):
        print "do_self"

    def __exit__(self, exc_type, exc_val, exc_tb):
        print "__exit__"
        print "Error:", exc_type, " info:", exc_val


if __name__ == "__main__":
    with Mycontex('test context') as f:
        print f.name
        f.do_self()

whith statement application scenario:

1. File operation

2. Mutual exclusion objects between process threads, such as mutex locks

3. Other objects that support context

2. Standard exceptions and Automatically with exception

1. Python-assert and raise statements

• rais statement

• reise statement is used Actively throw exceptions

• Syntax format: raise[exception[,args]]

• exception: exception class

• args: Tuple describing exception information

raise TypeError, 'Test Error'

raise IOError, 'File Not Exit'

• assert statement

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

• Syntax format: assert expression[,args]

• experession: expression

• args: description information of the judgment condition

assert 0, 'test assert'

assert 4==5, 'test assert'

2. Python-Standard Exceptions and custom exceptions

• Standard exceptions

• Python built-in exceptions already exist before the program is executed

• 

• Custom exceptions:

• Python allows custom exceptions, Used to describe exceptions not involved in python

• Custom exceptions must inherit the Exception class

• Custom exceptions can only be actively triggered

class CustomError(Exception):
    def __init__(self, info):
        Exception.__init__(self)
        self.message = info
        print id(self)

    def __str__(self):
        return 'CustionError:%s' % self.message


try:
    raise CustomError('test CustomError')
except CustomError, e:
    print 'ErrorInfo:%d,%s' % (id(e), e)

For more articles related to Python errors and exception concepts, please pay attention to the PHP Chinese website!