精华内容
下载资源
问答
  • 在本篇文章里
  • 捕获异常 # 对数字变量使用append操作 a = 123 a.apppend(4) 执行这个程序时,会抛出: AttributeError: 'int' object has no attribute 'apppend' 我们使用try:except语句进行捕获。 # 捕获异常 a = 123 try: ...
  • python异常总结

    2019-03-05 19:31:41
    python异常总结,包括常见的AssertionError、KeyError、TypeError、ValueError等Python异常
  • Python 异常处理的实例详解 与许多面向对象语言一样,Python 具有异常处理,通过使用 try…except 块来实现。 Note: Python v s. Java 的异常处理 Python 使用 try…except 来处理异常,使用 raise 来引发异常。...
  • Python异常处理(基础详解)

    千次阅读 多人点赞 2020-04-06 13:52:05
    本文是python异常的基础知识,欢迎阅读,一起进步 Python专栏请参考:人生苦短-我学python 文章目录一.异常简介二.捕获异常三.异常的传递四.抛出自定义的异常五.模块六.模块制作七.python中的包 一.异常简介 ...

    本文是python异常的基础知识,欢迎阅读,一起进步



    一.异常简介

    在这里插入图片描述

    • 异常是指在语法正确的前提下,程序运行时报错就是异常。
    • 当Python脚本发生异常时我们需要捕获处理它,否则程序会终止执行。
    print ('-----test--1---')
    open('123.txt', 'r')
    print ('-----test--2---')
    
    -----test--1---
    Traceback (most recent call last):
      File "D:/Phython/study/venv/Include/hello.py", line 2, in <module>
        open('123.txt', 'r')
    FileNotFoundError: [Errno 2] No such file or directory: '123.txt'
    
    • Why?-->打开一个不存在的文件123.txt,当找不到123.txt 文件时,就会抛出给我们一个IOError类型的错误,No such file or directory:123.txt (没有123.txt这样的文件或目录)

    二.捕获异常

    • 捕获异常 try…except…
    try:
        print('-----test--1---')
        open('123.txt','r')
        print('-----test--2---')
    except IOError:
        pass
    
    -----test--1---
    
    • 说明:
    • 此程序看不到任何错误,因为用except 捕获到了IOError异常,并添加了处理的方法
    • pass 表示实现了相应的实现,但什么也不做;如果把pass改为print语句,那么就会输出其他信息
      在这里插入图片描述
    • 把可能出现问题的代码,放在try中
    • 把处理异常的代码,放在except中

    • except捕获多个异常
    try:
        print (num)
    except IOError:
        print('产生错误了')
    
    Traceback (most recent call last):
      File "D:/Phython/study/venv/Include/hello.py", line 2, in <module>
        print (num)
    NameError: name 'num' is not defined
    

    上例程序,已经使用except来捕获异常了,为什么还会看到错误的信息提示?

    • except捕获的错误类型是IOError,而此时程序产生的异常为 NameError ,所以except没有生效
    • 正确写法
    try:
        print num
    except NameError:
        print('产生错误了')
    
    产生错误了
    

    • 实际开发中,捕获多个异常的方式,如下:
    #coding=utf-8
    try:
        print('-----test--1---')
        open('123.txt','r') # 如果123.txt文件不存在,那么会产生 IOError 异常
        print('-----test--2---')
        print(num)# 如果num变量没有定义,那么会产生 NameError 异常
    
    except (IOError,NameError): 
        #如果想通过一次except捕获到多个异常可以用一个元组的方式
        print("捕捉到异常")
    
    -----test--1---
    捕捉到异常
    
    • 换个顺序对比一下
    #coding=utf-8
    try:
        print(num)# 如果num变量没有定义,那么会产生 NameError 异常
        print('-----test--1---')
        open('123.txt','r') # 如果123.txt文件不存在,那么会产生 IOError 异常
        print('-----test--2---')
    
    
    except (IOError,NameError): 
        #如果想通过一次except捕获到多个异常可以用一个元组的方式
        print("捕捉到异常")
    
    捕捉到异常
    
    • 注意: 当捕获多个异常时,可以把要捕获的异常的名字,放到except 后,并使用元组的方式仅进行存储

    • 获取异常的信息描述

    在这里插入图片描述

    在这里插入图片描述


    • 捕获所有异常
      在这里插入图片描述
      在这里插入图片描述

    • else
    • 咱们应该对else并不陌生,在if中,它的作用是当条件不满足时执行的实行;同样在try…except…中也是如此,即如果没有捕获到异常,那么就执行else中的事情
    try:
        num = 100
        print(num)
    except NameError as errorMsg:
        print('产生错误了:%s'%errorMsg)
    else:
        print('没有捕获到异常,真高兴')
    
    100
    没有捕获到异常,真高兴
    

    • try…finally…
    • 在程序中,如果一个段代码必须要执行,即无论异常是否产生都要执行,那么此时就需要使用finally。比如文件关闭,释放锁,把数据库连接返还给连接池等。
    import time
    try:
        f = open('test.txt')
        try:
            while True:
                content = f.readline()
                if len(content) == 0:
                    break
                time.sleep(2)
                print(content)
        except:
            #如果在读取文件的过程中,产生了异常,那么就会捕获到
            #比如 按下了 ctrl+c
            print("捕捉到异常")
        finally:
            f.close()
            print('关闭文件')
    except:
        print("没有这个文件")
    
    没有这个文件
    
    • test.txt文件中每一行数据打印,但是我有意在每打印一行之前用time.sleep方法暂停2秒钟。这样做的原因是让程序运行得慢一些。在程序运行的时候,按Ctrl+c中断(取消)程序。
    • 我们可以观察到KeyboardInterrupt异常被触发,程序退出。但是在程序退出之前,finally从句仍然被执行,把文件关闭。

    三.异常的传递

    • try嵌套中
    import time
    try:
        f = open('test.txt')
        try:
            while True:
                content = f.readline()
                if len(content) == 0:
                    break
                time.sleep(2)
                print(content)
        finally:
            f.close()
            print('关闭文件')
    except:
        print("没有这个文件")
    

    • 函数嵌套调用中
    def test1():
        print("----test1-1----")
        print(num)
        print("----test1-2----")
    
    
    def test2():
        print("----test2-1----")
        test1()
        print("----test2-2----")
    
    
    def test3():
        try:
            print("----test3-1----")
            test1()
            print("----test3-2----")
        except Exception as result:
            print("捕获到了异常,信息是:%s" % result)
    
        print("----test3-2----")
    
    
    test3()
    print("------华丽的分割线-----")
    test2()
    
    ----test3-1----
    ----test1-1----
    捕获到了异常,信息是:name 'num' is not defined
    ----test3-2----
    ------华丽的分割线-----
    ----test2-1----
    ----test1-1----
    Traceback (most recent call last):
      File "D:/Phython/study/venv/Include/hello.py", line 26, in <module>
        test2()
      File "D:/Phython/study/venv/Include/hello.py", line 9, in test2
        test1()
      File "D:/Phython/study/venv/Include/hello.py", line 3, in test1
        print(num)
    NameError: name 'num' is not defined
    
    • 总结:
    • ① 如果try嵌套,那么如果里面的try没有捕获到这个异常,那么外面的try会接收到这个异常,然后进行处理,如果外边的try依然没有捕获到,那么再进行传递。
    • ②如果一个异常是在一个函数中产生的,例如函数A---->函数B---->函数C,而异常是在函数C中产生的,那么如果函数C中没有对这个异常进行处理,那么这个异常会传递到函数B中,如果函数B有异常处理那么就会按照函数B的处理方式进行执行;如果函数B也没有异常处理,那么这个异常会继续传递,以此类推。。。如果所有的函数都没有处理,那么此时就会进行异常的默认处理,即通常见到的那样。
    • ③注意观察上图中,当调用test3函数时,在test1函数内部产生了异常,此异常被传递到test3函数中完成了异常处理,而当异常处理完后,并没有返回到函数test1中进行执行,而是在函数test3中继续执行

    四.抛出自定义的异常

    • 你可以用raise语句来引发一个异常。异常/错误对象必须有一个名字,且它们应是Error或Exception类的子类
    • 下面是一个引发异常的例子:
    class ShortInputException(Exception):
        '''自定义的异常类'''
        def __init__(self, length, atleast):
            #super().__init__()
            self.length = length
            self.atleast = atleast
    
    def main():
        try:
            s = input('请输入 --> ')
            if len(s) < 3:
                # raise引发一个你定义的异常
                raise ShortInputException(len(s), 3)
        except ShortInputException as result:#x这个变量被绑定到了错误的实例
            print('ShortInputException: 输入的长度是 %d,长度至少应是 %d'% (result.length, result.atleast))
        else:
            print('没有异常发生.')
    
    main()
    
    • 情况1
    请输入 --> hello
    没有异常发生.
    
    • 情况2
    请输入 --> la
    ShortInputException: 输入的长度是 2,长度至少应是 3
    
    • 注意
    • 以上程序中,关于代码#super().init()的说明
    • 这一行代码,可以调用也可以不调用,建议调用,因为__init__方法往往是用来对创建完的对象进行初始化工作,如果在子类中重写了父类的__init__方法,即意味着父类中的很多初始化工作没有做,这样就不保证程序的稳定了,所以在以后的开发中,如果重写了父类的__init__方法,最好是先调用父类的这个方法,然后再添加自己的功能

    五.模块

    • Python中的模块有过C语言编程经验的朋友都知道在C语言中如果要引用sqrt函数,必须用语句#include <math.h>引入math.h这个头文件,否则是无法正常进行调用的。

    那么在Python中,如果要引用一些其他的函数,该怎么处理呢?

    • 在Python中有一个概念叫做模块(module),这个和C语言中的头文件以及Java中的包很类似,比如在Python中要调用sqrt函数,必须用import关键字引入math这个模块,下面就来了解一下Python中的模块。
    • 说的通俗点模块就好比是工具包,要想使用这个工具包中的工具(就好比函数),就需要导入这个模块

    • import
    • 在Python中用关键字import来引入某个模块,比如要引用模块math,就可以在文件最开始的地方用import math来引入。
    import module1,mudule2...
    
    • 当解释器遇到import语句,如果模块在当前的搜索路径就会被导入。
    • 在调用math模块中的函数时,必须这样引用:
      模块名.函数名
    

    什么必须加上模块名调用呢 ?

    • 因为可能存在这样一种情况:在多个模块中含有相同名称的函数,此时如果只是通过函数名来调用,解释器无法知道到底要调用哪个函数。所以如果像上述这样引入模块的时候,调用函数必须加上模块名。
    import math
    
        #这样会报错
    print sqrt(2)
    
        #这样才能正确输出结果
    print math.sqrt(2)
    
    • 有时候我们只需要用到模块中的某个函数,只需要引入该函数即可,此时可以用下面方法实现:
    from 模块名 import 函数名1,函数名2....
    
    • ①通过这种方式引入的时候,调用函数时只能给出函数名,不能给出模块名,但是当两个模块中含有相同名称函数的时候,后面一次引入会覆盖前一次引入。也就是说假如模块A中有函数function(),在模块B中也有函数function(),如果引入A中的function在先、B中的function在后,那么当调用function函数的时候,是去执行模块B中的function函数。
    • ②如果想一次性引入math中所有的东西,还可以通过from math import *来实现

    • from…import
    • Python的from语句让你从模块中导入一个指定的部分到当前命名空间中
    • 语法如下:
    from modname import name1[, name2[, ... nameN]]
    
    • 例如,要导入模块fib的fibonacci函数,使用如下语句:
    from fib import fibonacci
    
    • 注意:不会把整个fib模块导入到当前的命名空间中,它只会将fib里的fibonacci单个引入

    • from … import *
    • 把一个模块的所有内容全都导入到当前的命名空间也是可行的,只需使用如下声明:
    from modname import *
    
    • 注意:这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

    • as
    import time as tt
    time.sleep(1)
    
    Traceback (most recent call last):
      File "D:/Phython/study/venv/Include/hello.py", line 2, in <module>
        time.sleep(1)
    NameError: name 'time' is not defined
    

    • 定位模块
    • 当你导入一个模块,Python解析器对模块位置的搜索顺序是:
    • ①当前目录
    • ②如果不在当前目录,Python则搜索在shell变量PYTHONPATH下的每个目录。
    • ③如果都找不到,Python会察看默认路径。UNIX下,默认路径一般为/usr/local/lib/python/
    • ④模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录,PYTHONPATH和由安装过程决定的默认目录。

    六.模块制作

    • 定义自己的模块
    • 在Python中,每个Python文件都可以作为一个模块,模块的名字就是文件的名字。
      比如有这样一个文件test.py,在test.py中定义了函数add
    • test.py
    def add(a, b):
        return a + b
    
    • 调用自己定义的模块
    • 那么在其他文件中就可以先import test,然后通过test.add(a,b)来调用了,当然也可以通过from test import add来引入
    • main.py
    import test
    
    result = test.add(11, 22)
    print(result)
    
    • test.py
    def add(a, b):
        return a + b
    
    
    # 用来进行测试
    ret = add(12, 22)
    print('int test.py file,,,,12+22=%d' % ret)
    
    int test.py file,,,,12+22=34
    
    • 如果此时,在其他py文件中引入了此文件的话,想想看,测试的那段代码是否也会执行呢!
    import test
    
    result = test.add(11, 22)
    print(result)
    
    int test.py file,,,,12+22=34
    33
    

    • 模块中的__all__
    • 没有__all__
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
    • 模块中有__all__
      在这里插入图片描述
      在这里插入图片描述
    • 总结: 如果一个文件中有__all__变量,那么也就意味着这个变量中的元素,不会被from xxx import *时导入

    七.python中的包

    • (1)引入包
    • 有2个模块功能有些联系

    在这里插入图片描述

    • 所以将其放到同一个文件夹下

    在这里插入图片描述

    • 使用import 文件.模块 的方式导入

    在这里插入图片描述

    • 使用from 文件夹 import 模块 的方式导入

    在这里插入图片描述

    • 在msg文件夹下创建__init__.py文件

    在这里插入图片描述

    • 在__init__.py文件中写入

    在这里插入图片描述

    • 重新使用from 文件夹 import 模块 的方式导入

    在这里插入图片描述

    • 总结: 包将有联系的模块组织在一起,即放到同一个文件夹下,并且在这个文件夹创建一个名字为__init__.py 文件,那么这个文件夹就称之为包,有效避免模块名称冲突问题,让应用组织结构更加清晰

    • (2)init.py文件有什么用
    __init__.py 控制着包的导入行为
    
    • init.py为空
    • 仅仅是把这个包导入,不会导入包中的模块
    • __ all__
    • 在__init__.py文件中,定义一个__all__变量,它控制着 from 包名 import *时导入的模块
    • 可以在__init__.py文件中编写内容
    • 可以在这个文件中编写语句,当导入时,这些语句就会被执行

    在这里插入图片描述
    在这里插入图片描述


    • 最后小结几个常见异常
    异常解释
    AttributeError当你访问一个对象的属性,但是这个属性并没有在这个对象定义的时候,就会引发 AttributeError
    ImportError在使用 import 导入模块时,如果要导入的模块找不到,或者从模块中导入模块中不存在的内容
    IndexError当你尝试从序列(如列表或元组)中检索索引,但是序列中找不到该索引。此时就会引发 IndexError
    KeyError与 IndexError 类似,当你访问映射(通常是 dict )中不包含的键时,就会引发 KeyError。
    NameError当你引用了变量、模块、类、函数或代码中没有定义的其他名称时,将引发 NameError。
    SyntaxError当代码中有不正确的 Python 语法时,就会引发 SyntaxError。下面的问题是函数定义行末尾缺少一个冒号
    TypeError当你的代码试图对一个无法执行此操作的对象执行某些操作时,例如将字符串添加到整数中,以及一开始的例子使用 append 方法给元组添加元素,这些都会引发 TypeError。
    ValueError当对象的值不正确时就会引发 ValueError。这个和我们前面说的因为索引的值不在序列的范围内,而导致 IndexError 异常类似。

    • The best investment is in yourself
      在这里插入图片描述
    • 2020.04.06 记录辰兮的第49篇博客
    展开全文
  • python异常处理(一)

    千次阅读 2020-12-02 13:41:41
    Python异常处理能力是很强大的,可向用户准确反馈出错信息。在Python中,异常也是对象,可对它进行操作。所有异常都是基类Exception的成员。所有异常都从基类Exception继承,而且都在exceptions模块中定义。Python...

    Python的异常处理能力是很强大的,可向用户准确反馈出错信息。在Python中,异常也是对象,可对它进行操作。所有异常都是基类Exception的成员。所有异常都从基类Exception继承,而且都在exceptions模块中定义。Python自动将所有异常名称放在内建命名空间中,所以程序不必导入exceptions模块即可使用异常。Python用异常对象(exception object)表示异常情况,遇到错误后,会引发异常。如果异常对象并未被处理或捕捉,程序就会用所谓的回溯(Traceback,一种错误信息)终止执行。

    注意:虽然大多数错误会导致异常,但一个异常不一定代表错误,有时候它们只是一个警告,有时候它们可能是一个终止信号,比如退出循环等。

    一.与python异常相关的关键字

    raise:手动抛出/引发异常:raise [exception[,data]

    try/except:捕获异常并处理

    pass:忽略异常

    as:定义异常实例(except IOError as e)

    finally:无论是否出现异常,都执行的代码]

    else:如果try中的语句没有引发异常,则执行else中的语句

    except Exception as error:

    二.python中的异常类型

    1.StandardError类:如果程序上出现逻辑错误, 将引发该异常。StandardError类是所有内敛异常的基类,放置在默认的命名空间中,因此使用IOEroor, EOFError, ImportError等类,不需要导入exception模块。

    StopIteration类:判断循环是否执行到尾部,如果循环到尾部,则抛出该异常。

    GeneratorExit类:是由Generator函数引发的异常,当调用close()时引发该异常。

    Warning类:表示程序中的代码引起的警告。

    三.基本方式:

    1.try:

    语句1

    except  [exception1(,exception2...),[data…]]:

    语句2

    else:

    语句3

    该种异常处理语法的规则是:

    ·   执行try下的语句,如果引发异常,则执行过程会跳到第一个except语句。

    ·   如果第一个except中定义的异常与引发的异常匹配,则执行该except中的语句。

    ·   如果引发的异常不匹配第一个except,则会搜索第二个except,允许编写的except数量没有限制。

    ·   如果所有的except都不匹配,则异常会传递到下一个调用本代码的最高层try代码中。

    ·   如果没有发生异常,则执行else块代码。

    import traceback

    try:

    1/0

    except Exception as err:

    print(err)

    try:

    f = open("file.txt","r")

    except IOError as e:

    print(e)

    try:

    f = open("file.txt","r")

    except Exception as e:

    print(e)

    最后两个的输出是一模一样的---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    2.try:

    语句1

    finally:

    语句2

    该语句的执行规则是:

    ·   执行try下的代码。

    ·   如果发生异常,在该异常传递到下一级try时,执行finally中的代码。

    ·   如果没有发生异常,则执行finally中的代码。

    第二种try语法在无论有没有发生异常都要执行代码的情况下是很有用的。例如我们在python中打开一个文件进行读写操作,我在操作过程中不管是否出现异常,最终都是要把该文件关闭的。这两种形式相互冲突,使用了一种就不允许使用另一种,而功能又各异

    所以,一般情况下,finally里面执行的都是一些清理工作,比如:关闭文件描述符,释放锁等

    注意,finally中,如果出现异常,外部如果没有相应的捕获机制,该异常会层层抛出,直到最顶端,然后解释器停止。一般在外层再加一次try except异常捕获

    三.手动使用raise引发异常

    1.raise [exception[,data]]

    2.在Python中,要想引发异常,最简单的形式就是输入关键字raise,后跟要引发的异常的名称。异常名称标识出具体的类:Python异常是那些类的对象。执行raise语句时,Python会创建指定的异常类的一个对象。raise语句还可指定对异常对象进行初始化的参数。为此,请在异常类的名称后添加一个逗号以及指定的参数(或者由参数构成的一个元组)。

    3.实例:

    try:

    print("开始测试")

    raise IOError

    except IOError:

    print("定义好的错误")

    except:

    print("别的错误")

    展开全文
  • python异常值如何处理_如何处理异常

    千次阅读 2020-07-01 06:55:52
    python异常值如何处理 最近,我与一个朋友进行了讨论,他是一个相对初级但很聪明的软件开发人员。 她问我有关异常处理的问题。 这些问题指出了一种技巧和窍门,肯定有它们的清单。 但是我坚信我们编写软件的方式...

    python异常值如何处理

    最近,我与一个朋友进行了讨论,他是一个相对初级但很聪明的软件开发人员。 她问我有关异常处理的问题。 这些问题指出了一种技巧和窍门,肯定有它们的清单。 但是我坚信我们编写软件的方式背后的背景和动机,因此我决定从这样一个角度写关于异常的想法。
    编程中的异常(使用Java作为故事的舞台)用于通知我们在执行代码期间发生了问题。 异常是类的特殊类别。 使它们与众不同的是,它们扩展了Exception类,而后者又扩展了Throwable类。 作为Throwable的实现,我们可以在必要时“抛出”它们。 那么,如何发生异常? 使用throw语句从JVM或代码段中引发异常类的实例。 那是怎么回事,但是为什么呢?

    我敢肯定,当我们看到异常发生时,我们大多数人都会畏缩,但它们是我们受益的工具。 在引发异常之前,返回了特殊值或错误代码,以使我们知道操作没有成功。 忘记(或不知道)检查此类错误代码,可能会导致我们的应用程序发生不可预测的行为。 所以对

    在我撰写以上内容时,我想到了两件事。 异常是一个不好的事件,因为创建异常时我们知道发生了问题。 异常是一种有用的构造,因为异常可以为我们提供有关发生错误的有价值的信息,并允许我们针对每种情况采取适当的行为。

    试图散布此设计问题的实质: 触发方法/请求执行某项操作,但它可能会失败–我们如何最好地通知调用方它失败了? 我们如何传达有关发生的情况的信息? 我们如何帮助客户决定下一步该怎么做? 使用异常的问题在于我们“放弃了”,而不仅仅是“放弃”。 我们以“爆炸性”的方式来做,我们服务的客户/呼叫者必须处理混乱

    因此,关于异常是我的第一条建议,因为它们是一件坏事,请尽量避免 。 在您所控制的软件部分中,实施难以出错的设计。 您可以使用支持此行为的语言功能。 我相信Java中最常见的异常是NullPointerException,而Optionals可以帮助我们避免它们。 让我们考虑一下我们想要检索具有指定id的雇员:

    public Optional<Employee> tryGetEmployee(String employeeId) {
        return Optional.ofNullable(employeeService.getEmployee(employeeId));
    }

    现在好多了。 但是,除了我们语言的功能之外,我们还可以通过某种方式设计代码,以免发生错误。 如果我们考虑一种只能接收正整数作为输入的方法,则可以设置代码,这样客户端错误地传递无效输入的可能性就很小。 首先,我们创建一个PositiveInteger类:

    public class PositiveInteger {
      private Integer integerValue;
     
      public PositiveInteger(Integer inputValue) {
         if(inputValue <= 0) {
            throw new IllegalArgumentException("PositiveInteger instances can only be created out of positive integers");
         }
        
         this.integerValue = inputValue;
      }
     
      public Integer getIntegerValue() {
         return integerValue;
      }
    }

    然后,对于只能使用正整数作为输入的方法:

    public void setNumberOfWinners(PositiveInteger numberOfWinners) { … }

    这些当然是简单的例子,我确实认为,问题的核心是偶尔出现问题,然后我们必须告知客户发生的情况。 假设我们从外部后端系统检索了一个员工列表,那么事情可能会出错。 如何处理呢?
    我们可以将响应对象设置为GetEmployeesResponse,如下所示:

    public class GetEmployeesResponse {
      private Ok ok;
      private Error error;
    
       …
      class Ok {
        private List<Employee> employeeList;
        ...
      }
    
      class Error {
        private String errorMessage;
        ...
      }
    }

    但是,让我们成为现实主义者,您无法控制代码库的每个部分,也不会更改所有内容。 确实会发生异常,因此,让我们从它们的简要背景信息开始。

    如前所述,Exception类扩展了Throwable类。 所有异常都是异常类的子类。 可以将异常分为已检查和未检查的异常。 这仅表示某些异常(已检查的异常)要求我们在编译时指定在异常发生时应用程序的行为方式。 未检查的异常不要求我们进行编译时间处理。 要创建此类异常,您可以扩展RuntimeException类,该类是Exception的直接子类。 关于已检查与未检查的较旧的常见指导原则是,运行时异常用于表示应用程序通常无法预期或从中恢复的情况,而已检查异常是编写良好的应用程序应从中预期并从中恢复的情况。

    好吧,我主张仅使用运行时异常 。 而且,如果我使用的库具有带检查异常的方法,则我将创建一个包装器方法,将其转换为运行时。 那为什么不检查异常呢? Bob叔叔在他的“ Clean Code”一书中指出, 它们违反了Open / Closed原理 ,因为使用新的throws声明更改签名可能会对调用该方法的程序的许多级别产生影响。

    现在,无论是检查还是未检查,由于异常是一种结构,可让我们洞悉出了什么问题,因此应该对所发生的事情尽可能地具体和丰富 。 因此, 尝试使用标准异常,其他人将更容易理解发生的情况。 看到NullPointerException时,任何人都清楚原因。 如果您自己设置例外,请使其明智且具体。 例如,ValidationException使我知道某个验证失败,AgeValidationException将我指向特定的验证失败。 具体而言,既可以更容易地诊断出发生了什么,又可以根据发生的事情(异常类型)指定不同的行为。 这就是为什么您必须始终首先捕获最具体的异常的原因! 因此,这里出现了另一个常见建议,指示不要抓住“异常”。 这是一个有效的建议,我偶尔不遵循。 在我的api的边界(比如说我的REST服务的端点)中,我总是有通用的catch Exception子句。 我不希望任何意外以及我在代码中无法预测或防止的某些事情可能会向外界揭示事物。

    具有描述性,但也可以根据抽象级别提供例外 。 考虑创建一个异常层次结构,以不同的抽象级别提供语义信息。 如果从程序的较低层引发了异常,例如与数据库相关的异常,则不必向API的调用者提供详细信息。 捕获异常并引发一个更抽象的异常,该异常仅通知调用者其尝试的操作失败。 这似乎与“仅在可能的情况下才捕获”的常见方法背道而驰,但事实并非如此。 只是在这种情况下,我们的“处理”是触发新异常。 在这些情况下,通过将原始异常传递给新异常的构造函数,可以使整个异常历史在抛出之间可用。

    “手柄”一词已被多次使用。 这是什么意思? 当异常在我们熟悉的catch子句中被“捕获”时,被视为已处理。 引发异常时,首先它将在发生异常的代码中搜索异常处理,如果找不到异常,它将进入所包含方法的调用上下文,依此类推,直到找到异常处理程序或程序为止将终止。

    我再次喜欢Bob叔叔的一件好事,就是try-catch-finally块定义了程序中的作用域。 除词汇范围外,我们还应考虑其概念范围,将try块视为事务 。 如果出问题了该怎么办? 我们如何确保使程序保持有效状态? 不要忽略例外! 我猜程序员对许多小时的不满是由无声异常引起的。 捕获并最终阻止是您进行清理的地方。 确保等待,直到掌握了正确处理异常的所有信息为止。 这可以与早起早发的原则联系在一起。 我们提早抛出,因此我们不必进行由于异常而不得不稍后恢复的操作,而为了及时掌握所有信息以正确处理异常,我们不必迟到。 顺便说一句,当您捕获异常时,只有在解决它们时才记录日志,否则单个异常事件会导致日志混乱。 最后,对于异常处理,我个人更喜欢创建一个可以在代码的不同部分中使用的错误处理服务 ,并在日志记录,重新抛出,清理资源等方面采取适当的措施。它集中了我的错误处理行为,避免了代码重复,并帮助我从更高级的角度了解应用程序中如何处理错误。

    现在我们有了足够的上下文,悖论,规则及其例外,我们可以总结一下:

    • 尽量避免例外。 使用语言功能和适当的设计来实现它
    • 使用运行时异常,将方法与检查的异常包装在一起,然后将其转换为运行时
    • 尝试使用标准异常
    • 使您的例外情况具有特定性和描述性
    • 首先捕获最具体的异常
    • 不要赶上异常
    • 但是请在您的API边界上抓住Exception。 完全掌控一切
    • 创建与应用程序的层和功能匹配的异常层次结构
    • 在适当的抽象级别上抛出异常。 逐层移动时,捕获异常并引发更高级别的异常
    • 通过在新的构造函数中提供异常,在重新抛出时传递完整的异常历史记录
    • 将try-catch-finally块视为事务。 当出现问题时,请确保将程序保持在有效状态
    • 在可以处理时捕获异常
    • 永远不要有空的catch子句
    • 处理异常时记录异常
    • 拥有全局异常处理服务,并具有如何处理错误的策略

    就是这样! 继续,要与众不同!

    翻译自: https://www.javacodegeeks.com/2017/12/how-to-deal-with-exceptions.html

    python异常值如何处理

    展开全文
  • 日常开发中,当系统提供的异常类型不能满足开发的需求时,就需要自己创建一个新的异常类来拥有自己的异常。 自定义异常类继承自 Exception 类,可以直接继承,或者间接继承。

    您的“关注”和“点赞”,是信任,是认可,是支持,是动力…

    如意见相佐,可留言。
    本人必将竭尽全力试图做到准确和全面,终其一生进行修改补充更新。

    1 Python 自定义异常类

    日常开发中,当系统提供的异常类型不能满足开发的需求时,就需要自己创建一个新的异常类来拥有自己的异常。

    自定义异常类继承自 Exception 类,可以直接继承,或者间接继承。
    对于异常类的层次结构(或叫异常类的继承关系),请参见博文《Python 异常类的层次结构、或叫继承关系一览无余》

    举例如下所示:

    # 自定义异常类 MyError ,继承普通异常基类 Exception
    class MyError(Exception):
            def __init__(self, value):
                self.value = value
    
            def __str__(self):
                return repr(self.value)
    
    

    2 Python 自定义异常:自定义异常类的使用

    系统自带的异常只要触发会自动抛出,比如 ZeroDivisionError、NameError 等等。

    但用户自定义的异常需要用户自己决定什么时候抛出。可以使用 raise 语句手动抛出自定义的异常。
    对于 raise 语句,请参见博文《Python raise 语句详解》

    再用 try 块捕捉用户手动抛出的异常,except 块处理就 ok 了。

    举例如下所示:

    # 自定义异常类 MyError ,继承普通异常基类 Exception
    class MyError(Exception):
            def __init__(self, value):
                self.value = value
    
            def __str__(self):
                return repr(self.value)
    
    
    try:
        num = input("请输入数字:")
        if not num.isdigit():  # 判断输入的是否是数字
            raise MyError(num)  # 输入的如果不是数字,手动指定抛出异常
    except MyError as e:
        print("MyError:请输入数字。您输入的是:", e.value)
    
    

    运行结果:

    请输入数字:a
    MyError:请输入数字。您输入的是: a
    

    【友情链接】

    微信公众号:码农阿杰

    博客园

    【参考资料】

    Python 官网

    Python 3.8.2 documentation

    展开全文
  • Python异常及处理方法总结

    万次阅读 多人点赞 2018-08-12 00:32:48
    调试Python程序时,经常会报出一些异常异常的原因一方面可能是写程序时由于疏忽或者考虑不全造成了错误,这时就需要根据异常Traceback到出错点,进行分析改正;另一方面,有些异常是不可避免的,但我们可以对异常...
  • 异常值是指样本中的个别值,也称为离群点,其数值明显偏离其余的观测值。常用检测方法3σ原则和箱型图。其中,3σ原则只适用服从正态分布的数据。在3σ原则下,异常值被定义为观察值和平均值的偏差超过3倍标准差的值...
  • Python异常处理

    万次阅读 多人点赞 2019-04-20 21:31:10
    其中try子句中的代码块包含可能出现的语句,而except子句用来不做相应的异常,except子句中的代码块用来处理异常。如果try中的代码块没有出现异常,则继续往下执行异常处理结构后面的代码;如果出现异常并且被except...
  • 我们自定义了一个异常类,叫做CustomerError,继承自BaseException这个Python异常错误类型的基类 然后定义其__init__方法,并用一个变量接受传入的错误信息。 __init__方法里可以什么都不做,用一个pass...
  • 今天小编就为大家分享一篇python实现异常信息堆栈输出到日志文件,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • python 异常类型(比较全)

    千次阅读 多人点赞 2020-02-07 21:44:01
    异常名称 描述 BaseException 所有异常的基类 SystemExit 解释器请求退出 KeyboardInterrupt 用户中断执行(通常是输入^C) Exception 常规错误的基类 ...生成器(generator)发生异常来通知退出 ...Python...
  • python 异常之捕获、处理

    千次阅读 2020-05-11 17:38:57
    Python无法正常处理程序时就会发生一个异常,程序就会停止运行,把异常信息抛出。 如下,当代码执行到除0的时候,0不能当作被除数,这时出现异常,print(‘end’)就不会再执行。 如果发生异常时不结束程序,可以...
  • 主要介绍了python except异常处理之后不退出,解决异常继续执行的实现,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Python异常处理的3个技巧

    千次阅读 2019-09-05 13:55:25
    如果你用 Python 编程,那么你就无法避开异常,因为异常在这门语言里无处不在。打个比方,当你在脚本执行时按 ctrl+c 退出,解释器就会产生一个 KeyboardInterrupt 异常。而 KeyError、 ValueError、 TypeError 等更...
  • python异常打印堆栈

    千次阅读 2020-07-20 19:17:50
    1 python异常打印堆栈 python调试中难免要捕获异常,并捕捉异常信息,使用 print(e) ,无法得到调用堆栈,不利于问题定位,这里列出python的异常打印方法,记住方便后续调试问题。 import traceback def fun(a,b): ...
  • python提供了两个非常重要的功能来处理python程序在运行中出现的异常和错误。你可以使用该功能来调试python程序。 异常处理: 本站Python教程会具体介绍。 断言(Assertions):本站Python教程会具体介绍。 python...
  • Python异常处理机制

    千次阅读 2017-02-28 21:43:21
    Python 异常处理 python提供了两个非常重要的功能来处理python程序在运行中出现的异常和错误。你可以使用该功能来调试python程序。 异常处理 断言(Assertions) python标准异常 异常名称 描述 ...
  • python 异常值检测

    千次阅读 2019-05-07 13:55:23
    python数据清洗-异常点识别与检测 利用图形检测和输出异常值的方法–箱线图法。 箱线图法 箱线图实际就是利用数据的分位数识别其中的异常点,其特征如下图所示: 下四分位数:25%分位点所对应的值(Q1) 中位...
  • 主要介绍了Python 捕获代码中所有异常的方法,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • 一文掌握Pyhton的异常捕获和抛出,包括Python内置异常类型、自定义异常类等。对方不想和你说话并向你抛出了一个异常。 文章目录 异常信息 捕获异常 多重异常处理 抛出异常 内置异常类型 自定义异常类型
  • Python异常处理 -跳过异常继续执行

    万次阅读 多人点赞 2019-02-19 15:01:48
    Python异常处理 -跳过异常继续执行 python一般使用try…except…处理异常 try: #可能会出现异常的代码,放在try下 code1 #如何try内部任意一行代码出现异常,# 直接跳转至except,执行except下代码 code2 except: ...
  • 主要介绍了python中的异常嵌套的相关资料,帮助大家更好的理解和学习python 异常的相关知识,感兴趣的朋友可以了解下
  • Python3 错误和异常Python3 错误和异常没有异常处理机制异常处理器 except代码示例捕获错误类型捕获未知错误完整的异常语法异常具有传递性自定义异常小总结 Python3 错误和异常 没有异常处理机制 当我们敲代码时,总...
  • PyOD - 用于异常值检测的Python工具包(也称为异常检测)
  • # 这里我包装了一个异常值处理的代码,可以随便调用。 def outliers_proc(data, col_name, scale=3): """ 用于清洗异常值,默认用 box_plot(scale=3)进行清洗 :param data: 接收 pandas 数据格式 :param col_...
  • python异常捕获

    千次阅读 2021-09-20 22:23:32
    异常 程序在运行时,如果Python 解释器遇到到一个错误,会停止程序的执行,并且提示一些错误...python异常处理 捕捉异常可以使用try/except语句。 try: 执行的代码 except: 如果try中的语句异常,则提示的信息

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 405,567
精华内容 162,226
关键字:

python异常

python 订阅
友情链接: MSRCR.py.zip