精华内容
下载资源
问答
  • Python错误处理

    2020-07-10 16:38:48
    Python错误处理错误处理调用栈记录错误抛出错误 错误处理 在程序运行的过程中,如果发生了错误,可以事先约定一个错误代码,这样就可以知道是否有错,以及出错的原因,在操作系统的调用中,返回错误码的非常常见。 三种...

    错误处理

    在程序运行的过程中,如果发生了错误,可以事先约定一个错误代码,这样就可以知道是否有错,以及出错的原因,在操作系统的调用中,返回错误码的非常常见。

    三种常见错误:

    1. 语法错误:直接能检查到的错误
    2. 运算类型的错误,在测试过程中,一定要解决掉.
    3. 逻辑错误

    比如打开文件的函数open,成功时返回文件的描述符[就是一个整数],出错时返回-1,但是使用错误码表示是否出错十分不方便,因为函数本身应该返回的正常结果与错误码混淆在一起,所以调用者要使用大量的代码来判断程序是否出错.

    因此,在高级语言通常都内置了一套try…except…finally…错误处理机制,python也不例外.

    语法:

    try:
        #语句块,有可能发生异常语句
        #
    except 异常类型 as e:
        print(e)
        #异常处理
    else:
        #没有发生异常的时候执行此语句块
    finally:
        #无论是否发生异常,都会执行此模块
    
    #try的机制
    try:
        print("try...")
        r = 10/0
        print('result', r)
    except ZeroDivisionError as e:
        print("except:", e)
    finally:
        print("finally...")
    print("END")   
    
    

    当我们认为某些代码可能会出错时,就可以用try来运行这段代码,如果执行出错,则后续代码不会继续执行,而是直接跳转至错误处理代码,即except语句块,执行完except后,如果有finally语句块则执行finally语句块,至此,执行完毕.

    从输入可以看到,当错误发生时,后续语句print(‘result’, r)不会执行,except由于捕获到了ZeroDivisionError,因此被执行,最后finally语句被执行。

    错误应该有很多种类,如果发生了不同类型的错误,应该由不同的except语句块处理,但其实python的错误也是class,所有的错误类型都继承自BaseException,所以在使用except时需要注意的是,它不但捕获该类型的错误,还把其他的子类也一网打尽

    使用try…except捕获错误还有一个巨大的好处,就是可以跨越多层调用。也就是说,我们不必再每个可能出错的地方都去捕获错误,只要在合适的层次去捕获错误就可以了,这样一来,就大大减少了try…except…finally的麻烦。

    错误捕捉的时候需要注意:

    当我们捕捉错误类型的父类的时候,这时候会将它的子类也一网打尽.

    不建议频繁使用:
    1.影响代码的可读性
    2.影响代码性能

    调用栈

    语法:

    import logging
    try:
        #语句块,有可能发生异常语句
        #
    except 异常类型 as e:
        #记录错误信息
        logging.exception(e)
        #异常处理
    else:
        #没有发生异常的时候执行此语句块
    finally:
        #无论是否发生异常,都会执行此模块
    
    自定义错误
    class FooError(Exception):
        pass
    

    如果错误没有捕获,它就会一直向上抛,最后被python解释器捕获,打印一个错误信息,然后程序退出.

    def foo(s):
        return 10/int(s)
    
    def bar(s):
        return foo(s)*2
    
    def main():
        bar('0')
    main()
    

    出错的时候,一定要分析错误的调用栈的信息,这样才能定位错误

    记录错误

    如果不捕获错误,自然可以让python解释器来打印出错误堆栈,但是程序也被结束了,既然我们能捕获错误,就可以把错误堆栈打印出来,然后分析错误的原因,同时让程序继续执行下去。

    python内置的logging模块可以非常容易的记录错误信息:

    import logging
    
    def foo(s)return 10/int(s)
    def bar(s)
    	return foo(s)*2
    
    def mian():
        try:
            bar('0')
        except Exception as e:
            logging.exception(e)
    main()
    print("END")       
    
    

    同样是出错,但是程序打印完信息后会继续执行,并且正常退出

    抛出错误

    因为错误是class,捕获一个错误就是捕获到该class的一个实例,因此,错误并不是凭空产生的,而是有意创建并抛出的,pyhton的内置函数会抛出很多类型的错误,我们自己编写的函数也可以抛出错误。

    如果要抛出错误,首先根据需要,可以定义一个错误的class,选择好继承关系,然后,用raise语句抛出一个错误的实例。

    class  FooError(valueError)pass
    def foo(s):
    	n = int(s)
        if n == 0:
            raise FooError("invalid value :%s"%s)
        return 10/n
    foo('0')
    
    

    只有在必要的时候才定义我们自己的错误类型,如果可以选择python已有的内置的错误类型,尽量使用python内置的错误类型。

    展开全文
  • Python 错误处理

    2020-08-26 13:53:51
    目录断言(Assertions)错误和异常处理语法错误异常异常捕获处理(try/except...else-finally语句)抛出异常try...except Exception as e...Python 提供了两个重要功能来处理 Python 程序中可能出现的错误和异常: 断言

    Python 提供了两个重要功能来处理 Python 程序中可能出现的错误和异常:

    • 断言(Assertions)
    • 异常处理
      assert&exception

    断言(Assertions)

    Python assert(断言) 用于判断一个表达式,在表达式为 false 时触发异常

    断言可以在条件不满足程序运行的情况下直接返回错误,而不必等待程序运行后出现崩溃的情况。
    assert

    • 语法

      assert expression [,arguments
      

      等同于

      if not expression:
        raise AssertionError(arguments)
      

    错误和异常处理

    Python 中有两种错误:

    • 语法错误(Syntax errors)
    • 异常(Exceptions)

    语法错误

    当 Python 代码出现语法错误时,会抛出语法错误。

    >>> Print Hello,world!
      File "<stdin>", line 1
        Print Hello,world!
              ^
    SyntaxError: invalid syntax
    

    异常

    语法正确的情况下,运行时出现的错误叫做异常。

    >>> 10 / 0
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ZeroDivisionError: division by zero
    

    异常捕获处理(try/except…else-finally语句)

    try-except

    • 示例:

      while True:
          try:
              x = int(input("请输入一个数字: "))
              break
          except ValueError:
              print("您输入的不是数字,请再次尝试输入!")
      
    • 同时捕获多个异常

      except (RuntimeError, TypeError, NameError): # except 后面是多个异常组成的一个元组
      pass
      
      # Or
      
      except OSError as err:
          print("OS error: {0}".format(err))
      except ValueError:
          print("Could not convert data to an integer.")
      except:
          print("Unexpected error:", sys.exc_info()[0])
          raise
      
    • 捕获所有异常

      >>> try:
      ...     10 * (1 / 0)
      ... except:
      ...     print(”代码有错误,请检查")
        File "<stdin>", line 4
          print(”代码有错误,请检查")
                         ^
      SyntaxError: invalid character in identifier
      

    抛出异常

    Python 中使用 raise 语句抛出一个指定的异常
    raise

    示例

    x = 10
    if x > 5:
        raise Exception(f'x 不能大于 5, x 的值为: {x}')
    

    try…except Exception as e语句

    Exception 匹配了所有异常,把异常名称赋给了 e。相当于 Java 中的声明了一个异常对象 catch(Exeption e)

    • 示例
      try:
          10 * (1 / 0)
      except Exception as e:
          print(f"代码有异常,异常类型为:{str(e)}")
      
      # 代码有异常,异常类型为:division by zero
      

    传递异常 re-raise Exception

    • 使用场景:

      • 捕捉到了异常,但是又想重新引发它(传递异常)。
      • 只想知道这是否抛出了一个异常,并不想去处理它。
    • 示例

      >>> try:
              raise NameError('HiThere')
          except NameError:
              print('An exception flew by!')
              raise
      
    • 使用单个 raise 语句的原因:

      为了保持异常的完整信息,在捕获异常后再次抛出时不能在 raise 后面加上异常对象,否则异常的 trace 信息就会从此处截断。

    自定义异常

    >>> class MyError(Exception):
            def __init__(self, value):
                self.value = value
            def __str__(self):
                return repr(self.value)
    

    当做文件操作时使用内置的语法范式而不要使用 try/except-finally

    with open("myfile.txt") as f:
        for line in f:
            print(line, end="")
    

    使用 Exception 而不是 BaseException

    通常情况下,当我们再程序中捕获异常时,应该使用 Exception 而不是 BaseException

    Python 的异常结构如下:

    BaseException          # 所有异常的基类
    ├── SystemExit         # 解释器请求退出
    ├── KeyboardInterrupt  # 用户中断执行(通常是输入^C)
    ├── GeneratorExit      # 生成器(generator)发生异常来通知退出
    └── Exception          # 常规异常的基类
    

    可以明显看到, BaseException 在 Python 中属于所有异常的基类Exception 继承了它。

    BaseException 的子类除了包括 Exception,还包括 SystemExitKeyboardInterruptGeneratorExit 三个异常。

    所以,在程序中我们更应该使用 Exception 而不是 BaseException,另外三个异常属于更高级别的异常,合理的做法应该是交给Python的解释器处理

    Python 异常列表

    BaseException  # 所有异常的基类
    ├── SystemExit  # 解释器请求退出
    ├── KeyboardInterrupt  # 用户中断执行(通常是输入^C)
    ├── GeneratorExit  # 生成器(generator)发生异常来通知退出
    └── Exception  # 常规异常的基类
        ├── StopIteration  # 迭代器没有更多的值
        ├── StopAsyncIteration  # 必须通过异步迭代器对象的__anext__()方法引发以停止迭代
        ├── ArithmeticError  # 各种算术错误引发的内置异常的基类
        │   ├── FloatingPointError  # 浮点计算错误
        │   ├── OverflowError  # 数值运算结果太大无法表示
        │   └── ZeroDivisionError  # 除(或取模)零 (所有数据类型)
        ├── AssertionError  # 当assert语句失败时引发
        ├── AttributeError  # 属性引用或赋值失败
        ├── BufferError  # 无法执行与缓冲区相关的操作时引发
        ├── EOFError  # 当input()函数在没有读取任何数据的情况下达到文件结束条件(EOF)时引发
        ├── ImportError  # 导入模块/对象失败
        │   └── ModuleNotFoundError  # 无法找到模块或在在sys.modules中找到None
        ├── LookupError  # 映射或序列上使用的键或索引无效时引发的异常的基类
        │   ├── IndexError  # 序列中没有此索引(index)
        │   └── KeyError  # 映射中没有这个键
        ├── MemoryError  # 内存溢出错误(对于Python 解释器不是致命的)
        ├── NameError  # 未声明/初始化对象 (没有属性)
        │   └── UnboundLocalError  # 访问未初始化的本地变量
        ├── OSError  # 操作系统错误,EnvironmentError,IOError,WindowsError,socket.error,select.error和mmap.error已合并到OSError中,构造函数可能返回子类
        │   ├── BlockingIOError  # 操作将阻塞对象(e.g. socket)设置为非阻塞操作
        │   ├── ChildProcessError  # 在子进程上的操作失败
        │   ├── ConnectionError  # 与连接相关的异常的基类
        │   │   ├── BrokenPipeError  # 另一端关闭时尝试写入管道或试图在已关闭写入的套接字上写入
        │   │   ├── ConnectionAbortedError  # 连接尝试被对等方中止
        │   │   ├── ConnectionRefusedError  # 连接尝试被对等方拒绝
        │   │   └── ConnectionResetError    # 连接由对等方重置
        │   ├── FileExistsError  # 创建已存在的文件或目录
        │   ├── FileNotFoundError  # 请求不存在的文件或目录
        │   ├── InterruptedError  # 系统调用被输入信号中断
        │   ├── IsADirectoryError  # 在目录上请求文件操作(例如 os.remove())
        │   ├── NotADirectoryError  # 在不是目录的事物上请求目录操作(例如 os.listdir())
        │   ├── PermissionError  # 尝试在没有足够访问权限的情况下运行操作
        │   ├── ProcessLookupError  # 给定进程不存在
        │   └── TimeoutError  # 系统函数在系统级别超时
        ├── ReferenceError  # weakref.proxy()函数创建的弱引用试图访问已经垃圾回收了的对象
        ├── RuntimeError  # 在检测到不属于任何其他类别的错误时触发
        │   ├── NotImplementedError  # 在用户定义的基类中,抽象方法要求派生类重写该方法或者正在开发的类指示仍然需要添加实际实现
        │   └── RecursionError  # 解释器检测到超出最大递归深度
        ├── SyntaxError  # Python 语法错误
        │   └── IndentationError  # 缩进错误
        │       └── TabError  # Tab和空格混用
        ├── SystemError  # 解释器发现内部错误
        ├── TypeError  # 操作或函数应用于不适当类型的对象
        └── ValueError  # 操作或函数接收到具有正确类型但值不合适的参数
            ├── UnicodeError  # 发生与Unicode相关的编码或解码错误
            │   ├── UnicodeDecodeError  # Unicode解码错误
            │   ├── UnicodeEncodeError  # Unicode编码错误
            │   └── UnicodeTranslateError  # Unicode转码错误
            └── Warning  # 警告的基类
                ├── DeprecationWarning  # 有关已弃用功能的警告的基类
                ├── PendingDeprecationWarning  # 有关不推荐使用功能的警告的基类
                ├── RuntimeWarning  # 有关可疑的运行时行为的警告的基类
                ├── SyntaxWarning  # 关于可疑语法警告的基类
                ├── UserWarning  # 用户代码生成警告的基类
                ├── FutureWarning  # 有关已弃用功能的警告的基类
                ├── ImportWarning  # 关于模块导入时可能出错的警告的基类
                ├── UnicodeWarning  # 与Unicode相关的警告的基类
                ├── BytesWarning  # 与bytes和bytearray相关的警告的基类
                └── ResourceWarning  # 与资源使用相关的警告的基类。被默认警告过滤器忽略。
    

    参考资料

    展开全文
  • python错误处理

    2020-03-14 11:41:12
    1、错误处理 异常处理 捕捉异常可以使用try/except语句。 try/except语句用来检测try语句块中的错误,从而让except语句捕获异常信息并处理。 如果你不想在异常发生时结束你的程序,只需在try里捕获它。 格式: try :...

    1、错误处理

    异常处理
    捕捉异常可以使用try/except语句。
    try/except语句用来检测try语句块中的错误,从而让except语句捕获异常信息并处理。
    如果你不想在异常发生时结束你的程序,只需在try里捕获它。
    
    格式:
    try :
         语句1
    except 错误代码 as e:
        语句2
    
    except 错误代码 as e:
        语句3
    ......
    except 错误代码 as e:
        语句n
    else:
    
        语句e
    
    # Exception  万能异常处理
    
    try:
        print("1")
       	23233223
    except Exception:
        print("错了")
    
    python 常见的错误:
    
    异常名称    描述
    BaseException    所有异常的基类
    SystemExit    解释器请求退出
    KeyboardInterrupt    用户中断执行(通常是输入^C)
    Exception    常规错误的基类
    StopIteration    迭代器没有更多的值
    GeneratorExit    生成器(generator)发生异常来通知退出
    StandardError    所有的内建标准异常的基类
    ArithmeticError    所有数值计算错误的基类
    FloatingPointError    浮点计算错误
    OverflowError    数值运算超出最大限制
    ZeroDivisionError    除(或取模)(所有数据类型)
    AssertionError    断言语句失败
    AttributeError    对象没有这个属性
    EOFError    没有内建输入,到达EOF 标记
    EnvironmentError    操作系统错误的基类
    IOError    输入/输出操作失败
    OSError    操作系统错误
    WindowsError    系统调用失败
    ImportError    导入模块/对象失败
    LookupError    无效数据查询的基类
    IndexError    序列中没有此索引(index)
    KeyError    映射中没有这个键
    MemoryError    内存溢出错误(对于Python 解释器不是致命的)
    NameError    未声明/初始化对象 (没有属性)
    UnboundLocalError    访问未初始化的本地变量
    ReferenceError    弱引用(Weak reference)试图访问已经垃圾回收了的对象
    RuntimeError    一般的运行时错误
    NotImplementedError    尚未实现的方法
    SyntaxError    Python 语法错误
    IndentationError    缩进错误
    TabError    Tab 和空格混用
    SystemError    一般的解释器系统错误
    TypeError    对类型无效的操作
    ValueError    传入无效的参数
    UnicodeError    Unicode 相关的错误
    UnicodeDecodeError    Unicode 解码时的错误
    UnicodeEncodeError    Unicode 编码时错误
    UnicodeTranslateError    Unicode 转换时错误
    Warning    警告的基类
    DeprecationWarning    关于被弃用的特征的警告
    FutureWarning    关于构造将来语义会有改变的警告
    OverflowWarning    旧的关于自动提升为长整型(long)的警告
    PendingDeprecationWarning    关于特性将会被废弃的警告
    RuntimeWarning    可疑的运行时行为(runtime behavior)的警告
    SyntaxWarning    可疑的语法的警告
    UserWarning    用户代码生成的警告
    
    展开全文
  • python 错误处理

    2017-03-07 11:28:00
    前提:调试python代码时,总是出现各种错误,如何解决? 解决方法: 一、提前写各种情况的逻辑代码,避免错误的产生; 例:a可能的取值为'1', 'x', '2.1' if a.isalpha():  print ("This is an alpha") else:...

    前提:调试python代码时,总是出现各种错误,如何解决?

    解决方法:

    一、提前写各种情况的逻辑代码,避免错误的产生;

    例:a可能的取值为'1', 'x', '2.1'

    if a.isalpha():

      print ("This is an alpha")

    else:

      print (int(a))

    避免的直接用内置函数int()时报错

     

    二、让错误出现,用try...except语句处理异常情况;

    例:try:

        print (int(a))

      except ValueError:

        print ("This is an alpha")

    转载于:https://www.cnblogs.com/heiao10duan/p/6513830.html

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,523
精华内容 4,609
关键字:

python错误处理

python 订阅