python——day_08:错误和异常

古城微笑少年丶 2023-06-11 14:24 13阅读 0赞

--------------------

title: ‘python——day\_08:错误和异常’  
date: 2019-10-30 22:07:28  
categories:

*  python基础  
    tags:
 *  python基础

--------------------

# ‘python——day\_08:错误和异常’ #

## 错误 ##

*  语法错误或者是解析错误

## 异常 ##

*  运行期检测到的错误被称为异常
 *  大多数的异常都不会被程序处理，都以错误信息的形式展现在命令行
 *  示例：
    
        >>>10 * (1/0)
        Traceback (most recent call last):
         File "<stdin>", line 1, in ?
        ZeroDivisionError: division by zero
        >>> 4 + spam*3
        Traceback (most recent call last):
         File "<stdin>", line 1, in ?
        NameError: name 'spam' is not defined
        >>> '2' + 2
        Traceback (most recent call last):  File "<stdin>", line 1, in ?
        TypeError: Can't convert 'int' object to str implicitly
 *  示例2：
    
        try:
                    x = int(input("Please enter a number: "))
                    break
                except ValueError:
                    print("Oops! That was no valid number. Try again ")
    
    1.  首先，执行try子句（在关键字try和关键字except之间的语句）
    2.  如果没有异常发生，忽略except子句，try子句执行后结束。
    3.  如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。
    4.  如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中
 *  一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。
    
    处理程序将只针对对应的try子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。
    
    一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组
    
        except (RuntimeError, TypeError, NameError):
                pass
 *  try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到的、而except又没有捕获的异常
 *  异常处理并不仅仅处理那些直接发生在try子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常
    
        >>>def this_fails():
                x = 1/0
           
        >>> try:
                this_fails()
            except ZeroDivisionError as err:
                print('Handling run-time error:', err)
           
        Handling run-time error: int division or modulo by zero
 *  raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出
    
        >>>try:
                raise NameError('HiThere')
            except NameError:
                print('An exception flew by!')
                raise
           
        An exception flew by!
        Traceback (most recent call last):
          File "<stdin>", line 2, in ?
        NameError: HiThere
 *  用户自定义异常
    
        >>>class MyError(Exception):
                def __init__(self, value):
                    self.value = value
                def __str__(self):
                    return repr(self.value)
    
    当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类
    
        class Error(Exception):
            """Base class for exceptions in this module."""
            pass
         
        class InputError(Error):
            """Exception raised for errors in the input. Attributes: expression -- input expression in which the error occurred message -- explanation of the error """
         
            def __init__(self, expression, message):
                self.expression = expression
                self.message = message
         
        class TransitionError(Error):
            """Raised when an operation attempts a state transition that's not allowed. Attributes: previous -- state at beginning of transition next -- attempted new state message -- explanation of why the specific transition is not allowed """
         
            def __init__(self, previous, next, message):
                self.previous = previous
                self.next = next
                self.message = message
 *  定时清理行为：不管 try 子句里面有没有发生异常，finally 子句都会执行。
    
    如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后被抛出
    
        >>>def divide(x, y):
                try:
                    result = x / y
                except ZeroDivisionError:
                    print("division by zero!")
                else:
                    print("result is", result)
                finally:
                    print("executing finally clause")
           
        >>> divide(2, 1)
        result is 2.0
        executing finally clause
        >>> divide(2, 0)
        division by zero!
        executing finally clause
        >>> divide("2", "1")
        executing finally clause
        Traceback (most recent call last):
          File "<stdin>", line 1, in ?
          File "<stdin>", line 3, in divide
        TypeError: unsupported operand type(s) for /: 'str' and 'str'