精华内容
下载资源
问答
  • 主要介绍了通过实例了解Python异常处理机制底层实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 首先,Python 完整的异常处理语法结构如下: try: #业务实现代码 except Exception1 as e: #异常处理块1 ... except Exception2 as e: #异常处理块2 ... #可以有多个 except ... else: #正常处理块 finally :...
  • Python异常处理机制

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

            python提供了两个非常重要的功能来处理python程序在运行中出现的异常和错误。你可以使用该功能来调试python程序。1、异常处理。2、断言(Assertions)

    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无法正常处理程序时就会发生一个异常。

            异常是Python对象,表示一个错误。当Python脚本发生异常时我们需要捕获处理它,否则程序会终止执行。


    Python异常处理

            捕捉异常可以使用try/except语句。try/except语句用来检测try语句块中的错误,从而让except语句捕获异常信息并处理。

    如果你不想在异常发生时结束你的程序,只需在try里捕获它。

    以下为简单的try....except...else的语法:

    try:
    <语句>        #运行别的代码
    except <名字>:
    <语句>        #如果在try部份引发了'name'异常
    except <名字>,<数据>:
    <语句>        #如果引发了'name'异常,获得附加的数据
    else:
    <语句>        #如果没有异常发生

            try的工作原理是,当开始一个try语句后,python就在当前程序的上下文中作标记,这样当异常出现时就可以回到这里,try子句先执行,接下来会发生什么依赖于执行时是否出现异常。

           1、如果当try后的语句执行时发生异常,python就跳回到try并执行第一个匹配该异常的except子句,异常处理完毕,控制流就通过整个try语句(除非在处理异常时又引发新的异常)。

            2、如果在try后的语句里发生了异常,却没有匹配的except子句,异常将被递交到上层的try,或者到程序的最上层(这样将结束程序,并打印缺省的出错信息)。

            3、如果在try子句执行时没有发生异常,python将执行else语句后的语句(如果有else的话),然后控制流通过整个try语句。(注意:是没有异常时才执行else语句)。


    简单实例

    下面是简单的例子,它打开一个文件,在该文件中的内容写入内容:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    try:
        fh = open("testfile", "w")
        fh.write("这是一个测试文件,用于测试异常!!")
    except IOError:
        print("Error: 没有找到文件或读取文件失败");
    else:
        print("内容写入文件成功");
        fh.close()


    捕获所有异常

    可以不带任何异常类型使用except,如下实例:

    try:
        正常的操作
       ......................
    except:
        发生异常,执行这块代码
       ......................
    else:
        如果没有异常执行这块代码

            以上方式try-except语句捕获所有发生的异常。但这不是一个很好的方式,我们不能通过该程序识别出具体的异常信息。因为它捕获所有的异常。


    捕获多种异常类型

    也可以使用相同的except语句来处理多个异常信息,如下所示:

    try:
        正常的操作
       ......................
    except(Exception1[, Exception2[,...ExceptionN]]]):
       发生以上多个异常中的一个,执行这块代码
       ......................
    else:
        如果没有异常执行这块代码


    try-finally 语句

    try-finally 语句无论是否发生异常都将执行最后的代码。

    try:
    <语句>
    finally:
    <语句>    #退出try时总会执行
    raise


    异常的参数

            一个异常可以带上参数,可作为输出的异常信息参数。可以通过except语句来捕获异常的参数,如下所示:

    try:
        正常的操作
       ......................
    except ExceptionType, Argument:
        你可以在这输出 Argument 的值...

            变量接收的异常值通常包含在异常的语句中。在元组的表单中变量可以接收一个或者多个值。元组通常包含错误字符串,错误数字,错误位置。


    触发异常

    我们可以使用raise语句自己触发异常,raise语法格式如下:

    raise [Exception [, args [, traceback]]]

            语句中Exception是异常的类型(例如,NameError)参数是一个异常参数值。该参数是可选的,如果不提供,异常的参数是"None"。最后一个参数是可选的(在实践中很少使用),如果存在,是跟踪异常对象。


    简单实例

            一个异常可以是一个字符串,类或对象。 Python的内核提供的异常,大多数都是实例化的类,这是一个类的实例的参数。定义一个异常非常简单,如下所示:

            注意:为了能够捕获异常,"except"语句必须有用相同的异常来抛出类对象或者字符串。

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    # 定义函数
    def mye( level ):
        if level < 1:
            raise Exception("Invalid level!", level)
            # 触发异常后,后面的代码就不会再执行
    
    try:
        mye(0)                // 触发异常
    except "Invalid level!":
        print 1
    else:
        print 2


    用户自定义异常

            通过创建一个新的异常类,程序可以命名它们自己的异常。异常应该是典型的继承自Exception类,通过直接或间接的方式。以下为与RuntimeError相关的实例,实例中创建了一个类,基类为RuntimeError,用于在异常触发时输出更多的信息。在try语句块中,用户自定义的异常后执行except块语句,变量 e 是用于创建Networkerror类的实例。

    class Networkerror(RuntimeError):
        def __init__(self, arg):
            self.args = arg

    在你定义以上类后,你可以触发该异常,如下所示:

    try:
        raise Networkerror("Bad hostname")
    except Networkerror,e:
        print e.args



    两个特殊的处理异常的方法

    断言(assert)

    assert expression[,reason]  
            其中assert是断言的关键字。执行该语句的时候,先判断表达式expression,如果表达式为真,则什么都不做;如果表达式不为真,则抛出异常。reason跟之前谈到的异常类的实例一样。

    上下文管理(with语句)

            如果你使用try, except, finally代码仅仅是为了保证共享资源(如文件,数据)的唯一分配,并在任务结束后释放它,那么这个with语句可以让你从try, except, finally中解放出来!语法如下:

    with context_expr [as var]:  
        with_suite  

    举个例子: view plain
    >>> with open('/root/test.py') as f:  
    ...     for line in f:  
    ...         print line 

            上面这几行代码干了什么?

            (1)打开文件/root/test.py

            (2)将文件对象赋值给  f

            (3)将文件所有行输出

           (4)无论代码中是否出现异常,Python都会为我们关闭这个文件,我们不需要关心这些细节。

           使用with语句来使用这些共享资源,我们不用担心会因为某种原因而没有释放他。但并不是所有的对象都可以使用with语句,只有支持上下文管理协议(context management protocol)的对象才可以,那哪些对象支持该协议呢?如下表:

            file 

            decimal.Context

            thread.LockType

            threading.Lock

            threading.RLock

            threading.Condition

            threading.Semaphore

            threading.BoundedSemaphore


    sys模块获取异常

            另一种获取异常信息的途径是通过sys模块中的exc_info()函数。该函数回返回一个三元组:(异常类,异常类的实例,跟中记录对象)。

    >>> try:  
    ...     1/0  
    ... except:  
    ...     import sys  
    ...     tuple = sys.exc_info()  
    ...   
    >>> print tuple  
    (<type 'exceptions.ZeroDivisionError'>, ZeroDivisionError('integer division or modulo by zero',), <traceback object at 0x7f538a318b48>)  
    >>> for i in tuple:  
    ...     print i  
    ...   
    <type 'exceptions.ZeroDivisionError'> #异常类      
    integer division or modulo by zero #异常类的实例  
    <traceback object at 0x7f538a318b48> #跟踪记录对象 
    展开全文
  • 在本篇文章里
  • 定义:异常处理就是我们在写Python时,经常看到的报错信息,例如;NameError TypeError ValueError等,这些都是异常。 异常是一个事件,改事件会在程序执行过程中发生,影响程序的正常执行,一般情况下,在python中...
  • 通通过过实实例例了了解解Python异异常常处处理理机机制制底底层层实实现现 这篇文章主要介绍了通过实例了解Python异常处理机制底层实现,文中通过示例代码介绍的非常详细对大家的学 习或者工作具有 定的参考学习价值...
  • 不可否认,Python异常机制确实方便,但滥用异常机制也会带来一些负面影响。过度使用异常主要表现在两个方面: 把异常和普通错误混淆在一起,不再编写任何错误处理代码,而是以简单地引发异常来代苦所有的错误...

    前面介绍了使用异常处理的优势、便捷之处,本节将进一步从程序性能优化、结构优化的角度给出异常处理的一般规则。

    成功的异常处理应该实现如下 4 个目标:

    1. 使程序代码混乱最小化。
    2. 捕获并保留诊断信息。
    3. 通知合适的人员。
    4. 采用合适的方式结束异常活动。

    下面介绍达到这些效果的基本准则。

    不要过度使用异常

    不可否认,Python 的异常机制确实方便,但滥用异常机制也会带来一些负面影响。过度使用异常主要表现在两个方面:

    1. 把异常和普通错误混淆在一起,不再编写任何错误处理代码,而是以简单地引发异常来代苦所有的错误处理。
    2. 使用异常处理来代替流程控制。

    熟悉了异常使用方法后,程序员可能不再愿意编写烦琐的错误处理代码,而是简单地引发异常。实际上这样做是不对的,对于完全己知的错误和普通的错误,应该编写处理这种错误的代码,增加程序的健壮性。只有对于外部的、不能确定和预知的运行时错误才使用异常。

    对比前面五子棋游戏中,处理用户输入坐标点己有棋子的两种方式。如果用户试图下棋的坐标点己有棋子:

    #如果要下棋的点不为空
    if board[int(y_str) - 1) [int(x_str) - 1] !="╋" :
        inputStr = input ("您输入的坐标点己有棋子了,请重新输入\n")
        continue
    

    上面这种处理方式检测到用户试图下棋的坐标点己经有棋子,立即打印一条提示语句,并重新开始下一次循环。这种处理方式简洁明了、逻辑清晰,程序的运行效率也很好程序进入 if 块后,即结束了本次循环。

    如果将上面的处理机制改为如下方式:

    #如果要下棋的点不为空
    if board[int(y_str) - 1) [int(x_str) - 1) != "╋":
        #引发默认的RuntimeError 异常    
        raise
    

    上面这种处理方式没有提供有效的错误处理代码,当程序检测到用户试图下棋的坐标点己经有棋子时,并没有提供相应的处理,而是简单地引发一个异常。这种处理方式虽然简单,但 Python 解释器接收到这个异常后,还需要进入相应的 except 块来捕获该异常,所以运行效率要差一些。而且用户下棋重复这个错误完全是可预料的,所以程序完全可以针对该错误提供相应的处理,而不是引发异常。

    必须指出,异常处理机制的初衷是将不可预期异常的处理代码和正常的业务逻辑处理代码分离,因此绝不要使用异常处理来代替正常的业务逻辑判断。

    另外,异常机制的效率比正常的流程控制效率差,所以不要使用异常处理来代替正常的程序流程控制。例如,对于如下代码:

    #定义一个字符串列表
    my_list =["Hello", "Python", "Spring"]
    #使用异常处理来遍历arr数组的每个元素
    try:
        i = 0    
        while True:
            print (my_list [i])
            i += 1
    except:
        pass
    

    运行上面程序确实可以实现遍历 my_list 列表的功能,但这种写法可读性较差,而且运行效率也不高。程序完全有能力避免产生 indexError 异常,程序“故意”制造这种异常,然后使用 except 块去捕获该异常,这是不应该的。将程序改为如下形式肯定要好得多:

    i = 0
    while i < len(my_list):
        print(my_list[i])
        i += 1
    

    注意,异常只应该用于处理非正常的情况,不要使用异常处理来代替正常的流程控制。对于一些完全可预知,而且处理方式清楚的错误,程序应该提供相应的错误处理代码,而不是将其笼统地称为异常。

    不要使用过于庞大的 try 块

    很多初学异常机制的读者喜欢在 try 块里放置大量的代码,这看上去很“简单”,但这种“简单”只是一种假象,只是在编写程序时看上去比较简单。但因为 try 块里的代码过于庞大,业务过于复杂,就会造成 try 块中出现异常的可能性大大增加,从而导致分析异常原因的难度也大大增加。

    而且当时块过于庞大时,就难免在 try 块后紧跟大量的 except 块才可以针对不同的异常提供不同的处理逻辑。在同一个 try 块后紧跟大量的 except 块则需要分析它们之间的逻辑关系,反而增加了编程复杂度。

    正确的做法是,把大块的 try 块分割成多个可能出现异常的程序段落,并把它们放在单独的 try 块中,从而分别捕获并处理异常。

    不要忽略捕获到的异常

    不要忽略异常!既然己捕获到异常,那么 except 块理应做些有用的事情,及处理并修复异常。except 块整个为空,或者仅仅打印简单的异常信息都是不妥的!

    except 块为空就是假装不知道甚至瞒天过海,这是最可怕的事情,程序出了错误,所有人都看不到任何异常,但整个应用可能已经彻底坏了。仅在 except 块里打印异常传播信息稍微好一点,但仅仅比空白多了几行异常信息。通常建议对异常采取适当措施,比如:

    • 处理异常。对异常进行合适的修复,然后绕过异常发生的地方继续运行;或者用别的数据进行计算,以代替期望的方法返回值;或者提示用户重新操作……总之,程序应该尽量修复异常,使程序能恢复运行。
    • 重新引发新异常。把在当前运行环境下能做的事情尽量做完,然后进行异常转译,把异常包装成当前层的异常,重新传给上层调用者。
    • 在合适的层处理异常。如果当前层不清楚如何处理异常,就不要在当前层使用 except 语句来捕获该异常,让上层调用者来负责处理该异常。
    展开全文
  • 文章目录Python入门异常处理机制多个except结构try...except...else结构try...except...else...finally结构traceback模块Python中创建的异常类型 Python入门 Python开发工具的使用:Pycharm的配置使用 第一章:...

    Python入门

    Python开发工具的使用:Pycharm的配置使用


    第一章:Python入门学习(一)Print函数、Input函数、基本数据类型、运算符、流程控制语句、循环语句
    第二章:Python入门学习(二) 列表的增删改查
    第三章:Python入门学习(三) 字典的增删改查
    第四章:Python入门学习(四)元组与集合
    第五章:Python入门学习(五)字符串的操作
    第六章:Python入门学习(六)函数学习
    第七章:Python入门学习(七)Python异常处理机制
    第八章:Python入门学习(八)Python中的类和对象
    第九章:Python入门学习(九)Python面向对象的三大特征封装、继承和多态
    第十章:Python入门学习(十)Python模块化编程
    第十一章:Python入门学习(十一)Python的IO操作


    第十二章:Python进阶学习(一)_学生信息管理系统项目


    代码仓库地址:Python入门项目

    异常处理机制

    Python提供了异常处理机制,可以在异常出现时及时捕获,然后让程序继续运行。
    在这里插入图片描述

    while True:
        try:
            a = int(input("请输入第一个整数"))
            b = int(input("请输入第二个整数"))
            result = a/b
            print("%d 除以 %d 等于 %.1f" % (a,b,result))  # %.1f 浮点数  小数点后保留1位
        except ZeroDivisionError:
            print("除数不能为0哦!")
    

    多个except结构

    捕获异常的顺序按照先子类后父类的顺序,为了避免遗漏可能出现的异常,可以在最后增加BaseException

    while True:
        try:
            a = int(input("请输入第一个整数"))
            b = int(input("请输入第二个整数"))
            result = a/b
            print("%d 除以 %d 等于 %.1f" % (a,b,result))  # %.1f 浮点数  小数点后保留1位
        except ZeroDivisionError:
            print("除数不能为0哦!")
        except ValueError:
            print("数据类型转换失败")
        except BaseException as e:
            print(e)
    

    在这里插入图片描述

    try…except…else结构

    如果try块中没有抛出异常,则执行else块,如果try中抛出异常,则执行except块

    """
    try...except...else 结构
    如果try块中没有抛出异常,则执行else块,如果try中抛出异常,则执行except块
    """
    try:
        a = int(input("请输入第一个整数"))
        b = int(input("请输入第二个整数"))
        result = a/b
    except ZeroDivisionError:
        print("除数不能为0哦!")
    else:
        print("%d 除以 %d 等于 %.1f" % (a,b,result))  # %.1f 浮点数  小数点后保留1位
    

    try…except…else…finally结构

    finally块无论是否发生异常都会被执行,能常用开释放try块中申请的资源。
    在这里插入图片描述

    try:
        a = int(input("请输入第一个整数"))
        b = int(input("请输入第二个整数"))
        result = a/b
    except ZeroDivisionError:
        print("除数不能为0哦!")
    else:
        print("%d 除以 %d 等于 %.1f" % (a,b,result))  # %.1f 浮点数  小数点后保留1位
    finally:
        print("无论是否发生异常,最后都执行finally中的代码")
    

    traceback模块

    使用traceback模块打印异常信息

    import traceback
    try:
        print(1/0)
    except:
        traceback.print_exc()
    

    在这里插入图片描述

    Python中创建的异常类型

    在这里插入图片描述

    展开全文
  • 引言我们用什么语言写项目,其实都会出错,错误有很多种,有我们写的代码本身就有问题,这个时候属于编译错误,有的代码运行的时候有问题,这个属于运行时异常,python其实也有一套自己的异常处理机制。今天我们来...

    引言

    我们用什么语言写项目,其实都会出错,错误有很多种,有我们写的代码本身就有问题,这个时候属于编译错误,有的代码运行的时候有问题,这个属于运行时异常,python其实也有一套自己的异常处理机制。今天我们来学习一下。

    解决错误中的一种方式:返回错误码

    返回错误码其实是程序员排除错误的一种方式,他们往往会有一个错误码的字典,字典里面记录了什么数字对应着什么错误;然后当程序返回什么码的时候,去再对照之前那个字典,就能够知道什么错误了。

    但是错误码其实有一个局限性,就是当我们返回的结果如果和错误码混合在一起,那么久不太好区分了。

    为了避免这种问题,我们常用try catch finally(java语言中)等方式进行运行时异常的捕获。

    当然python也有类似的。

    try...except...finally

    我们先试用一下

    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语句块

    至此,执行完毕

    ok,当然,如果没有错误出现,那么也不会执行except代码块,如下如

    (注意:如果想得到整数,那么用"//")

    从上面的输出结果,可以看到,不论异常有没有finally一直都会执行,就像java中的一样

    那么,如果发生了不同种的错误,是不是可以使用多种except去处理呢?

    答案是肯定的!

    我们直接来看示例

    这个例子中,我们用一个 except 来捕获 ValueError ,一个 except 来捕获 ZeroDivisionError

    此外,如果没有错误发生的话,还可以在 except 后添加一个 else: 去执行没有该错误的处理

    如下面例子所示

    需要注意的是,并不是一个 except 对应一个 else ,而是当所有的 except 都没处理的话,才会执行唯一的 else ,下面的写法是错的

    错误写法

    Python的错误也是类,所以如果想捕获某一大类的错误,直接捕获大类就好了

    所有的错误类,都继承自 BaseException类

    使用try...except捕获错误还有一个巨大的好处,就是可以跨越多层调用

    请看下方示例:

    由此我们发现,有了这个跨越多层调用 except ,大大减少了复杂的 try except finally 代码的使用

    调用栈

    如果出的错没有处理,那么最终会被 python 解释器捕获,打印一个错误信息,然后程序退出

    我们来演示一下

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

    出了错之后要懂得找打错误的位置,上面的例子错误的位置就在第三行,10/s的位置,找到错误的位置,确定错误的类型,我们就能够解决了

    logging类

    我们从上面的例子知道了,即使我们不进行异常的捕获,python编译器也会对异常进行处理,我们也能定位到异常的位置,那么还要异常处理干什么?

    其实不然,python处理器虽然会处理异常,但是在处理的同时,也将程序终止。

    其实我们可以借助logging类去处理,logging类既会想python处理器一样将错误展示出来,也不会终止程序,如下例所示

    抛出错误

    需要明确的是:

    错误是一个 class ,我们捕获的错误其实就是捕获了该 class 的一个实例

    所以说,错误并不是凭空出现的,而是有意抛出的

    python内置的函数会抛出很多类型的错误,当然我们自己编写的函数也可以抛出错误。

    如果要抛出错误,我们可以根据需要,可以定义一个表示错误的 class ,然后选择好继承关系,

    最后用 raise 语句抛出一个错误的实例。

    比如,现在定义一个错误,让他继承ValueError

    class FooError(ValueError):

    pass

    然后在适当的地方抛出

    def foo(s):

    if s==0:

    raise FooError('Foo Error %s' %s)

    return 10/s

    这样,当我们调用foo函数时,如果我们传入

    0

    那么将会抛出FooError的错误,并且打印

    “Foo Error 0”

    否则的话,则会直接返回 10/s 的返回值

    我们来看一下真实的案例演示:

    但是,我们只有在必要的时候才会定义我们自己的错误类型,在定义错误类型时,一定要继承对父类,否则会造成麻烦

    下面再来看另外一中处理错误的方式:重复抛出错误

    由上图,我们可以看出,虽然已经捕获了异常:打印出了FooError!

    但是又将之前的异常抛出,这是什么操作呢?

    这个操作有的时候很有必要

    有的情况下,由于当前函数不知道怎样去处理当前遇到的错误,那么最恰当的方式是往上抛,让顶层调用者去处理。就好比像一个员工遇到了一个棘手的问题不知道怎么处理,那么他最恰当的做法是交给他的上司,如果他的上司也处理不好,那么就会一直往上抛,直到抛给公司的大老板,让大老板去处理

    注意用法

    raise 如果直接写的话,那么就是把错误直接原封不动的抛给上级

    如果raise 后追加别的错误类型的话,其实就完成了把错误转化成另外一个类型额操作了,如

    try:

    10/s

    except ZeroDivisionError as e:

    print('ZeroDivisionError')

    raise ValueError('ValueError')

    当然了,这种转化只要符合逻辑就可以,但是切忌瞎转化。

    展开全文
  • 简单介绍Python中的错误和异常,重点介绍Python中的异常处理机制,包括主要的关键字:try、except、finally、else等,以及它们组合使用时程序执行的流程等,非常适合高校老师教学和学生课后复习使用。
  • @Author : Roger TX (425144880@qq.com)一、错误与异常在...有的错误是用户输入造成的,比如让用户输入email地址,结果得到一个空字符串,这种错误可以通过检查用户输入来做相应的处理。还有一类错误是完全无法在程...
  • Python 异常处理

    2020-12-29 17:21:27
    Python和很多其他语言一样,支持异常处理。我们可以使用try-catch类似的形式捕获异常,处理异常,或者抛出异常。Python的异常命名惯例和Java语言有些不同, Java的异常一般以Exception结尾,而Python的异常一般以...
  • python中的五种异常处理机制

    千次阅读 2018-07-11 13:41:14
    这篇文章主要介绍了python中的五种异常处理机制介绍,本文是Learn Python一书的读书笔记,需要的朋友可以参考下从几年前开始学习编程直到现在,一直对程序中的异常处理怀有恐惧和排斥心理。之所以这样,是因为不了解。...
  • 文章目录代码出现异常怎么看待Python异常处理机制 代码出现异常怎么看待 开始之前我们先休息一下,久坐成疾!而且以后还可能犯老年痴呆(我还年轻),接下来我们先讲上3个笑话: 1、在公司听到过一句最惨绝人寰...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,003
精华内容 27,201
关键字:

python异常处理机制

python 订阅