1. Exceptions and Errors
There are inevitably errors in the program, and there are two types of errors
1.1.1 Syntax Error
Syntax error: This kind of error can not pass the python interpreter's grammar detection at all and must be corrected before the program is executed.
#Syntax Error Example 1 if #Grammar Error Example 2 def test: pass #Grammatical Error Model Three print(haha
1.1.2 Logical Error
#Incomplete user input(For example, the input is empty)Or the input is illegal(Input is not a number) num=input(">>: ") int(num) #Unable to complete calculation res1=1/0 res2=1+'str'
1.2 What is an exception
Exceptions are signals that errors occur while the program is running. In python, errors trigger exceptions as follows:
Different exceptions in Python can be identified by different types (python unifies classes and types, types are classes), different class objects identify different exceptions, and an exception identifies an error.
1.3.1 exception example
1. Trigger IndexError:
2. Trigger KeyError
3. Trigger ValueError
1.3.2 Common Exceptions
AttributeError attempts to access a tree that an object does not have, such as foo.x, but foo does not have attribute x IOError input/output exception; basically unable to open file ImportError cannot introduce modules or packages; basically a path problem or a name error IndentationError syntax error (subclass); code not aligned correctly IndexError subscript index is out of sequence bounds, such as when x has only three elements and tries to access x KeyError attempts to access keys that do not exist in the dictionary KeyboardInterrupt Ctrl+C is pressed NameError uses a variable that has not been assigned to an object SyntaxError Python code is illegal and cannot be compiled (I personally think this is a syntax error and has been written incorrectly) TypeError incoming object type does not meet requirements UnboundLocalError is trying to access a local variable that has not been set, basically because there is another global variable with the same name. Cause you to think you're accessing it ValueError passes in a value that the caller does not expect, even if the value is of the correct type
1.3.3 More exceptions
ArithmeticError AssertionError AttributeError BaseException BufferError BytesWarning DeprecationWarning EnvironmentError EOFError Exception FloatingPointError FutureWarning GeneratorExit ImportError ImportWarning IndentationError IndexError IOError KeyboardInterrupt KeyError LookupError MemoryError NameError NotImplementedError OSError OverflowError PendingDeprecationWarning ReferenceError RuntimeError RuntimeWarning StandardError StopIteration SyntaxError SyntaxWarning SystemError SystemExit TabError TypeError UnboundLocalError UnicodeDecodeError UnicodeEncodeError UnicodeError UnicodeTranslateError UnicodeWarning UserWarning ValueError Warning ZeroDivisionError
2. Exception handling
After an exception occurs, the code will not execute after the exception, and exception handling is necessary if you want the code to run properly.
2.1 What is exception handling
The python interpreter detects errors and triggers exceptions (which allow programmers to trigger exceptions themselves).
Programmers write specific code specifically designed to catch this exception (this code has nothing to do with program logic, but with exception handling).
If the catch succeeds, it enters another processing branch and executes the logic you customize for it so that the program does not crash, which is exception handling.
2.2 Why exception handling
When the python parser executes a program, it detects an error, triggers an exception, and when the exception is triggered and not handled, the program terminates at the current exception. The code behind it will not run. Who will use a software that runs with a sudden crash?
So you must provide an exception handling mechanism to enhance the robustness and fault tolerance of your program.(
2.3 How to handle exceptions
First of all, exceptions are caused by program errors. Grammatical errors are not related to exception handling and must be corrected before the program runs.
python causes a type for each exception and then provides a specific syntax structure for exception handling.
2.3.1 Basic Grammar
try: Code Block Detected Exceept except ion type: Once an exception is detected in the try, the logic for this location is executed
try: f = open('a.txt') g = (line.strip() for line in f) print(next(g)) print(next(g)) print(next(g)) print(next(g)) print(next(g)) except StopIteration: f.close() ''' next(g)Will trigger iteration f，successively next(g)You can read a line of a file, regardless of the file a.txt How big is it? There is only one line in memory at a time. //Tip: G is based on file handle f, so f.close() can only be executed after next(g) throws an exception StopIteration '''
Exception class intelligence is used to handle specified exceptions, which cannot be handled if no exceptions are specified.
# No exceptions caught, program directly error s1 = 'hello' try: int(s1) except IndexError as e: print e
More than 2.3.2 branches
try: Code Block Detected Exceept except ion type: Once an exception is detected in the try, the logic for this location is executed Exceept except ion type: Once an exception is detected in the try, the logic for this location is executed ... Exceept except ion type: Once an exception is detected in the try, the logic for this location is executed
Code that errs from top to bottom executes the code in that branch and exits the branch directly whenever a branch matches the type of error is found.If you can't find a branch that handles the same type of error, you'll keep going, and if you don't find one, you'll get an error.
s1 = 'hello' try: int(s1) except IndexError as e: print(e) except KeyError as e: print(e) except ValueError as e: print(e)
233,000 omnipotent anomalies
Among python's exceptions, there is one omnipotent exception: Exception, which can catch any exception, that is:
s1 = 'hello' try: int(s1) except Exception as e: print(e)
You might say that since there are omnipotent exceptions, I would just like to use the above form, other exceptions can be ignored.
You're right, but there are two things to look at:
1. If you want the effect that we discard all exceptions, or use the same piece of code logic to process them, then only one Exception is sufficient.
s1 = 'hello' try: int(s1) except Exception,e: 'Discard or execute other logic' print(e) #If you use them all Exception，Yes, you can catch all exceptions, but that means you use the same logic to handle all exceptions (the logic here is the current one) expect Code block following)
2. If you want the effect that we need to customize different processing logic for different exceptions, you need to use more branching.
s1 = 'hello' try: int(s1) except IndexError as e: print(e) except KeyError as e: print(e) except ValueError as e: print(e) except Exception as e: print(e)
2.3.4 Other structures with abnormalities
try: Code Block Detected Exceept except ion type: Once an exception is detected in the try, the logic for this location is executed ... Exceept except ion type: Once an exception is detected in the try, the logic for this location is executed else: Execute code block without exception in try finally: The module executes regardless of whether it is unusual or not, usually for cleanup
s1 = 'hello' try: int(s1) except IndexError as e: print(e) except KeyError as e: print(e) except ValueError as e: print(e) #except Exception as e: # print(e) else: print('try Execute me if there are no exceptions in the inner code block') finally: print('Abnormal or not,Will execute the module,Usually cleaning up')
2.3.5 Active Trigger Abnormality
try: raise TypeError('error in type') except Exception as e: print(e)
2.3.6 Custom Exception
class EvaException(BaseException): def __init__(self,msg): self.msg=msg def __str__(self): return self.msg try: raise EvaException('error in type') except EvaException as e: print(e)
2.4 When to use exception handling
Some students think so, after learning the exception handling, it's so strong that I want to add try...except to each of my programs to think about whether it will have logic errors. That's great.
try...except should be used as little as possible, because it is itself an exception handling logic that you attach to your program and has nothing to do with your main job.
More of this will cause your code to become less readable. try...except should be added only if some exceptions are unpredictable and other logic errors should be corrected as much as possible.
BaseException +-- SystemExit +-- KeyboardInterrupt +-- GeneratorExit +-- Exception +-- StopIteration +-- StandardError | +-- BufferError | +-- ArithmeticError | | +-- FloatingPointError | | +-- OverflowError | | +-- ZeroDivisionError | +-- AssertionError | +-- AttributeError | +-- EnvironmentError | | +-- IOError | | +-- OSError | | +-- WindowsError (Windows) | | +-- VMSError (VMS) | +-- EOFError | +-- ImportError | +-- LookupError | | +-- IndexError | | +-- KeyError | +-- MemoryError | +-- NameError | | +-- UnboundLocalError | +-- ReferenceError | +-- RuntimeError | | +-- NotImplementedError | +-- SyntaxError | | +-- IndentationError | | +-- TabError | +-- SystemError | +-- TypeError | +-- ValueError | +-- UnicodeError | +-- UnicodeDecodeError | +-- UnicodeEncodeError | +-- UnicodeTranslateError +-- Warning +-- DeprecationWarning +-- PendingDeprecationWarning +-- RuntimeWarning +-- SyntaxWarning +-- UserWarning +-- FutureWarning +-- ImportWarning +-- UnicodeWarning +-- BytesWarning