精华内容
下载资源
问答
  • 尝试React路由器和React形式 因为它们看起来非常漂亮。 安装 git clone git@github.com:DjebbZ/try-react-router-forms.git npm install
  • try-with-resources 语句中的资源只能是实现了java.lang.AutoCloseable接口的类实例,但是 Java SE 7 之後的所有实现了java.io.Closeable的类都实现了java.lang.AutoCloseable接口(该接口是在Java SE 7中才引入的)...
  • 主要介绍了php中try catch捕获异常的用法,以实例形式详细分析了捕获一个异常与捕获多个异常的方法,有助于更好的处理一些不必要的错误,具有一定的实用价值,需要的朋友可以参考下
  • 主要介绍了C#中的try catch finally用法,以实例形式分析了try catch finally针对错误处理时的不同用法,具有一定的参考借鉴价值,需要的朋友可以参考下
  • Java 异常

    千次阅读 多人点赞 2019-04-27 20:18:44
    Java异常 Java异常是Java提供的一种识别及响应错误的一致性机制。 Java异常机制可以使程序中异常处理代码和正常业务代码分离,保证程序代码更加优雅,并...Java异常机制用到的几个关键字:try、catch、finally、thr...

    Java异常

    Java异常是Java提供的一种识别及响应错误的一致性机制。
    Java异常机制可以使程序中异常处理代码和正常业务代码分离,保证程序代码更加优雅,并提高程序健壮性。在有效使用异常的情况下,异常能清晰的回答3个问题:异常类型回答了“什么”被抛出,异常堆栈跟踪回答了“在哪“抛出,异常信息回答了“为什么“会抛出。

    Java异常机制用到的几个关键字:try、catch、finally、throw、throws
    • try – 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内,当try语句块内发生异常时,异常就被抛出。
    • catch – 用于捕获异常。catch用来捕获try语句块中发生的异常。
    • finally – finally语句块总是会被执行。它主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)。只有finally块,执行完成之后,才会回来执行try或者catch块中的return或者throw语句,如果finally中使用了return或者throw等终止方法的语句,则就不会跳回执行,直接停止。
    • throw – 用于抛出异常。
    • throws – 用在方法签名中,用于声明该方法可能抛出的异常。

    (1)了解try和catch基本用法
    public class Demo1 {
    
        public static void main(String[] args) {
            try {
                int i = 10/0;
                  System.out.println("i="+i); 
            } catch (ArithmeticException e) {
                  System.out.println("Caught Exception"); 
                System.out.println("e.getMessage(): " + e.getMessage()); 
                System.out.println("e.toString(): " + e.toString()); 
                System.out.println("e.printStackTrace():");
                e.printStackTrace(); 
            }
        }
    }
    

    运行结果:

    Caught Exception
    e.getMessage(): / by zero
    e.toString(): java.lang.ArithmeticException: / by zero
    e.printStackTrace():
    java.lang.ArithmeticException: / by zero
        at Demo1.main(Demo1.java:6)
    

    分析:在try语句块中有除数为0的操作,该操作会抛出java.lang.ArithmeticException异常。通过catch,对该异常进行捕获。
    没有执行System.out.println(“i=”+i)。这说明try语句块发生异常之后,try语句块中的剩余内容就不会再被执行了。

    (2)了解finally的基本用法

    在(1)的基础上,添加finally语句。

    public class Demo2 {
        public static void main(String[] args) {
            try {
                int i = 10/0;
                  System.out.println("i="+i); 
            } catch (ArithmeticException e) {
                  System.out.println("Caught Exception"); 
                System.out.println("e.getMessage(): " + e.getMessage()); 
                System.out.println("e.toString(): " + e.toString()); 
                System.out.println("e.printStackTrace():");
                e.printStackTrace(); 
            } finally {
                System.out.println("run finally");
            }
        }
    }
    

    运行结果:

    Caught Exception
    e.getMessage(): / by zero
    e.toString(): java.lang.ArithmeticException: / by zero
    e.printStackTrace():
    java.lang.ArithmeticException: / by zero
        at Demo2.main(Demo2.java:6)
    run finally
    

    结果说明:最终执行了finally语句块。

    (3)了解throws和throw的基本用法

    throws是用于声明抛出的异常,而throw是用于抛出异常。

    class MyException extends Exception {
        public MyException() {}
        public MyException(String msg) {
            super(msg);
        }
    }
    
    public class Demo3 {
        public static void main(String[] args) {
            try {
                test();
            } catch (MyException e) {
                System.out.println("Catch My Exception");
                e.printStackTrace();
            }
        }
        public static void test() throws MyException{
            try {
                int i = 10/0;
                  System.out.println("i="+i); 
            } catch (ArithmeticException e) {
                throw new MyException("This is MyException"); 
            }
        }
    }
    

    运行结果:

    Catch My Exception
    MyException: This is MyException
        at Demo3.test(Demo3.java:24)
        at Demo3.main(Demo3.java:13)
    

    结果说明:
      MyException是继承于Exception的子类。test()的try语句块中产生ArithmeticException异常(除数为0),并在catch中捕获该异常;接着抛出MyException异常。main()方法对test()中抛出的MyException进行捕获处理。

    Java异常框架

    异常类有两个主要的子类:IOException 类和 RuntimeException 类。Java异常架构图如下
    在这里插入图片描述

    1. Throwable

    Throwable是 Java 语言中所有错误或异常的超类。
      Throwable包含两个子类: Error 和 Exception。它们通常用于指示发生了异常情况。
      Throwable包含了其线程创建时线程执行堆栈的快照,它提供了printStackTrace()等接口用于获取堆栈跟踪数据等信息。

    2. Exception

    Exception及其子类是 Throwable 的一种形式,它指出了合理的应用程序想要捕获的条件。

    3. RuntimeException

    RuntimeException是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。
      编译器不会检查RuntimeException异常。例如,除数为零时,抛出ArithmeticException异常。RuntimeException是ArithmeticException的超类。当代码发生除数为零的情况时,倘若既"没有通过throws声明抛出ArithmeticException异常",也"没有通过try…catch…处理该异常",也能通过编译。这就是我们所说的"编译器不会检查RuntimeException异常"!
      如果代码会产生RuntimeException异常,则需要通过修改代码进行避免。例如,若会发生除数为零的情况,则需要通过代码避免该情况的发生!

    4. Error

    • 和Exception一样,Error也是Throwable的子类。它用于指示合理的应用程序不应该试图捕获的严重问题,大多数这样的错误都是异常条件。
    • 和RuntimeException一样,编译器也不会检查Error。

    Java将可抛出(Throwable)的结构分为三种类型:被检查的异常(Checked Exception),运行时异常(RuntimeException)和错误(Error)。

    (1) 运行时异常

    定义: RuntimeException及其子类都被称为运行时异常。
    特点: Java编译器不会检查它。也就是说,当程序中可能出现这类异常时,倘若既"没有通过throws声明抛出它",也"没有用try-catch语句捕获它",还是会编译通过。例如,除数为零时产生的ArithmeticException异常,数组越界时产生的IndexOutOfBoundsException异常,fail-fail机制产生的ConcurrentModificationException异常等,都属于运行时异常。
      虽然Java编译器不会检查运行时异常,但是我们也可以通过throws进行声明抛出,也可以通过try-catch对它进行捕获处理。
      如果产生运行时异常,则需要通过修改代码来进行避免。例如,若会发生除数为零的情况,则需要通过代码避免该情况的发生!

    (2) 被检查的异常

    概念:Exception类本身,以及Exception的子类中除了"运行时异常"之外的其它子类都属于被检查异常。
    特点: Java编译器会检查它。此类异常,要么通过throws进行声明抛出,要么通过try-catch进行捕获处理,否则不能通过编译。例如,CloneNotSupportedException就属于被检查异常。当通过clone()接口去克隆一个对象,而该对象对应的类没有实现Cloneable接口,就会抛出CloneNotSupportedException异常。
      被检查异常通常都是可以恢复的。

    (03) 错误

    定义: Error类及其子类。
    特点: 和运行时异常一样,编译器也不会对错误进行检查。
      当资源不足、约束失败、或是其它程序无法继续运行的条件发生时,就产生错误。程序本身无法修复这些错误的。例如,VirtualMachineError就属于错误。
      按照Java惯例,我们是不应该是实现任何新的Error子类的!

    对于上面的3种结构,我们在抛出异常或错误时,到底该哪一种?《Effective Java》中给出的建议是:对于可以恢复的条件使用被检查异常,对于程序错误使用运行时异常。

    展开全文
  • Python中异常捕捉try..except...finally的使用

    万次阅读 多人点赞 2018-08-18 10:41:33
    Python开发中 ,常见错误类型有两种 :语法错误和异常。语法错误是程序没有运行时,由开发IDE环境检测到错误,比如缩进错误,变量没有...1.实际开发中不能直接讲代码的报错抛给用户,而是通过异常处理的形式给出提示...

        Python开发中 ,常见错误类型有两种 :语法错误和异常。语法错误是程序没有运行时,由开发IDE环境检测到错误,比如缩进错误,变量没有写完整,缺少:等解析错误。而异常就是指程序运行时检测到的错误,比如ZeroDivisionError,分母为0的错1/0.比如“aaa”+4等错误。

         异常为什么需要处理?1.实际开发中不能直接讲代码的报错抛给用户,而是通过异常处理的形式给出提示。2.如果有异常不处理,程序会挂起,异常后的代码都不会执行。这样影响实际程序的使用。

    1.异常演示

    #异常类型1:
    print("准备open the file")
    f1 = open("aaa.txt","r")
    print("the file is open")
    '''文件不存在,程序报错,是代码形式反馈错误,实际开发给用户体验不好。
    准备open the file
        f1 = open("aaa.txt","r")
    FileNotFoundError: [Errno 2] No such file or directory: 'aaa.txt'
    '''
    #异常类型2
    num= 5
    print(num/0) 
    print(num/0) #ZeroDivisionError: division by zero
    ZeroDivisionError: division by zero

    2.异常处理:python中用 try...except... 捕获异常

    1.虽然try....except捕捉了异常 ,程序不会报代码的错误。但是注意异常代码后面的代码不会执行了,可以用try...finally替代。

    2.一个 try 语句可能包含多个except子句,分别来处理不同的特定的异常。但只有一个分支会被执行,类似else

    3.如果在执行try子句的过程中发生了异常,那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符,那么对应的except子句将被执行。最后执行 try 语句之外的代码。

    #0.捕捉异常和不捕捉异常的区别在哪里?
    num = 5
    print(num/0)
    
    print("我是try之外的代码,你猜我会执行吗?哈哈哈")
    print("我是try之外的代码,你猜我会执行吗?呵呵呵呵")
    -------不捕捉异常的结果,异常代码后面的代码print都不会执行-------------------------------------
    Traceback (most recent call last):
      File "D:/pythoyworkspace/file_demo/Class_Demo/Exception_demo.py", line 3, in <module>
        print(num/0)
    ZeroDivisionError: division by zero
    ------------------捕捉异常的代码---------------------------------------------------------
    try:
        num = 5
        print(num/0)
    except Exception as ex_results:
        print("有情况")
        print("抓了一个异常:",ex_results)
    print("我是try之外的代码,你猜我会执行吗?哈哈哈")
    ==============捕捉异常后代码的执行结果:异常后的代码print会执行=============================
    有情况
    抓了一个异常: division by zero
    我是try之外的代码,你猜我会执行吗?哈哈哈
    我是try之外的代码,你猜我会执行吗?呵呵呵
    ------------------------------------------------------------------------------------------
    #1.异常处理:python中用 try...except... 捕获异常
    try:  #1.注意代码的缩进,隐患需要处理的代码放到try的缩进代码块里。
        print("准备open the file")
        f1 = open("aaa.txt","r")
        print("the file is open")
    except IOError: #except后面跟的是错误类型。
        print("很抱歉:你打开的文件不存在!")  
        #except缩进跟的是处理方式,把处理异常的代码,放在except中。如果没有处理方式可以直接用pass表示什么也不做.
    
    =========================================================================
    准备open the file
    很抱歉:你打开的文件不存在!
    
    #2.try--except同时处理多个异常类型
    try:
        num = 5
        print(num/0)
        print("准备open the file")
        f1 = open("aaa.txt","r")
        print("the file is open")
    except(IOError,ZeroDivisionError): #可以同时处理多个异常,各种类型用元组封装
        print("垃圾,程序有异常了")
    
    #3.如果不确定异常类型,可以except后面什么都不写。
    try:
        num = 5
        print(num/0)
        print("准备open the file")
        f1 = open("aaa.txt","r")
        print("the file is open")
    except:
        print("垃圾,程序有异常了")
    #4.打印异常类型,但是实际异常后面的代码不会执行 ,所以只能捕捉一个异常。
    try:
        f1 = open("aaa.txt", "r")
        print("the file is open")
        num = 5
        print(num/0)
        print("准备open the file")
    except (IOError,ZeroDivisionError) as ex_results: 
        print(ex_results)
    =========================================================================
    [Errno 2] No such file or directory: 'aaa.txt'
    
    #5.捕捉所有异常,这种情况适合不知道异常具体类型,但是又想存储打印异常类型 。
    try:
        num = 5
        print(num/0)
        f1 = open("aaa.txt", "r")
        print("the file is open")
        print("准备open the file")
    except Exception as ex_results:
        print("有情况")
        print("抓了一个异常:",ex_results)
    print("我是try之外的代码,你猜我会执行吗?哈哈哈")
    print("我是try之外的代码,你猜我会执行吗?呵呵呵呵")
    ==========================================================================
    有情况
    抓了一个异常: division by zero
    我是try之外的代码,你猜我会执行吗?哈哈哈
    我是try之外的代码,你猜我会执行吗?呵呵呵呵
    
    #6.try--except可以配上else,类似while else ,for else的使用
    try:
        num = input("请输入一个整数除数:")
        result = 100.0/int(num)
        print("商的结果是:%f"%result)
    except ZeroDivisionError as ex_results:
        print("有情况")
        print("抓了一个异常:",ex_results)
    else :
        print("恭喜,没有 错误")
    ==========================================================================
    请输入一个整数除数:6
    商的结果是:16.666667
    恭喜,没有 错误
    请输入一个整数除数:0
    有情况
    抓了一个异常: float division by zero
    
    

    3.异常捕捉:try ..except..finally 

    在程序中,如果一个段代码必须要执行,即无论异常是否产生都要执行,那么此时就需要使用finally。 比如文件关闭,释放锁,把数据库连接返还给连接池等,注意:finally是可选的选项。

    #1.try...except....finally的使用演示
    try:
        f1 = open("test.txt","rU")
        for i in f1:
            i=i.strip()
            print(i)
    except Exception as E_results:
        print("捕捉有异常:",E_results)
    finally: #finally的代码是肯定执行的,不管是否有异常,但是finally语块是可选的。
        f1.close
        print("我不管,我肯定要执行。")
    ------------------程序无异常会执行-----------------------------------
    ccccccccccd
    ddddddddddddddddd
    333343434343
    safsdfasdfsadfsa
    我不管,我肯定要执行。
    ------------------程序有异常还是会执行----------------------------------
    File "D:/pythoyworkspace/file_demo/Class_Demo/Exception_demo.py", line 44, in <module>
    捕捉有异常: [Errno 2] No such file or directory: 'tes2t.txt'
        f1.close
    我不管,我肯定要执行。
    NameError: name 'f1' is not defined
    
    #2.注意try..finally的使用,可以没有except。只有try...except.,try...except...finally这三种用法
    
    try:
        f1 = open("tes3t.txt","rU")
        for i in f1:
            i=i.strip()
            print(i)
    finally: #finally的代码是肯定执行的,不管是否有异常,但是finally语块是可选的。
        print("我不管,我肯定要执行。")
        f1.close
    -----------------------有异常的情况 ------------------------------------------------------
     File "D:/pythoyworkspace/file_demo/Class_Demo/Exception_demo.py", line 36, in <module>
    恭喜,没有 错误
        f1 = open("tes3t.txt","rU")
    我不管,我肯定要执行。
    FileNotFoundError: [Errno 2] No such file or directory: 'tes3t.txt'
    
    During handling of the above exception, another exception occurred:
    
    Traceback (most recent call last):
      File "D:/pythoyworkspace/file_demo/Class_Demo/Exception_demo.py", line 42, in <module>
        f1.close
    NameError: name 'f1' is not defined
    --------------------------无异常的情况----------------------------------------------------- 
    ccccccccccd
    ddddddddddddddddd
    333343434343
    safsdfasdfsadfsa
    我不管,我肯定要执行。

    4.异常处理事失败的情况:异常类似错误

    try:
        num = 5
        print(num/0) #ZeroDivisionError: division by zero
    except IOError:
        print("报错了,分母不能为0")
    '''虽然捕捉处理了异常,但是为什么用呢?
    print(num/0) #ZeroDivisionError: division by zero
    ZeroDivisionError: division by zero
    '''
    注意:因为异常类型不对,异常类型要很精确的,否则没有用。如果不确定异常类型,可以直接什么都不写
    try:
        num = 5
        print(num/0) #ZeroDivisionError: division by zero
    except ZeroDivisionError:
        print("报错了,分母不能为0")
    -------------------------------------------------------
    报错了,分母不能为0
    
    #如果不知道异常是什么类型,可以不写。但是如果写了异常类型,必须是精确的
    try:
        num = 5
        print(num/0) #ZeroDivisionError: division by zero
    except :
        print("报错了,分母不能为0")
    -------------------------------------------------------
    报错了,分母不能为0

    5.案例演示:异常传递的情况

    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-3---")
    #注意分析执行的结果
    test3()
    print("------test3执行完了,分割一下-----")
    test2()
    
    ====================执行结果如下=======================================================
    ----test3-1----
    Traceback (most recent call last):
    ----test1-1----
      File "D:/pythoyworkspace/file_demo/Class_Demo/Exception_demo.py", line 23, in <module>
        test2()
    捕获到了异常,信息是:name 'num' is not defined
    ----test3-3---
    
    ------test3执行完了,分割一下------------
    NameError: name 'num' is not defined
    ----test2-1----
    ----test1-1----

    6.开发中异常处理模式

    • 在实际开发中,为了能够处理复杂的异常情况,完整的异常语法如下:
    try:
        # 尝试执行的代码
        pass
    except 错误类型1:
        # 针对错误类型1,对应的代码处理
        pass
    except 错误类型2:
        # 针对错误类型2,对应的代码处理
        pass
    except (错误类型3, 错误类型4):
        # 针对错误类型3 和 4,对应的代码处理
        pass
    except Exception as result:
        # 打印错误信息
        print(result)
    else:
        # 没有异常才会执行的代码
        pass
    finally:
        # 无论是否有异常,都会执行的代码
        print("无论是否有异常,都会执行的代码")
    
    • else 只有在没有异常时才会执行的代码
    • finally 无论是否有异常,都会执行的代码

    7.异常的传递

    • 异常的传递 —— 当 函数/方法 执行 出现异常,会 将异常传递 给 函数/方法 的 调用一方
    • 如果 传递到主程序,仍然 没有异常处理,程序才会被终止
    • 在开发中,可以在主函数中增加 异常捕获
    • 而在主函数中调用的其他函数,只要出现异常,都会传递到主函数的 异常捕获 中
    • 这样就不需要在代码中,增加大量的 异常捕获,能够保证代码的整洁

    需求

    1. 定义函数 demo1() 提示用户输入一个整数并且返回
    2. 定义函数 demo2() 调用 demo1()
    3. 在主程序中调用 demo2()
    def demo1():
        return int(input("请输入一个整数:"))
    
    
    def demo2():
        return demo1()
    
    try:
        print(demo2())
    except ValueError:
        print("请输入正确的整数")
    except Exception as result:
        print("未知错误 %s" % result)

    统一声明:关于原创博客内容,可能会有部分内容参考自互联网,如有原创链接会声明引用;如找不到原创链接,在此声明如有侵权请联系删除哈。关于转载博客,如有原创链接会声明;如找不到原创链接,在此声明如有侵权请联系删除哈。 

    展开全文
  • 主要介绍了Python中的错误和异常处理简单操作,结合实例形式分析了Python中try except在错误与异常处理中的用法,需要的朋友可以参考下
  • Python 脚本编写

    万次阅读 多人点赞 2018-07-14 19:50:05
    :如果 Python 在运行 try 块时遇到异常,它将跳到 处理该异常的 except 块 。 else :如果 Python 在运行 try 块时没有遇到异常 ,它将在运行 try 块后运行 该块中的代码。 finally :在 Python 离开此 try ...

    学习内容:

    • Python 安装和环境设置
    • 运行和修改 Python 脚本
    • 与用户输入交互
    • 处理异常
    • 读写文件
    • 导入本地、标准和第三方模块
    • 在解释器中进行实验

    安装 Python

    检查计算机是否安装了 Python ?

    在终端窗口输入如下指令,并按回车

    python --version

    系统可能会显示已安装的 Python 版本是 Python 2.7.9。在这种情况下,表明你已经安装了 Python 2。如果版本号以 3 开头,则表明你已经安装了 Python 3!请勿再次安装 Python!

    下载/安装 Anaconda

    如果你对数据科学方面的 Python 感兴趣,强烈建议安装Anaconda,即使你已经在计算机上安装了 Python。

    Anaconda 和 Jupyter notebook 已经成为数据分析的标准环境。简单来说,Anaconda是包管理器和环境管理器,Jupyter notebook 可以将数据分析的代码、图像和文档全部组合到一个web文档中。

    Anaconda 安装教程

    下载/安装 Python

    Python 下载,找到适用于你的操作系统、下载 3 开头的最新版本。

    如果你使用的是 Windows 设备,确保在安装过程中选中 Add Python 3.5 to PATHAdd Python to environment variables 选项,这样可以确保从命令行提示符窗口中访问 Python。

    如果你使用的是 Windows 设备,并且已经安装了 Python,但是未选中上述选项,则需要将 Python 添加到 PATH。这样的话,当你输入 python 时,可以告诉命令行运行 Python 3。如果你未选中上述选项,或者转到下一阶段时似乎不可行,请按照 Python 文档中的这些说明将 Python 添加到 PATH。

    运行 Python 脚本

    将 Python3 下载并配置好后,在终端窗口检查是否配置成功

    ...$ python --version
    Python 3.6.6 :: Anaconda custom (64-bit)

    在终端窗口使用 cd 命令转到包含 .py 的 python 文件目录,运行该文件,查看结果

    ...$ cd ..
    ...$ cd /udacity/python
    ...$ ls
    first_script.py untitled.py
    ...$ python first_script.py
    Congratulations on running this script!!

    配置 Python 编程环境

    推荐的文本编辑器

    下载并安装好后,需要将我们新下载的 Python3 与 Sublime 编辑器关联。可以参考文章 Mac下Sublime Text3配置Python3开发环境

    内置函数 input()

    我们可以使用内置函数 input 获取用户的原始输入,该函数接受一个可选字符串参数,用于指定在要求用户输入时向用户显示的消息。

    name = input("Enter your name: ")
    print("Hello there, {}!".format(name.title()))

    input 函数获取用户输入的任何内容并将其存储为字符串。如果你想将输入解析为字符串之外的其他类型,例如整数(如以下示例所示),需要用新的类型封装结果并从字符串转换为该类型。

    num = int(input("Enter an integer"))
    print("hello" * num)

    我们还可以使用内置函数 eval 将用户输入解析为 Python 表达式。该函数会将字符串评估为一行 Python 代码

    result = eval(input("Enter an expression: "))
    print(result)
    # 输出
    ...$ python untitled.py
    Enter an expression: 3*2 
    6

    示例

    1. 请求用户输入三次。一次是名字列表,一次是未交作业数量列表,一次是分数列表。使用该输入创建 namesassignmentsgrades 列表。
    2. 使用循环为每个学生输出一条信息并包含正确的值。潜在分数是 2 乘以未交作业数加上当前分数。
    names = (input("Enter names separated by commas: ")).split(",")
    assignments = ((input("Enter assignment counts separated by commas: "))).split(",")
    grades = ((input("Enter grades separated by commas: "))).split(",")
    
    result = """
    Hi {},\n\nThis is a reminder that you have {} assignments left to \
    submit before you can graduate. Your current grade is {} and can increase \
    to {} if you submit all assignments before the due date.\n\n 
    """
    
    for name, assignment, grade in zip(names, assignments, grades):
        print(result.format(name, assignment, grade, 2*int(assignment)+int(grade) ))
    # 命令窗口输入输出
    ...$ python untitled.py
    Enter names separated by commas: Chandler bing,Phoebe Buffay,Monica Geller,Ross Geller
    Enter assignment counts separated by commas: 3,6,0,2
    Enter grades separated by commas: 81,77,92,88
    
    Hi Chandler bing,
    
    This is a reminder that you have 3 assignments left to submit before you can graduate. Your current grade is 81 and can increase to 87 if you submit all assignments before the due date.
    
    Hi Phoebe Buffay,
    
    This is a reminder that you have 6 assignments left to submit before you can graduate. Your current grade is 77 and can increase to 89 if you submit all assignments before the due date.
    
    Hi Monica Geller,
    
    This is a reminder that you have 0 assignments left to submit before you can graduate. Your current grade is 92 and can increase to 92 if you submit all assignments before the due date.
    
    Hi Ross Geller,
    
    This is a reminder that you have 2 assignments left to submit before you can graduate. Your current grade is 88 and can increase to 92 if you submit all assignments before the due date.   

    错误与异常

    • 错误,当 Python 无法解析代码时,就会发生语法错误,因为我们没有遵守正确的 Python 语法。当你出现拼写错误或第一次开始学习 Python 时,可能会遇到这些错误。
    • 异常,当在程序执行期间出现意外情况时,就会发生异常,即使代码在语法上正确无误。Python 有不同类型的内置异常,你可以在错误消息中查看系统抛出了什么异常。

    如果你没有使用正确的语法,并且 Python 不知道如何运行你的代码,会发生语法错误。

    如果 Python 在执行代码时遇到意外情形,会发生异常,即使你采用了正确的语法,也可能会发生异常。

    处理异常

    Try 语句

    我们可以使用 try 语句 来处理异常。

    • try:这是 try 语句中的唯一必需子句。该块中的代码是 Python 在 try 语句中首先运行的代码
    • except:如果 Python 在运行 try 块时遇到异常,它将跳到处理该异常的 except 块
    • else:如果 Python 在运行 try 块时没有遇到异常,它将在运行 try 块后运行该块中的代码。
    • finally:在 Python 离开此 try 语句之前,在任何情形下它都将运行此 finally 块中的代码,即使要结束程序,例如:如果 Python 在运行 except 或 else 块中的代码时遇到错误,在停止程序之前,依然会执行此finally 块。

    为何在 Python 中需要 finally 子句?

    您可以使用它 finally 来确保文件或资源是否已关闭或释放,无论是否发生异常,即使您没有捕获到异常。

    指定异常

    我们可以指定要在 except 块中处理哪个错误,如下所示:

    try:
        # some code
    except ValueError:
        # some code

    现在它会捕获 ValueError 异常,但是不会捕获其他异常。如果我们希望该处理程序处理多种异常,我们可以在 except 后面添加异常元组。

    try:
        # some code
    except (ValueError, KeyboardInterrupt):
        # some code

    或者,如果我们希望根据异常执行不同的代码块,可以添加多个 except 块。

    try:
        # some code
    except ValueError:
        # some code
    except KeyboardInterrupt:
        # some code

    访问异常信息

    try:
        # some code
    except ZeroDivisionError as e:
       # some code
       print("ZeroDivisionError occurred: {}".format(e))
       # 输出
       ZeroDivisionError occurred: division by zero

    因此依然可以访问错误消息,即使已经处理异常以防止程序崩溃!

    Exception 是所有内置异常的基础类。你可以在此处详细了解 Python 的异常。

    读写文件

    读取文件

    f = open('my_path/my_file.txt', 'r')
    file_data = f.read()
    f.close()
    1. 首先使用内置函数 open打开文件。需要文件路径字符串。open 函数会返回文件对象,它是一个 Python 对象,Python 通过该对象与文件本身交互。在此示例中,我们将此对象赋值给变量 f。
    2. 你可以在 open 函数中指定可选参数。参数之一是打开文件时采用的模式。在此示例中,我们使用 r,即只读模式。这实际上是模式参数的默认值
    3. 使用 read 访问文件对象的内容。该 read 方法会接受文件中包含的文本并放入字符串中。在此示例中,我们将该方法返回的字符串赋值给变量 file_data。
    4. 当我们处理完文件后,使用 close 方法释放该文件占用的系统资源

    代码中 f.read() 调用没有传入参数。它自动变成从当前位置读取文件的所有剩余内容,即整个文件。如果向 .read() 传入整型参数,它将读取长度是这么多字符的内容,输出所有内容,并使 ‘window’ 保持在该位置以准备继续读取

    with open(camelot.txt) as song:
        print(song.read(2))
        print(song.read(8))
        print(song.read())
    # 输出
    """
    We
    're the 
    knights of the round table
    We dance whenever we're able    """

    文本块中的 \n 是换行符。换行符表示一行的结束,告诉程序(例如文本编辑器)转到下一行。但是,对于文件中的一系列字符来说,\n 只是另一个字符。 幸运的是,Python 知道这些是特殊字符,你可以要求 Python 每次读取一行。

    f.readline(),读取文件下一行的方法。

    很方便的是,Python 将使用语法 for line in file 循环访问文件中的各行内容。 我可以使用该语法创建列表中的行列表。因为每行依然包含换行符,因此我使用 .strip() 删掉换行符。

    camelot_lines = []
    with open("camelot.txt") as f:
        for line in f:
            camelot_lines.append(line.strip())
    
    print(camelot_lines)
    # 输出
    """
    ["We're the knights of the round table", "We dance whenever we're able"]"""

    写入文件

    f = open('my_path/my_file.txt', 'w')
    f.write("Hello there!")
    f.close()
    1. 写入 ('w') 模式打开文件。如果文件不存在,Python 将为你创建一个文件。如果以写入模式打开现有文件,该文件中之前包含的所有内容将被删除。如果你打算向现有文件添加内容,但是不删除其中的内容,可以使用附加('a') 模式,而不是写入模式。
    2. 使用 write 方法向文件中添加文本
    3. 操作完毕后,关闭文件

    With

    Python 提供了一个特殊的语法,该语法会在你使用完文件后自动关闭该文件

    with open('my_path/my_file.txt', 'r') as f:
        file_data = f.read()

    with 关键字使你能够打开文件,对文件执行操作,并在缩进代码(在此示例中是读取文件)执行之后自动关闭文件。现在,我们不需要调用 f.close() 了!你只能在此缩进块中访问文件对象 f

    导入本地脚本

    我们实际上可以导入其他脚本中的 Python,如果你处理的是大型项目,需要将代码整理成多个文件并重复利用这些文件中的代码,则导入脚本很有用。如果你要导入的 Python 脚本与当前脚本位于同一个目录下,只需输入 import,然后是文件名无需扩展名 .py

    import useful_functions

    Import 语句写在 Python 脚本的顶部,每个导入语句各占一行。该 import 语句会创建一个模块对象,叫做 useful_functions。模块是包含定义和语句的 Python 文件。要访问导入模块中的对象,需要使用点记法

    import useful_functions
    useful_functions.add_five([1, 2, 3, 4])

    我们可以为导入模块添加别名,以使用不同的名称引用它。

    import useful_functions as uf
    uf.add_five([1, 2, 3, 4])

    使用 if main

    为了避免运行从其他脚本中作为模块导入的脚本中的可执行语句,将这些行包含在 if __name__ == "__main__" 块中。或者,将它们包含在函数 main() 中并在 if main 块中调用该函数。

    每当我们运行此类脚本时,Python 实际上会为所有模块设置一个特殊的内置变量 __name__。当我们运行脚本时,Python 会将此模块识别为主程序,并将此模块的 name 变量设为字符串 "__main__"。对于该脚本中导入的任何模块,这个内置 name 变量会设为该模块的名称。因此,条件 if __name__ == "__main__" 会检查该模块是否为主程序。

    # demo.py
    
    import useful_functions as uf
    
    scores = [88, 92, 79, 93, 85]
    
    mean = uf.mean(scores)
    curved = uf.add_five(scores)
    
    mean_c = uf.mean(curved)
    
    print("Scores:", scores)
    print("Original Mean:", mean, " New Mean:", mean_c)
    
    print(__name__)
    print(uf.__name__)
    # useful_functions.py
    
    def mean(num_list):
        return sum(num_list) / len(num_list)
    
    def add_five(num_list):
        return [n + 5 for n in num_list]
    
    def main():
        print("Testing mean function")
        n_list = [34, 44, 23, 46, 12, 24]
        correct_mean = 30.5
        assert(mean(n_list) == correct_mean)
    
        print("Testing add_five function")
        correct_list = [39, 49, 28, 51, 17, 29]
        assert(add_five(n_list) == correct_list)
    
        print("All tests passed!")
    
    if __name__ == '__main__':
        main()

    标准库的模块

    上面介绍了我们如何导入自己的模块,但 Python 也内置了完整的标准库模块。标准库里面有大量实用模块,我们可以将这个库看作是一个非常庞大的工具集,帮助我们轻松获取和使用现有代码大大增强我们的编程技能。

    Python 标准库详细介绍了每种模块,模块按照用途分类。标准库中的每个模块都是全小写形式。在使用每个模块时,建议阅读相关的页面。

    推荐模块

    Python 标准库包含大量模块!为了帮助你熟悉那些实用的模块,我们在下面筛选了一些我们推荐的 Python 标准库模块并解释为何我们喜欢使用它们!

    • csv:对于读取 csv 文件来说非常便利
    • collections:常见数据类型的实用扩展,包括 OrderedDictdefaultdictnamedtuple
    • random:生成假随机数字,随机打乱序列并选择随机项
    • string:关于字符串的更多函数。此模块还包括实用的字母集合,例如 string.digits(包含所有字符都是有效数字的字符串)
    • re:通过正则表达式在字符串中进行模式匹配
    • math:一些标准数学函数
    • os:与操作系统交互
    • os.pathos 的子模块,用于操纵路径名称
    • sys:直接使用 Python 解释器
    • json:适用于读写 json 文件(面向网络开发)。

    导入模块技巧

    1.要从模块中导入单个函数或类:

    from module_name import object_name

    2.要从模块中导入多个单个对象:

    from module_name import first_object, second_object

    3.要重命名模块:

    import module_name as new_name

    4.要从模块中导入对象并重命名:

    from module_name import object_name as new_name

    5.要从模块中单个地导入所有对象,请使用标准导入 module_name 语句并使用点记法访问每个对象。

    import module_name

    为了更好地管理代码,Standard 标准库中的模块被拆分成了子模块并包含在软件包中。软件包是一个包含子模块的模块。子模块使用普通的点记法指定。

    子模块的指定方式是软件包名称、点,然后是子模块名称。你可以如下所示地导入子模块。

    import package_name.submodule_name

    第三方库

    独立开发者编写了成千上万的第三方库!你可以使用 pip 安装这些库。pip 是在 Python 3 中包含的软件包管理器,它是标准 Python 软件包管理器,但并不是唯一的管理器。另一个热门的管理器是 Anaconda,该管理器专门针对数据科学。

    要使用 pip 安装软件包,在命令行中输入“pip install”,然后是软件包名称,如下所示:pip install package_name。该命令会下载并安装该软件包,以便导入你的程序中。安装完毕后,你可以使用从标准库中导入模块时用到的相同语法导入第三方软件包。

    使用 requirements.txt 文件

    大型 Python 程序可能依赖于十几个第三方软件包。为了更轻松地分享这些程序,程序员经常会在叫做 requirements.txt 的文件中列出项目的依赖项。下面是一个 requirements.txt 文件示例。

    beautifulsoup4==4.5.1
    bs4==0.0.1
    pytz==2016.7
    requests==2.11.1

    该文件的每行包含软件包名称和版本号。版本号是可选项,但是通常都会包含。不同版本的库之间可能变化不大,可能截然不同,因此有必要使用程序作者在写程序时用到的库版本。

    你可以使用 pip 一次性安装项目的所有依赖项,方法是在命令行中输入 pip install -r requirements.txt

    实用的第三方软件包

    能够安装并导入第三方库很有用,但是要成为优秀的程序员,还需要知道有哪些库可以使用。大家通常通过在线推荐或同事介绍了解实用的新库。如果你是一名 Python 编程新手,可能没有很多同事,因此为了帮助你了解入门信息,下面是优达学城工程师很喜欢使用的软件包列表。(可能部分网站在国内网络中无法打开)

    • IPython - 更好的交互式 Python 解释器。
    • requests - 提供易于使用的方法来发出网络请求。适用于访问网络 API。
    • Flask - 一个小型框架,用于构建网络应用和 API。
    • Django - 一个功能更丰富的网络应用构建框架。Django 尤其适合设计复杂、内容丰富的网络应用。
    • Beautiful Soup - 用于解析 HTML 并从中提取信息。适合网页数据抽取。
    • pytest - 扩展了 Python 的内置断言,并且是最具单元性的模块。
    • PyYAML - 用于读写 YAML 文件。
    • NumPy - 用于使用 Python 进行科学计算的最基本软件包。它包含一个强大的 N 维数组对象和实用的线性代数功能等。
    • pandas - 包含高性能、数据结构和数据分析工具的库。尤其是,pandas 提供 dataframe!
    • matplotlib - 二维绘制库,会生成达到发布标准的高品质图片,并且采用各种硬拷贝格式和交互式环境。
    • ggplot - 另一种二维绘制库,基于 R’s ggplot2 库。
    • Pillow - Python 图片库可以向你的 Python 解释器添加图片处理功能。
    • pyglet - 专门面向游戏开发的跨平台应用框架。
    • Pygame - 用于编写游戏的一系列 Python 模块。
    • pytz - Python 的世界时区定义。

    文章只是作为个人记录学习使用,如有不妥之处请指正,谢谢。

    展开全文
  • Scala Try 与错误处理

    千次阅读 2018-11-01 21:22:05
    一.概述 当你在尝试一门新的语言时,可能...事实会表明,Scala 能够很优雅的处理此类问题, 这一部分,我会介绍 Scala 基于 Try 的错误处理机制,以及这背后的原因。 我将使用一个在 Scala 2.10 新引入的特性,该...

    一.概述

    当你在尝试一门新的语言时,可能不会过于关注程序出错的问题, 但当真的去创造可用的代码时,就不能再忽视代码中的可能产生的错误和异常了。 鉴于各种各样的原因,人们往往低估了语言对错误处理支持程度的重要性。

    事实会表明,Scala 能够很优雅的处理此类问题, 这一部分,我会介绍 Scala 基于 Try 的错误处理机制,以及这背后的原因。 我将使用一个在 Scala 2.10 新引入的特性,该特性向 2.9.3 兼容, 因此,请确保你的 Scala 版本不低于 2.9.3。

    二.异常抛出与捕获

    2.1 其他语言的错误处理机制

    在介绍 Scala 错误处理的惯用法之前,我们先看看其他语言(如,Java,Ruby)的错误处理机制。 和这些语言类似,Scala 也允许你抛出异常:

    case class Customer(age: Int)
    class Cigarettes
    case class UnderAgeException(message: String) extends Exception(message)
    def buyCigarettes(customer: Customer): Cigarettes =
      if (customer.age < 16)
        throw UnderAgeException(s"Customer must be older than 16 but was ${customer.age}")
      else new Cigarettes
    

    被抛出的异常能够以类似 Java 中的方式被捕获,虽然是使用偏函数来指定要处理的异常类型。 此外,Scala 的 try/catch 是表达式(返回一个值),因此下面的代码会返回异常的消息:

    val youngCustomer = Customer(15)
    try {
      buyCigarettes(youngCustomer)
      "Yo, here are your cancer sticks! Happy smokin'!"
    } catch {
        case UnderAgeException(msg) => msg
    }
    

    2.2 函数式的错误处理

    现在,如果代码中到处是上面的异常处理代码,那它很快就会变得丑陋无比,和函数式程序设计非常不搭。 对于高并发应用来说,这也是一个很差劲的解决方式,比如, 假设需要处理在其他线程执行的 actor 所引发的异常,显然你不能用捕获异常这种处理方式, 你可能会想到其他解决方案,例如去接收一个表示错误情况的消息。

    一般来说,在 Scala 中,好的做法是通过从函数里返回一个合适的值来通知人们程序出错了。 别担心,我们不会回到 C 中那种需要使用按约定进行检查的错误编码的错误处理。 相反,Scala 使用一个特定的类型来表示可能会导致异常的计算,这个类型就是 Try。

    Try 的语义

    解释 Try 最好的方式是将它与 Option 作对比。

    Option[A] 是一个可能有值也可能没值的容器, Try[A] 则表示一种计算: 这种计算在成功的情况下,返回类型为 A 的值,在出错的情况下,返回 Throwable 。 这种可以容纳错误的容器可以很轻易的在并发执行的程序之间传递。

    Try 有两个子类型:

    • Success[A]:代表成功的计算。
    • 封装了 Throwable 的 Failure[A]:代表出了错的计算。

    如果知道一个计算可能导致错误,我们可以简单的使用 Try[A] 作为函数的返回类型。 这使得出错的可能性变得很明确,而且强制客户端以某种方式处理出错的可能。

    假设,需要实现一个简单的网页爬取器:用户能够输入想爬取的网页 URL, 程序就需要去分析 URL 输入,并从中创建一个 java.net.URL :

    import scala.util.Try
    import java.net.URL
    def parseURL(url: String): Try[URL] = Try(new URL(url))
    

    正如你所看到的,函数返回类型为 Try[URL]: 如果给定的 url 语法正确,这将是 Success[URL], 否则, URL 构造器会引发 MalformedURLException ,从而返回值变成 Failure[URL] 类型。

    上例中,我们还用了 Try 伴生对象里的 apply 工厂方法,这个方法接受一个类型为 A 的 传名参数, 这意味着, new URL(url) 是在 Tryapply 方法里执行的。

    apply 方法会捕获任何非致命的异常,返回一个包含相关异常的 Failure 实例。

    因此, parseURL(“http://danielwestheide.com”) 会返回一个 Success[URL] ,包含了解析后的网址, 而 parseULR(“garbage”) 将返回一个含有 MalformedURLExceptionFailure[URL]

    三. 使用 Try

    3.1 初步使用 Try

    使用 Try 与使用 Option 非常相似,在这里你看不到太多新的东西。

    你可以调用 isSuccess 方法来检查一个 Try 是否成功,然后通过 get 方法获取它的值, 但是,这种方式的使用并不多见,因为你可以用 getOrElse 方法给 Try 提供一个默认值:

    val url = parseURL(Console.readLine("URL: ")) getOrElse new URL("http://duckduckgo.com")
    

    如果用户提供的 URL 格式不正确,我们就使用 DuckDuckGo 的 URL 作为备用。

    3.2 链式操作

    Try 最重要的特征是,它也支持高阶函数,就像 Option 一样。 在下面的示例中,你将看到,在 Try 上也进行链式操作,捕获可能发生的异常,而且代码可读性不错。

    Mapping 和 Flat Mapping

    将一个是 Success[A]Try[A] 映射到 Try[B] 会得到 Success[B] 。 如果它是 Failure[A] ,就会得到 Failure[B] ,而且包含的异常和 Failure[A] 一样。

    parseURL("http://danielwestheide.com").map(_.getProtocol)
    // results in Success("http")
    parseURL("garbage").map(_.getProtocol)
    // results in Failure(java.net.MalformedURLException: no protocol: garbage)
    

    如果链接多个 map 操作,会产生嵌套的 Try 结构,这并不是我们想要的。 考虑下面这个返回输入流的方法:

    import java.io.InputStream
    def inputStreamForURL(url: String): Try[Try[Try[InputStream]]] = parseURL(url).map { u =>
     Try(u.openConnection()).map(conn => Try(conn.getInputStream))
    }
    

    由于每个传递给 map 的匿名函数都返回 Try,因此返回类型就变成了 Try[Try[Try[InputStream]]]
    这时候, flatMap 就派上用场了。 Try[A] 上的 flatMap 方法接受一个映射函数,这个函数类型是 (A) => Try[B]。 如果我们的 Try[A] 已经是 Failure[A] 了,那么里面的异常就直接被封装成 Failure[B] 返回, 否则, flatMapSuccess[A] 里面的值解包出来,并通过映射函数将其映射到 Try[B]
    这意味着,我们可以通过链接任意个 flatMap 调用来创建一条操作管道,将值封装在 Success 里一层层的传递。
    现在让我们用 flatMap 来重写先前的例子:

    def inputStreamForURL(url: String): Try[InputStream] =
     parseURL(url).flatMap { u =>
       Try(u.openConnection()).flatMap(conn => Try(conn.getInputStream))
     }
    

    这样,我们就得到了一个 Try[InputStream], 它可以是一个 Failure,包含了在 flatMap 过程中可能出现的异常; 也可以是一个 Success,包含了最后的结果。
    过滤器和 foreach

    过滤器和 foreach

    当然,你也可以对 Try 进行过滤,或者调用 foreach ,如果你已经学过 Option,对于这两个方法也不会陌生。

    当一个 Try 已经是 Failure 了,或者传递给它的谓词函数返回假值,filter 就返回 Failure (如果是谓词函数返回假值,那 Failure 里包含的异常是 NoSuchException ), 否则的话, filter 就返回原本的那个 Success ,什么都不会变:

    def parseHttpURL(url: String) = parseURL(url).filter(_.getProtocol == "http")
    parseHttpURL("http://apache.openmirror.de") // results in a Success[URL]
    parseHttpURL("ftp://mirror.netcologne.de/apache.org") // results in a Failure[URL]
    

    当一个 TrySuccess 时, foreach 允许你在被包含的元素上执行副作用, 这种情况下,传递给 foreach 的函数只会执行一次,毕竟 Try 里面只有一个元素:

     parseHttpURL("http://danielwestheide.com").foreach(println)
    
    

    当 Try 是 Failure 时, foreach 不会执行,返回 Unit 类型。

    for 语句中的 Try

    既然 Try 支持 flatMapmapfilter ,能够使用 for 语句也是理所当然的事情, 而且这种情况下的代码更可读。 为了证明这一点,我们来实现一个返回给定 URL 的网页内容的函数:

    import scala.io.Source
    def getURLContent(url: String): Try[Iterator[String]] =
      for {
       url <- parseURL(url)
       connection <- Try(url.openConnection())
       is <- Try(connection.getInputStream)
       source = Source.fromInputStream(is)
      } yield source.getLines()
    

    这个方法中,有三个可能会出错的地方,但都被 Try 给涵盖了。 第一个是我们已经实现的 parseURL 方法, 只有当它是一个 Success[URL] 时,我们才会尝试打开连接,从中创建一个新的 InputStream 。 如果这两步都成功了,我们就 yield 出网页内容,得到的结果是 Try[Iterator[String]]

    当然,你可以使用 Source#fromURL 简化这个代码,并且,这个代码最后没有关闭输入流, 这都是为了保持例子的简单性,专注于要讲述的主题。

    在这个例子中,Source#fromURL可以这样用:

    import scala.io.Source
    def getURLContent(url: String): Try[Iterator[String]] =
      for {
        url <- parseURL(url)
        source = Source.fromURL(url)
      } yield source.getLines()
    

    用 is.close() 可以关闭输入流。

    模式匹配

    代码往往需要知道一个 Try 实例是 Success 还是 Failure,这时候,你应该想到模式匹配, 也幸好, SuccessFailure 都是样例类。

    接着上面的例子,如果网页内容能顺利提取到,我们就展示它,否则,打印一个错误信息:

    import scala.util.Success
    import scala.util.Failure
    getURLContent("http://danielwestheide.com/foobar") match {
      case Success(lines) => lines.foreach(println)
      case Failure(ex) => println(s"Problem rendering URL content: ${ex.getMessage}")
    }
    
    从故障中恢复

    如果想在失败的情况下执行某种动作,没必要去使用 getOrElse, 一个更好的选择是 recover ,它接受一个偏函数,并返回另一个 Try。 如果 recover 是在 Success 实例上调用的,那么就直接返回这个实例,否则就调用偏函数。 如果偏函数为给定的 Failure 定义了处理动作, recover 会返回 Success ,里面包含偏函数运行得出的结果。

    下面是应用了 recover 的代码:

    import java.net.MalformedURLException
    import java.io.FileNotFoundException
    val content = getURLContent("garbage") recover {
      case e: FileNotFoundException => Iterator("Requested page does not exist")
      case e: MalformedURLException => Iterator("Please make sure to enter a valid URL")
      case _ => Iterator("An unexpected error has occurred. We are so sorry!")
    }
    

    现在,我们可以在返回值 content 上安全的使用 get 方法了,因为它一定是一个 Success。 调用 content.get.foreach(println) 会打印 Please make sure to enter a valid URL。

    四. 总结

    Scala 的错误处理和其他范式的编程语言有很大的不同。 Try 类型可以让你将可能会出错的计算封装在一个容器里,并优雅的去处理计算得到的值。 并且可以像操作集合和 Option 那样统一的去操作 Try。

    Try 还有其他很多重要的方法,鉴于篇幅限制,这一章并没有全部列出,比如 orElse 方法, transformrecoverWith 也都值得去看。

    文章转自:https://windor.gitbooks.io/beginners-guide-to-scala/content/chp6-error-handling-with-try.html

    展开全文
  • C++ try……catch catch(CException *e) 打印异常信息 不经意间的内存泄露:try-catch(CException *e) [异常对象需要手动释放] C++ try catch 捕获空指针异常,数组越界异常 C++ try catch 异常类 异常类大全 C...
  • 一、Java IO流 1、概念 在Java中,把不同的...Java 把所有传统的”流“放在了 java . io 包下 2、IO流的分类(按流向划分) 输入流:只能从中读取数据,不能写入 输出流:只能写入数据,不能读取数据 3、IO流...
  • C#_try语句

    万次阅读 2020-01-27 22:51:55
    try语句定义 try 语句提供一种机制,用于捕捉在块的执行期间发生的各种异常。此外,try 语句还能让您指定一个代码块,并保证当控制离开 try 语句时,总是先执行该代码。 try-statement: try block catch-clauses...
  • try与except处理异常语句

    千次阅读 2019-08-21 11:43:11
    try/except介绍: 与其他语言相同,在python中,try/except语句主要是用于处理程序正常执行过程中出现的一些异常情况,如语法错(python作为脚本语言没有编译的环节,在执行过程中对语法进行检测,出错后发出异常...
  • Java笔试面试题整理第八波

    万次阅读 多人点赞 2016-06-14 11:07:41
    泛型在编译通过后,确保了类型正确,此后就擦除了相关泛型信息,把所有元素都作为Person数据类型 。也就是说, 泛型类型在逻辑上我们可以看成是多个不同的数据类型,但是在本质上它只是同一种数据类型 。 ...
  • try catch 捕获异常

    千次阅读 2016-04-07 14:08:43
    注意下面一种形式: void ExceptionFunction(argument…) throw() 表明没有任何异常抛出。 而正常的void ExceptionFunction(argument…)则表示:可能抛出任何一种异常,当然,也可能没有异常,...
  • go语言中的try、catch、throw实现

    千次阅读 2018-12-09 13:16:02
    go中很多函数有error类型的返回值,如果希望以异常的形式抛出,可以调用panic让recover函数捕获,如: func (o *MsSqlUtils) ExecuteWithTrans(callback TransCallback) (err1 error) { defer func() { //必须...
  • 使用try catch捕捉异常

    千次阅读 2018-05-07 21:06:58
    /* 处理异常的第二种方式:捕捉 try...catch.. 语法: try{ 可能出现的异常的代码; }catch(异常类型1 变量){ 处理异常的代码; }catch(异常类型2 变量1){ 处理异常的代码 }...
  • Python中try语句的用法

    千次阅读 2019-07-13 01:04:40
    1. try except语句的用法,用来检测一段代码内出现的异常并将其归类输出相关信息,首先是try: 被检测代码段 except Exception[as reason]: 相关信息,举例说明: try: f = open('该文档不存在') print(f.read()) ...
  • try/except介绍

    万次阅读 2019-03-14 20:43:00
    try/except介绍 与其他语言相同,在python中,try/except语句主要是用于处理程序正常执行过程中出现的一些异常情况,如语法错(python作为脚本语言没有编译的环节,在执行过程中对语法进行检测,出错后发出异常消息...
  • a:try/except:拦截由Python或者自己的代码引起的异常并从中恢复。 很多人学习python,不知道从何学起。 很多人学习python,掌握了基本语法过后,不知道在哪里寻找案例上手。 很多已经做案例的人,却不知道如何去...
  • python - try-except 语句

    千次阅读 2019-09-20 17:46:05
    try 语句有两种主要形式: try-except 和 try-finally . 这两个语句是互斥的, 也就是说你只能使用其中的一种 . 一个 try 语句可以对应一个或多个 except 子句 , 但只能对应一个finally 子句, 或是一个 try-except-...
  • 【python】详解 try 处理异常机制

    千次阅读 2018-06-25 15:08:46
    python的try语句有两种风格: ...try 语句子句形式表 except: 捕获所有异常 except name: 只捕获特定的异常 except name as value: 捕获异常和它的附加数据(将异常的信息保存到value,) except (name1,na...
  • try-with-resource:自动地关闭资源

    万次阅读 2019-01-08 19:37:45
    简而言之,当一个外部资源的句柄对象(比如FileInputStream对象)实现了AutoCloseable接口, 那么就可以将上面的板式代码简化为如下形式: public static void main(String[] args) { try (FileInputStream ...
  • try except异常

    千次阅读 2018-04-09 11:01:33
    异常处理在任何一门编程语言里都是值得关注的一个话题,良好的异常处理可以让你的程序更加健壮,清晰的错误信息更能帮助你快速修复...异常处理语句 try...excpet...finally实例代码defdiv(a, b):try:print(a / b)ex...
  • try catch 嵌套 try catch 肯定可以嵌套的,可以先来个嵌套小测试。 public static void main(String[] args) { try { System.out.println("**********************外层try**********************");...
  • python中的try-catch-finally-else简介

    万次阅读 多人点赞 2018-07-16 09:08:10
    一.try/catch简介 try/except语句主要是用于处理程序正常执行过程中出现的一些异常情况,如语法错误(python作为脚本语言没有编译的环节,在执行过程中对语法进行检测,出错后发出异常消息)、数据除零错误、从未...
  • Java:简述try-catch-finally异常捕获

    千次阅读 多人点赞 2019-02-14 17:02:58
    其一般语法形式为: try { // 可能会发生异常的程序代码 } catch (Type1 id1){ // 捕获并处置try抛出的异常类型Type1 } catch (Type2 id2){ //捕获并处置try抛出的异常类型Type2 } 关键词tr...
  • try-with-resources详解

    千次阅读 2017-07-05 17:59:48
    看下面一段例子static String readFirstLineFromFileWithFinallyBlock(String path) throws IOException { BufferedReader br = new BufferedReader(new FileReader(path));... try { return br.readLi
  • Tcl异常处理命令之try、throw

    千次阅读 2019-05-31 22:38:19
    try、throw

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 403,400
精华内容 161,360
关键字:

try的所有形式