精华内容
下载资源
问答
  • try-finally的语法结构

    2019-05-14 17:17:21
    set things up #需要做某事 try: #请求资源 互斥锁做-1操作 上了锁,其他资源不能用需要等待 do something #开始做事情 finally: #资源用完了释放资源 +1操作,其他进程可以用了...
    set things up                   #需要做某事
    try:                            #请求资源 互斥锁做-1操作   上了锁,其他资源不能用需要等待
        do something                #开始做事情
    finally:                        #资源用完了释放资源 +1操作,其他进程可以用了,唤醒等待队列
        tear things down            

     

    展开全文
  • Java中try-catch结构语法

    2021-03-23 15:53:50
    在main函数里catch结构写Exception会报错:No exception of type Exception can be thrown; an exception type must be a subclass of Throwable 就很奇怪,写RuntimeExceprion就没事。这是为啥啊ÿ...
  • 首先,Python 完整异常处理语法结构如下:try:#业务实现代码exceptException1 as e:#异常处理块1...exceptException2 as e:#异常处理块2...#可以有多个 except...else:#正常处理块finally:#资源回收块......

    首先,Python 完整的异常处理语法结构如下:

    try:#业务实现代码

    exceptException1 as e:#异常处理块1

    ...exceptException2 as e:#异常处理块2

    ...#可以有多个 except

    ...else:#正常处理块

    finally:#资源回收块

    ...

    整个异常处理结构的执行过程,如图 1 所示。

    注意,在整个异常处理结构中,只有 try 块是必需的,也就是说:

    如果没有 try 块,则不能有后面的 except 块、else 块和 finally 块。但是也不能只使用 try 块,要么使用 try except 结构,要么使用 try finally 结构;

    except 块、else 块、finally 块都是可选的,当然也可以同时出现;

    可以有多个 except 块,但捕获父类异常的 except 块应该位于捕获子类异常的 except 块的后面;

    多个 except 块必须位于 try 块之后,finally 块必须位于所有的 except 块之后。

    要使用 else 块,其前面必须包含 try 和 except。

    其中,很多初学者分不清 finally 和 else 的区别,这里着重说一下。else 语句块只有在没有异常发生的情况下才会执行,而 finally 语句则不管异常是否发生都会执行。不仅如此,无论是正常退出、遇到异常退出,还是通过 break、continue、return 语句退出,finally 语句块都会执行。

    注意,如果程序中运行了强制退出 Python 解释器的语句(如 os._exit(1) ),则 finally 语句将无法得到执行。例如:

    importostry:

    os._exit(1)finally:print("执行finally语句")

    运行程序,没有任何输出。因此,除非在 try 块、except 块中调用了退出 Python 解释器的方法,否则不管在 try 块、except 块中执行怎样的代码,出现怎样的情况,异常处理的 finally 块总会被执行。

    另外在通常情况下,不要在 finally 块中使用如 return 或 raise 等导致方法中止的语句(raise 语句将在后面介绍),一旦在 finally 块中使用了 return 或 raise 语句,将会导致 try 块、except 块中的 return、raise 语句失效。看如下程序:

    deftest():try:#因为finally块中包含了return语句

    #所以下面的return语句失去作用

    returnTruefinally:returnFalseprint(test())

    上面程序在 finally 块中定义了一条 return False 语句,这将导致 try 块中的 return true 失去作用。运行上面程序,输出结果为:

    False

    同样,如果 Python 程序在执行 try 块、except 块包含有 return 或 raise 语句,则 Python 解释器执行到该语句时,会先去查找 finally 块,如果没有 finally 块,程序才会立即执行 return 或 raise 语句;反之,如果找到 finally 块,系统立即开始执行 finally 块,只有当 finally 块执行完成后,系统才会再次跳回来执行 try 块、except 块里的 return 或 raise 语句。

    但是,如果在 finally 块里也使用了 return 或 raise 等导致方法中止的语句,finally 块己经中止了方法,系统将不会跳回去执行 try 块、except 块里的任何代码。

    尽量避免在 finally 块里使用 return 或 raise 等导致方法中止的语句,否则可能出现一些很奇怪的情况。

    原文:https://www.cnblogs.com/bashliuhe/p/12749270.html

    展开全文
  • 9.4 MATLAB try-catch结构

    千次阅读 2016-12-01 19:38:12
    try-catch结构的具体语法形式如下 try  commands1 %命令1总是首先被执行。若正确,执行完成后结束此结构 catch  commands2 %执行命令1发生错误时,执行命令2 end 说明: (1)只有当MATLAB执行...

    try-catch结构的具体语法形式如下

    try

            commands1    %命令1总是首先被执行。若正确,执行完成后结束此结构

    catch

             commands2       %执行命令1发生错误时,执行命令2

    end


    说明:

    (1)只有当MATLAB执行命令1发生错误时,才执行命令2,。try-catch结构只提供两个可供选择的命令组

    (2)当执行commands1发生错误时,可以调用lasterr函数查询出错的原因。如果函数lasterr的运行结果为空字符串,则表示命令1被成功执行了。

    (3)如果执行命令组2时又发生了错误,MATLAB将会终止该结构


    展开全文
  • 要点概论: 1. 使用 try , except 2. 异常继承结构 ...7.附录(完整异常继承结构,traceback模块官方文档) 1. 使用 try ,except:  先看一段简单代码: try: num = int(input('请输入数字...

    要点概论:

    1. 使用 try , except

    2. 异常继承结构

    3.引发(raise)异常

    4.python 的异常风格

    5. 认识堆栈追踪

    6. 提出警告信息(待补充)

    7.附录(完整的异常继承结构,traceback模块官方文档)

     

    1. 使用 try ,except:

      先看一段简单的代码:

    try:
        num = int(input('请输入数字>>>'))
        print(num)
    except ValueError:
        print('输入错误')

      在这段代码中,python解释器尝试执行 try 区块中的程序代码,如果发生异常,执行流程会跳离异常发生点,然后对比 except 声明的类型,如果符合,则执行 except 区块中的程序代码,

      执行完毕后若仍有后续的程序执行流程,就会继续执行。如果没有相符的异常类型,或者异常完全没有使用 try , except 处理,那么异常就会持续往上层调用者传递,在每一层调用处中断,

      直到最顶层由 python 解释器来处理(后面会由此衍生出 Traceback 模块)。

      

      PS:在 python 中,异常并不一定时错误,例如使用 for in 语句时,其实底层就运用到了异常处理机制(for in 会在遇到 StopIteration 时结束迭代,因此我们不会看到 StopIteration )。

     

    2. 异常继承结构

      如果一个异常在 except 的对比过程中就符合了某个异常的父类型,后续即使定义了 except 对比子类型异常,也等同于没有定义。例如:

    try:
        dividend = int(input('输入被除数:'))
        divisor = int(input('输入除数:'))
        print('{} / {} = {}'.format(dividend,divisor,dividend / divisor))
    except ArithmeticError:
        print('运算错误')
    except ZeroDivisionError:
        print('除零错误')
    View Code

      在上面这段代码中,永远也不会看到 '除零错误' 的信息,因为在异常继承结构中,ArithmeticError 是 ZeroDivisionError 的父类。发生 ZeroDivisionError 时,程序在 except 对比时会先遇到 ArithmeticError ,因此就执行了对应的区块。

      

      PS:在 python 中,异常都是 BaseException 的子类,当使用 except 而没有指定异常类型时,实际上都是对比 BaseException。

     

    3. 引发(raise)异常(待补充raise from,__cause__,__context__相关内容

      先看一个简单的类(描述了一个存取款的简单银行业务):

    class Account:
        def __init__(self,name,number,balance):
            self.name = name
            self.number = number
            self.balance = balance
    
        def deposit(self,amount):
            if amount <= 0:
                print('存款金额不能为负')
            else:
                self.balance += amount
        
        def withdraw(self,amount):
            if amount > self.balance:
                print('金额不足')
            else:
                self.balance -= amount
        
        def __str__(self):
            return "Account('{name}','{number}',{balance})".format(
                name = self.name,number = self.number,balance = self.balance
            )
    Account

        可以看到,当存款金额为负或者余额不足时,会使得相关流程无法继续而中断,

        如果想让调用者知道因为某些原因而使得流程无法继续而必须中断时,可以引发异常。

      在 python 中如果想要引发异常,可以使用 raise ,之后指定要引发的异常对象或类型,只指定异常类型的时候会自动创建异常对象。例如:

    class Account:
        def __init__(self,name,number,balance):
            self.name = name
            self.number = number
            self.balance = balance
    
        def check_amount(self,amount):      #检查参数值
            if amount <= 0:
                raise ValueError('金额必须时正数:' + str(amount))
    
        def deposit(self,amount):
            self.check_amount(amount)
    
            self.balance += amount
    
        def withdraw(self,amount):
            self.check_amount(amount)
    
            if amount > self.balance:
                raise BankingException('余额不足')  #自定义异常
    
            self.balance -= amount
    
        def __str__(self):
            return "Account('{name}','{number}',{balance})".format(
                name = self.name,number = self.number,balance = self.balance
            )
        
    class BankingException(Exception):  #自定义异常
        def __init__(self,message):
            super().__init__(message)
    exceptions Account

      例子中定义了一个 check_amount() 方法用来检查传入的金额是否为负。

      余额不足部分自定义了一个异常 BankException 。

      【可以为自己的 API 创建一个根异常,业务相关的异常都可以衍生自这个根异常,这样便于使用 API 的用户在 except 时使用根异常来处理 API 相关的异常。】

      

     

    4. python 异常风格

      在 python 中异常并不一定时错误,例如 KeyboardInterrupt ,SystemError, GeneratorExit ,或者时 StopIteration 等更像是一种事件,代表着流程因为某个原因无法继续而必须中断。

      【对于标准链接库会引发的异常,也可以从开发者的角度来思考,为什么他想要引发这样的异常?如此就可以知道该怎么处理异常,例如留下日志信息,转为其他流程或重新引发异常。】

      

      在其他程序设计语言中常会有个告诫,异常处理就应当用来处理错误,不应该将异常处理当成是程序流程的一部分。

      然而在 python 中,就算异常是个错误,只要程序代码能明确表达出意图,也常被当成流程的一部分。

      举个例子来说,如果 import 的模块不存在,就会引发 ImportError 错误。然而 import 是条语句,可以出现在语句能出现的场合,因此有时候会想看看某个模块能否被 import,

      若模块不存在,则改为 import 另一个模块,此时在 python 中就会如此编写:

    try:
        import some_module
    except ImportError:
        import other_module

      又或者通过另一种方式完成:

    import importlib
    
    some_loader = importlib.find_loader('some_module')
    if some_loader:
        import some_module
    else:
        import other_module

      如果指定的模块确实存在,那么 importlib.find_loader() 的返回值就不会是 None,因此可以 import指定模块而不会引发 ImportError 。

      一般情况下用 try,except 语句处理比较好。

     

    5. 认识堆栈追踪

      在 API 的多重调用下,异常发生点可能在某个函数或方法之中,若想得知异常发生的根源,以及多重调用下异常的传递过程,可以使用 traceback 模块

      这个模块提供了一些方式,模拟了 python 解释器在处理异常堆栈追踪(Stack Trace)时的行为,可在受控制的情况下获取,格式化或显示异常堆栈追踪信息。

     

      1)使用 traceback.print_exc() 

        查看堆栈追踪最简单的方法就是直接调用 traceback 模块的 print_exc() 函数。例如:

    def a():
        text = None
        return text.upper()
    def b():
        a()
    def c():
        b()
    
    try:
        c()
    except:
        import traceback
        traceback.print_exc()
    traceback.print_exc()

        在这个例子中,c() 函数调用 b() 函数,b()  函数调用  a()  函数 ,a() 函数中会因 text 为 None,之后试图调用 upper() 而引发 AttributeError 错误。

        假设事先并不知道这个调用顺序(比如说在使用一个链接库),当异常发生而被对比后,可以调用  traceback.print_exc() 显示堆栈追踪(在  Pycharm IDE 中,按下行数就会直接打开源码文件并跳至所对应的行数)。

        

         traceback.print_exc() 还可以指定 file 参数,指定一个已打开的文件对象,将堆栈追踪信息输出到文件里。例如 traceback.print_exc(file=open('traceback.txt','w+')) 可将堆栈信息写到 traceback.txt 中。

        traceback.print_exc() 的 limit 参数默认时 None ,也就是不限制堆栈追踪个数,可以指定为正数或负数。正数代表显示最后几次的堆栈追踪个数,负数代表显示最初几次的堆栈追踪个数。

        traceback.print_exc() 的 chain 参数默认时 True ,也就是一并显示 __cause__,__context__等串连起来的异常。

        如果只想获取堆栈追踪的字符串描述,可以使用 traceback.format_exc() ,它会返回字符串,只具有 limit 与 chain 两个参数。

      

      2)使用 sys.exc_info() 

        sys.exc_info()  可获取一个元组对象,当中包括了异常的类型,实例以及 traceback 对象。例如:

    import sys
    try:
        raise Exception('shit happens')
    except:
        print(sys.exc_info())
    
    
    #(<class 'Exception'>, Exception('shit happens',), <traceback object at 0x000001F41EF3EA48>)
    sys.exc_info()

         traceback 对象代表了调用堆栈中每一个层次的追踪,可以使用 tb_next 获取更深一层的调用堆栈。例如:

    import sys
    
    def test():
        raise Exception('shit happens')
    
    try:
        test()
    except:
        type,value,traceback = sys.exc_info()
        print('异常类型',type)
        print('异常对象',value)
    
        while traceback:
            print('-------')
            code = traceback.tb_frame.f_code
            print('文件名:',code.co_filename)
            print('函数或模块名称:',code.co_name)
            
            traceback = traceback.tb_next
    
    输出结果如下:
    
    异常类型 <class 'Exception'>
    异常对象 shit happens
    -------
    文件名: C:/Users/Administrator/PycharmProjects/S9/练习/异常处理/初探堆栈追踪.py
    函数或模块名称: <module>
    -------
    文件名: C:/Users/Administrator/PycharmProjects/S9/练习/异常处理/初探堆栈追踪.py
    函数或模块名称: test
    View Code

        tb_frame 代表了该层追踪的所有对象信息, f_code 可以获取该层的程序代码信息,例如 co_name 可获取函数或模块名称,co_filename 则表示该程序代码所在的文件。

        也可以通过 tb_frame 的 f_locals 和 f_globals 来获取执行时的局部变量或全局变量,返回的是个字典对象。

     

      3)使用 sys.excepthook()

          对于一个未匹配到的异常, python 解释器最后会调用 sys.excepthook() 并传入三个自变量:异常类,实例与 traceback 对象,也就是 sys.exc_info() 返回的元组中的三个对象。

          默认的操作时显示相关的异常追踪信息(也就是程序结束前看到的那些信息)。

          

          如果想要自定义  sys.excepthook() 被调用时的行为(或操作),也可以自行指定一个可接受三个自变量的函数给  sys.excepthook ,如果希望对比程序中没有被对比到的其他全部异常,

          就可以使用这个特性,而不一定要在程序最顶层使用 try ,except。例如:

    import sys
    
    def my_excepthook(type,value,traceback):
        print('异常类型:',type)
        print('异常对象:',value)
    
        while traceback:
            print('------')
            code = traceback.tb_frame.f_code
            print('文件名:',code.co_filename)
            print('函数或模块名称:',code.co_name)
    
            traceback = traceback.tb_next
    
    sys.excepthook = my_excepthook
    
    def test():
        raise Exception('shit happens')
    
    test()
    注册 sys.excepthook() 的方式实现

          执行结果与上一个例子相同,不过这次采取的是注册 sys.excepthook() 的方式。

     

    6. 提出警告信息(待补充)

     

     

      

     

     

     

     

     

     

     

     

    7. 附录:

      traceback官方帮助文档:https://docs.python.org/3.5/library/traceback.html

      python中完整的异常继承结构:https://docs.python.org/3.5/library/exceptions.html

     

    BaseException
     +-- SystemExit
     +-- KeyboardInterrupt
     +-- GeneratorExit
     +-- Exception
          +-- StopIteration
          +-- StopAsyncIteration
          +-- ArithmeticError
          |    +-- FloatingPointError
          |    +-- OverflowError
          |    +-- ZeroDivisionError
          +-- AssertionError
          +-- AttributeError
          +-- BufferError
          +-- EOFError
          +-- ImportError
          +-- LookupError
          |    +-- IndexError
          |    +-- KeyError
          +-- MemoryError
          +-- NameError
          |    +-- UnboundLocalError
          +-- OSError
          |    +-- BlockingIOError
          |    +-- ChildProcessError
          |    +-- ConnectionError
          |    |    +-- BrokenPipeError
          |    |    +-- ConnectionAbortedError
          |    |    +-- ConnectionRefusedError
          |    |    +-- ConnectionResetError
          |    +-- FileExistsError
          |    +-- FileNotFoundError
          |    +-- InterruptedError
          |    +-- IsADirectoryError
          |    +-- NotADirectoryError
          |    +-- PermissionError
          |    +-- ProcessLookupError
          |    +-- TimeoutError
          +-- ReferenceError
          +-- RuntimeError
          |    +-- NotImplementedError
          |    +-- RecursionError
          +-- SyntaxError
          |    +-- IndentationError
          |         +-- TabError
          +-- SystemError
          +-- TypeError
          +-- ValueError
          |    +-- UnicodeError
          |         +-- UnicodeDecodeError
          |         +-- UnicodeEncodeError
          |         +-- UnicodeTranslateError
          +-- Warning
               +-- DeprecationWarning
               +-- PendingDeprecationWarning
               +-- RuntimeWarning
               +-- SyntaxWarning
               +-- UserWarning
               +-- FutureWarning
               +-- ImportWarning
               +-- UnicodeWarning
               +-- BytesWarning
               +-- ResourceWarning
    异常继承结构

      KeyboardInterrupt 表示发生了一个键盘中断;SystemError 则是由 sys.exit() 引发的异常,表示离开 python 程序;

      GeneratorExit 会在生成器的 close() 方法被调用时从当时暂停的位置引发,如果在定义生成器时想要在 close() 时为生成器做些资源善后等操作,就可以使用。例如:(待验证,pycharm 里运行结果不一致

    def natural():
        n = 0
        try:
            while True:
                n += 1
                yield n
        except GeneratorExit:
            print('GeneratorExit',n)
    
    n = natural()
    
    print(next(n))    # 1
    n.close()         # GeneratorExit 1
    View Code

      KeyboardInterrupt ,SystemError, GeneratorExit 都直接继承了 BaseException,这是因为它们在 python 中都属于退出系统意外的异常。

      如果想要自定义异常,不要直接继承 BaseException ,而应该继承 Exception,或者是 Exception 的相关子类来继承。

      

      PS:在继承 Exception 自定义异常时,如果定义了 __init__() , 建议将自定义的 __init__()传入的自变量通过 super().__init__(arg1,arg2,...) 来调用 Exception 的 __init__(),

      因为 Exception 的 __init__()默认接收所有传入的自变量,而这些被接受的全部自变量可通过 args 属性以一个元组获取。

     

    转载于:https://www.cnblogs.com/HZY258/p/8461674.html

    展开全文
  • TRY-CATCH结构 语法: BEGIN TRY SQL语句… END TRY BEGIN CATCH 错误处理语句… END CATCH 例: 使用存储过程实现由用户输入学生学号及课程名称,根据 输入信息,显示相应成绩,如果成绩小于60分,则向 ...
  • php中文网最新课程每日17点准时技术干货分享问题当 PHP 在执行代码过程,在某...使用有一定限制,如:无法跳出一个函数或类,无法从外部跳入到一个函数,无法跳入到任何循环或者 switch 结构中。但可以跳出循环或...
  • 为了避免程序员在写输入输出流时忘记关闭流,Java提供了一种try的语法结构,可以实现流的自动关闭。其语法结构如下: try(创建的流对象){ 对输入输出流进行操作的语句 } 需要注意的是,在try语句后面的小...
  • 使用try...catch语法结构如下: try{//程序代码}catch(Exception e){//错误代码处理} 异常处理的语法try{有可能产生错误的代码}catch(异常处理声明(声明此catch区段要捕获哪一种类型的异常错误,可以不用声明,...
  • 1、演示通过fstream类进行串行化保存和加载方法,节省数据存储空间; 2、讲解和演示C++异常处理概念与用法,对比throw语法...3、演示try与多类型catch语法连用方法,讲解异常类开发应用以及异常注释方法;
  • 以我自己职业经历来说,我情愿自己去针对一项重现写代码,也不愿意去承接别人代码。我想,这是大部分码农心声吧...【1】语法格式我们开始从Python异常语法格式开始吧。从上图可以看到以下信息:四个关键词:...
  • 目录 情况一:try中有return,catch和finally中没有return 情况二:try和finally中都有return ...我们都已经清楚了解到:在try-catch-finally语法结构中无论异常是否发生,finally语句块中内容都会...
  • C#中的try与finally

    2013-12-02 22:13:38
    C#中的try与finally   ...try-catch-finally是很常用的语法结构,用来控制可能发生异常时的程序流程,其中catch和finally至少要有一个。初学try语法时可能会要问一个问题:如果在try块中retu
  • Java语法

    2020-09-04 09:06:40
    但其实,Java虚拟机是并不支持语法糖,语法糖在程序编译阶段就会被还原成简单基础语法结构,这个过程就是解语法糖。所以在Java中真正支持语法糖是Java编译器。 try-with-resource语法 Lambda表达式 try-...
  • try-catch-finally是很常用的语法结构,用来控制可能发生异常时的程序流程,其中catch和finally至少要有一个。初学try语法时可能会要问一个问题:如果在try块中return,那么finally还会执行吗?答案是肯定的。这个...
  • tryreturn与finally

    2012-08-04 12:47:50
    try-catch-finally是很常用的语法结构,用来控制可能发生异常时的程序流程,其中catch和finally至少要有一个。初学try语法时可能会要问一个问题:如果在try块中return,那么finally还会执行吗?答案是肯定的。这个...
  • Python try else异常处理教程在在我们使用 try except else 结构时,同样可以使用 finally 分支,表示一定要执行代码逻辑。Python try except else语句详解语法try:# 需要检测异常代码except Exception:# 异常...
  • C#中的try与finally .

    2013-04-23 09:02:12
    try-catch-finally是很常用的语法结构,用来控制可能发生异常时的程序流程,其中catch和finally至少要有一个。初学try语法时可能会要问一个问题:如果在try块中return,那么finally还会执行吗?答案是肯定的。这个...
  • Java 强化笔记 学校教其实真就是一些皮毛而已,怕是连门都没入。。。 泛型(泛型类型、原始类型、泛型方法)、通配符(上界、下界、无限制、...计算机网络体系结构(OIS参考模型、TCP/IP体系、网络通信标准化...
  • C#中的try与finally

    千次阅读 2008-10-24 16:07:00
    1 finally与returntry-catch-finally是很常用的语法结构,用来控制可能发生异常时的程序流程,其中catch和finally至少要有一个。初学try语法时可能会要问一个问题:如果在try块中return,那么finally还会执行吗?...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 621
精华内容 248
关键字:

try的语法结构