精华内容
下载资源
问答
  • 详解 try 语句

    2021-01-25 09:38:05
    try 语句 try 语句可为一组语句指定异常处理器和/或清理代码。语法结构有两种如下。 有 try 和 except 子句(可多个),以及可选的 else 和 finally 子句: try: suite except expression as identifier: suite ...

    try 语句

    try 语句可为一组语句指定异常处理器和/或清理代码。语法结构有两种如下。

    • 有 try 和 except 子句(可多个),以及可选的 else 和 finally 子句:
    try:
        suite
    except expression as identifier:
        suite
    else: # 可选
        suite
    finally: # 可选
        suite
    
    • 只有 try 和 finally 子句:
    try:
        suite
    finally:
        suite
    

    except 子句之后的表达式(通常为异常)expression,关键字 as 以及指定的别名 identifier 都是可选的。

    当 try 子句中没有发生异常时,没有异常处理器会被执行。当 try 子句中发生异常时,将启动对异常处理器的搜索。此搜索会依次检查 except 子句,直至找到与该异常相匹配的子句。

    except 子句可指定一个或多个异常,如果与发生的异常 “兼容” 则该子句将匹配该异常。

    • 指定的异常如果是发生的异常所属的类或基类,则该子句将匹配该异常;
    • 指定的异常可以置于一个元组,其中包含有与发生的异常 “兼容” 的异常,该子句将匹配该异常。

    当一个异常完全未被处理时,解释器会终止程序的执行。

    for i in range(3):
        try:
            print(3/i)
        except (ZeroDivisionError, AssertionError) as e:
            print(e)
    
    division by zero
    3.0
    1.5
    
    for i in range(3):
        try:
            print(3/i)
        except ZeroDivisionError:
            print(f'i={i}引发异常')
    
    i=0引发异常
    3.0
    1.5
    
    for i in range(3):
        print(3/i)
    
    ---------------------------------------------------------------------------
    
    ZeroDivisionError                         Traceback (most recent call last)
    
    <ipython-input-5-ddbcfc1a1b1b> in <module>
          1 for i in range(3):
    ----> 2     print(3/i)
    
    
    ZeroDivisionError: division by zero
    

    如果存在无表达式的 except 子句,它必须是最后一个,它将匹配任何异常:

    try:
        3/0
    except NameError as n:
        print(n)
    except:
        pass
    

    如果没有 except 子句与异常相匹配,则会在周边代码和发起调用栈上继续搜索异常处理器,除非存在一个finally 子句正好引发了另一个异常。新引发的异常将导致旧异常的丢失:

    def f():
        try:
            return 3/0
        except NameError as n:
            print(n)
    try:
        f()
    except ZeroDivisionError as z:
        print(z)
    
    division by zero
    
    def f():
        try:
            return 3/0
        except NameError as n:
            print(n)
        finally:
            name1
            
    try:
        f()
    except ZeroDivisionError as z: # 该异常已丢失
        print(z)
    except NameError as n:
        print(n)
    
    name 'name1' is not defined
    

    使用 as 将匹配的异常赋值给一个别名,才能在 except 子句之后引用它,并且它将在 except 子句结束时被清除:

    for i in range(3):
        try:
            print(3/i)
        except (ZeroDivisionError, AssertionError) as e:
            print(e)
    print(e)
    
    division by zero
    3.0
    1.5
    
    
    
    ---------------------------------------------------------------------------
    
    NameError                                 Traceback (most recent call last)
    
    <ipython-input-16-a87e190baccb> in <module>
          4     except (ZeroDivisionError, AssertionError) as e:
          5         print(e)
    ----> 6 print(e)
    
    
    NameError: name 'e' is not defined
    

    如果控制流离开 try 子句体时没有引发异常,并且没有执行 return, continue 或 break 语句,可选的 else 子句将被执行:

    try:
        print('开始')
    except:
        print('捕获')
    else:
        print('结束')
    
    开始
    结束
    
    while True:    
        try:
            print('开始')
            break
        except:
            print('捕获')
        else:
            print('结束')
    
    开始
    

    如果存在 finally,它用来指定一个 “清理” 处理程序。try,except 或 else 子句中发生任何未处理的异常,会被临时保存。finally 始终被执行,被保存的异常,它会在 finally 子句执行后被重新引发:

    try:
        print(3/0)
    except:
        name2
    else: # 未被执行
        range(3)[5]
    finally:
        print('end')
    
    end
    
    
    
    ---------------------------------------------------------------------------
    
    ZeroDivisionError                         Traceback (most recent call last)
    
    <ipython-input-24-7d6fe0d94043> in <module>
          1 try:
    ----> 2     print(3/0)
          3 except:
    
    
    ZeroDivisionError: division by zero
    
    
    During handling of the above exception, another exception occurred:
    
    
    NameError                                 Traceback (most recent call last)
    
    <ipython-input-24-7d6fe0d94043> in <module>
          2     print(3/0)
          3 except:
    ----> 4     name2
          5 else: # 未被执行
          6     range(3)[5]
    
    
    NameError: name 'name2' is not defined
    

    如果 finally 子句引发了另一个异常,被保存的异常会被设为新异常的上下文。如果 finally 子句执行了 return, break 或 continue 语句,则被保存的异常会被丢弃:

    while True:    
        try:
            print('开始')
        except:
            print('捕获')
        else:
            range(3)[5]
        finally:
            print(3/0)
    
    开始
    
    
    
    ---------------------------------------------------------------------------
    
    IndexError                                Traceback (most recent call last)
    
    <ipython-input-25-1f272bfbd667> in <module>
          6     else:
    ----> 7         range(3)[5]
          8     finally:
    
    
    IndexError: range object index out of range
    
    
    During handling of the above exception, another exception occurred:
    
    
    ZeroDivisionError                         Traceback (most recent call last)
    
    <ipython-input-25-1f272bfbd667> in <module>
          7         range(3)[5]
          8     finally:
    ----> 9         print(3/0)
    
    
    ZeroDivisionError: division by zero
    
    while True:    
        try:
            print('开始')
        except:
            print('捕获')
        else:
            range(3)[5]
        finally:
            break
    
    开始
    

    当 return, break 或 continue 语句在 finally 语句之前被执行时,finally 子语句也会 ‘在离开时’ 被执行:

    while True:    
        try:
            print('开始')
        except:
            print('捕获')
        else:
            break
        finally:
            print('结束')
    
    开始
    结束
    
    def f():    
        try:
            return '开始'
        finally:
            print('结束')
    f() # 先执行 finally 再离开函数调用
    
    结束
    
    
    
    
    
    '开始'
    
    展开全文
  • 目录try-catch 语句:作用捕获异常语句js的错误类型: try-catch 语句:作用捕获异常语句 执行流程: 先执行try中的语句,如果有错误,就会将错误抛出,并且被catch捕获并去执行 ,这时候就会执行catch里的语句,...

    例如acynk去请求报错了,可以打印错误,并继续代码运行

    try-catch 语句:作用捕获异常语句

    执行流程:
    先执行try中的语句,如果有错误,就会将错误抛出,并且被catch捕获并去执行
    这时候就会执行catch里的语句,而且不论try中有没有抛出和错误,finally语句都会去执行其中自己的代码块

    我们来看下常见的一些错误:

     console.log(a);//Uncaught ReferenceError(引用错误): a is not defined
       
     var b = 'hello'
     b();//Uncaught TypeError(类型错误): b is not a function
    

    我们来看下try-catch的用法:

      try {     console.log(a);
            } catch {
                /  一旦代码出错,自动执行catch语句, 
                console.log('代码出错了');
            }
    

    注意: !!!!!!!!! 如果不需要输出错误信息,catch 后不需要()

    如果需要输出错误信息,对错误进行处理; catch 需要() 并且需要传入一个参数err (就是错误信息,这里用err语义化,可以用a);

       try {
            console.log(a);
        } catch (err) {
            //  捕获 err 就是错误信息,
            console.log(err);
        }
    

    在这里插入图片描述
    我们看到这个输出结果和下面这样的信息相同
    在这里插入图片描述
    finally 不管代码是否出错,都会执行
    先来看不出错的情况

     try {
                console.log(1);
         } catch (err) {
                console.log(err);
         } finally {
                //   finally此处的代码始终都会执行
                console.log('代码执行了');
         }
    

    在这里插入图片描述
    再来看下出错的情况

     try {
                console.log(a);
         } catch (err) {
                console.log(err);
         } finally {
                //   finally此处的代码始终都会执行
                console.log('代码执行了');
         }
    

    finally此处的代码始终都会执行
    在这里插入图片描述

    js的错误类型:

    • 1.SyntaxError(语法错误)

    • 2.ReferenceError(引用错误)

    • 3.RangeError(范围错误)

    • 4.TypeError(类型错误)

    • 5.URLError(URL错误)

    • 6.EvalError(eval错误)

      1. Error(错误)

    其中,Error是基类型,其他错误类型都继承自该类型。因此,所有错误类型共享了一组相同的属性。Error类型的错误很少见,如果有也是浏览器抛出的;这个基类型的主要目的是供开发人员抛出自定义错误

    【EvalError(eval错误)】

    eval函数没有被正确执行时,会抛出EvalError错误。该错误类型已经不再在ES5中出现了,只是为了保证与以前代码兼容,才继续保留

    【RangeError(范围错误)】

    RangeError类型的错误会在一个值超出相应范围时触发,主要包括超出数组长度范围以及超出数字取值范围等

    new Array(-1); //Uncaught RangeError: Invalid array length

    【ReferenceError(引用错误)】

    引用一个不存在的变量或左值(lvalue)类型错误时,会触发ReferenceError(引用错误)

     console.log(a);//Uncaught ReferenceError(引用错误): a is not defined
    

    【SyntaxError(语法错误)】

    当不符合语法规则时,会抛出SyntaxError(语法错误)

    【TypeError(类型错误)】

    在变量中保存着意外的类型时,或者在访问不存在的方法时,都会导致TypeError类型错误。错误的原因虽然多种多样,但归根结底还是由于在执行特定类型的操作时,变量的类型并不符合要求所致

     var b = 'hello'
     b();//Uncaught TypeError(类型错误): b is not a function
    

    【URIError(URI错误)】

    URIError是URI相关函数的参数不正确时抛出的错误,主要涉及encodeURI()、decodeURI()、encodeURIComponent()、decodeURIComponent()、escape()和unescape()这六个函数

     decodeURI('%2'); // URIError: URI malformed
    
    展开全文
  • try~Catch语句中异常的处理过程

    千次阅读 2014-10-12 21:38:32
    简单介绍try~catch~throw~finally

        【2014/10/12 21:40】文章待续~

    1.函数自身捕获处理异常的情况

        下面的例子介绍了try~catch语句中出现异常时语句的执行顺序:

    package month10;
    
    import java.lang.*;
    
    public class TryCatch{
    
    	/*
    	 * 函数产生一个ArithmeticException异常
    	 */
    	public static void First(){
    		System.out.println("第一个异常处理的例子");
    		try{
    			//double m=5.0/0;    在java中,浮点数double和float可以除0,返回无穷大
    			int m=5/0;
    			System.out.println(m+"第一个函数不会继续执行了");
    		}
    		catch(ArithmeticException e){
    			System.out.println("第一个函数捕获了异常");
    		}
    		finally{
    			System.out.println("第一个异常处理的例子结束");
    		}
    	}
    	
    	/*
    	 * 函数产生一个OutIndexOfException异常
    	 */
    	public static void Second(){
    		System.out.println("第二个异常处理的例子");
    		int[] arr=new int[3];
    		try{
    			for(int i=0;i<4;i++){
    				arr[i]=i;
    			}
    		}
    		catch(Exception e){
    			System.out.println("第二个函数捕获了异常");
    		}
    		finally{
    			System.out.println("第一个异常处理的例子结束");
    		}
    	}
    	
    	public static void main(String[] args) {
    		
    		System.out.println("程序运行开始");
    		First();
    		Second();
    		System.out.println("程序运行结束");
    
    	}
    
    }
    


        执行的结果如下:




    2. 函数自身不处理异常,抛出异常,直接外层函数处理

        try抛出了异常,try语句块中抛出异常之后的语句不会再被执行。

    package month10;
    
    import java.lang.*;
    
    public class TryCatch{
    
    	/*
    	 * 函数产生一个ArithmeticException异常
    	 */
    	public void First(){
    		System.out.println("第一个异常处理的例子");
    		try{
    			//double m=5.0/0;    在java中,浮点数double和float可以除0,返回无穷大
    			int m=5/0;
    			System.out.println(m+"第一个函数不会继续执行了");
    		}
    		catch(ArithmeticException e){
    			//throw用在程序中明确表示这里抛出一个异常。 后面跟一个异常对象(实例).
    			throw new ArithmeticException("ArithmeticException");
    			//后面不跟语句
    		}
    		finally{
    			System.out.println("第一个异常处理的例子结束");
    		}
    	}
    	
    	/*
    	 * 函数产生一个OutIndexOfException异常
    	 */
    	public void Second(){
    		System.out.println("第二个异常处理的例子");
    		int[] arr=new int[3];
    		try{
    			for(int i=0;i<4;i++){
    				arr[i]=i;
    			}
    		}
    		catch(ArrayIndexOutOfBoundsException e){
    			throw new ArithmeticException("ArrayIndexOutOfBoundsException");
    		}
    		finally{
    			//上面的例子这里写的输出语句有错误
    			System.out.println("第二个异常处理的例子结束");
    		}
    	}
    	
    	/*
    	 * 封装了First、Second
    	 */
    	public void Thrid(){
    		System.out.println("函数三将First/Second开始执行");
    		try{
    			First();
    			Second();
    		}
    		catch(Exception e){
    			System.out.println("接受异常"+e.getMessage());
    		}
    		System.out.println("函数三之后的语句");
    	}
    	
    	
    	public static void main(String[] args) {
    		
    		System.out.println("程序运行开始");
    		TryCatch temp=new TryCatch();
    		temp.Thrid();
    		System.out.println("程序运行结束");
    
    	}
    
    }
    

        函数的执行效果如下:




    3.函数抛出异常,向上抛,外层函数处理

        验证函数运行产生异常,外层函数既没有对异常进行捕获处理、亦没有声明抛出异常、异常信息是否会一直向上抛,直到被处理。

    package month10;
    
    import java.lang.*;
    
    public class TryCatch{
    
    	/*
    	 * 函数产生一个ArithmeticException异常
    	 */
    	public void First(){
    		System.out.println("第一个异常处理的例子");
    		try{
    			//double m=5.0/0;    在java中,浮点数double和float可以除0,返回无穷大
    			int m=5/0;
    			System.out.println(m+"第一个函数不会继续执行了");
    		}
    		catch(ArithmeticException e){
    			//throw用在程序中明确表示这里抛出一个异常。 后面跟一个异常对象(实例).
    			throw new ArithmeticException("ArithmeticException");
    			//后面不跟语句
    		}
    		finally{
    			System.out.println("第一个异常处理的例子结束");
    		}
    	}
    	
    	/*
    	 * 函数产生一个OutIndexOfException异常
    	 */
    	public void Second(){
    		System.out.println("第二个异常处理的例子");
    		int[] arr=new int[3];
    		try{
    			for(int i=0;i<4;i++){
    				arr[i]=i;
    			}
    		}
    		catch(ArrayIndexOutOfBoundsException e){
    			throw new ArithmeticException("ArrayIndexOutOfBoundsException");
    		}
    		finally{
    			//上面的例子这里写的输出语句有错误
    			System.out.println("第二个异常处理的例子结束");
    		}
    	}
    	
    	/*
    	 * 封装了First、Second,
    	 * 函数对First、Second抛出的异常不进行处理
    	 */
    	public void Thrid(){
    		
    		System.out.println("函数三将First/Second开始执行");	
    		First();
    		Second();	
    		System.out.println("函数三之后的语句");
    	}
    	
    	/*
    	 * 调用函数Thrid
    	 */
    	public void Four(){
    		try{
    			Thrid();
    		}
    		catch(Exception e){
    			System.out.println("函数3没有进行异常抛出,但是函数1的异常会一直向上抛,直到被捕获");
    		}
    		System.out.println("函数4之后的语句");
    	}
    	
    	public static void main(String[] args) {
    		
    		System.out.println("程序运行开始");
    		TryCatch temp=new TryCatch();
    		temp.Four();
    		System.out.println("程序运行结束");
    
    	}
    
    }
    

        运行结果如下:



     

    4.验证Checked Exception 是否也符合

        上面的例子都验证的是运行时异常,不能完全说明问题。现在,验证Checked Exception。

        :函数产生异常,若由函数调用者来捕获处理异常,继续之后的程序代码执行;若产生异常未捕获,异常会沿着调用栈下移,一直找到与之匹配的处理方法,若被处理,从处理的地方开始执行之后的代码;若到达调用栈底仍未找到,程序终止。

        添加了CExce()函数,用于生产FileNotFoundException异常。大家差分吧。

    package month10;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.lang.*;
    
    public class TryCatch{
    
    	/*
    	 * 函数产生一个ArithmeticException异常
    	 */
    	public void First(){
    		System.out.println("第一个异常处理的例子");
    		try{
    			//double m=5.0/0;    在java中,浮点数double和float可以除0,返回无穷大
    			int m=5/0;
    			System.out.println(m+"第一个函数不会继续执行了");
    		}
    		catch(ArithmeticException e){
    			//throw用在程序中明确表示这里抛出一个异常。 后面跟一个异常对象(实例).
    			throw new ArithmeticException("ArithmeticException");
    			//后面不跟语句
    		}
    		finally{
    			System.out.println("第一个异常处理的例子结束");
    		}
    	}
    	
    	/*
    	 * 函数产生一个OutIndexOfException异常
    	 */
    	public void Second(){
    		System.out.println("第二个异常处理的例子");
    		int[] arr=new int[3];
    		try{
    			for(int i=0;i<4;i++){
    				arr[i]=i;
    			}
    		}
    		catch(ArrayIndexOutOfBoundsException e){
    			throw new ArithmeticException("ArrayIndexOutOfBoundsException");
    		}
    		finally{
    			//上面的例子这里写的输出语句有错误
    			System.out.println("第二个异常处理的例子结束");
    		}
    	}
    	
    	/*
    	 * 封装了First、Second,
    	 * 函数对First、Second抛出的异常不进行处理
    	 * 添加了CExce()函数
    	 */
    	public void Thrid(){
    		
    		System.out.println("函数三将CExce/First/Second开始执行");	
    		
    		CExce();
    		First();
    		Second();
    		System.out.println("函数三之后的语句");
    	}
    	
    	/*
    	 * 调用函数Thrid
    	 */
    	public void Four(){
    		try{
    			Thrid();
    		}
    		catch(Exception e){
    			System.out.println("函数3没有进行异常抛出,此时Checked Exception异常函数Cexce的异常自己捕获处理了异常。此时捕获First的异常");
    		}
    		System.out.println("函数4之后的语句");
    	}
    	
    	/*
    	 * 
    	 */
    	public void CExce(){
    		FileInputStream fis=null;
    		FileOutputStream fos=null;
    		try{
    			//文件夹下没有这个文件,会产生FileNoFoundException。
    			fis=new FileInputStream("C:\\Users\\acer\\Pictures\\boke\\neojos.jpg");
    			fos=new FileOutputStream("rt.png");
    			byte[] b=new byte[1024];
    			int count=0;
    			while((count=fis.read(b))!=-1){						//int read(byte[] b)
    				fos.write(b,0,count);							//write(byte[]b,int off,int len)
    			}
    		}
    		catch(IOException e){
    			System.out.println("IO异常咯");
    		}
    		finally{
    			if(fis!=null){
    				try{
    					fis.close();
    				}
    				catch(IOException e){
    					System.out.println("error1");
    				}
    			}
    			if(fos!=null){
    				try{
    					fos.close();
    				}
    				catch(IOException e){
    					System.out.println("error2");
    				}
    			}
    			//System.out.println("IO over!");
    		}
    	}
    	
    	public static void main(String[] args) {
    		
    		System.out.println("程序运行开始");
    		TryCatch temp=new TryCatch();
    		temp.Four();
    		System.out.println("程序运行结束");
    
    	}
    }
    


    函数运行截图如下:



    5.函数体声明抛出异常Throws

        函数体声明异常,也就是在方法名后面加上throws ExceptionName,..., 方法本身只是抛出异常,由函数调用者来捕获异常。若产生异常,异常会沿着调用栈下移,一直找到与之匹配的处理方法,若到达调用栈底仍未找到,程序终止。

        编写代码,你会发现。对于Throw unchecked Exception的函数,必须在函数体方法声明时追加throws xxException,否则通不过编译器。在上面的例子中分别在CExce()和Third函数中追加。


    import java.lang.*;
    
    public class TryCatch{
    
    	/*
    	 * 函数产生一个ArithmeticException异常
    	 */
    	public void First(){
    		System.out.println("第一个异常处理的例子");
    		try{
    			//double m=5.0/0;    在java中,浮点数double和float可以除0,返回无穷大
    			int m=5/0;
    			System.out.println(m+"第一个函数不会继续执行了");
    		}
    		catch(ArithmeticException e){
    			//throw用在程序中明确表示这里抛出一个异常。 后面跟一个异常对象(实例).
    			throw new ArithmeticException("ArithmeticException");
    			//后面不跟语句
    		}
    		finally{
    			System.out.println("第一个异常处理的例子结束");
    		}
    	}
    	
    	/*
    	 * 函数产生一个OutIndexOfException异常
    	 */
    	public void Second(){
    		System.out.println("第二个异常处理的例子");
    		int[] arr=new int[3];
    		try{
    			for(int i=0;i<4;i++){
    				arr[i]=i;
    			}
    		}
    		catch(ArrayIndexOutOfBoundsException e){
    			throw new ArithmeticException("ArrayIndexOutOfBoundsException");
    		}
    		finally{
    			//上面的例子这里写的输出语句有错误
    			System.out.println("第二个异常处理的例子结束");
    		}
    	}
    	
    	/*
    	 * 封装了First、Second,
    	 * 函数对First、Second抛出的异常不进行处理
    	 * 添加了CExce()函数
    	 */
    	public void Thrid() throws IOException{
    		
    		System.out.println("函数三将CExce/First/Second开始执行");	
    		
    		CExce();
    		First();
    		Second();
    		System.out.println("函数三之后的语句");
    	}
    	
    	/*
    	 * 调用函数Thrid
    	 */
    	public void Four(){
    		try{
    			Thrid();
    		}
    		catch(Exception e){
    			System.out.println("函数3没有进行异常抛出,此时Checked Exception异常函数Cexce的异常自己捕获处理了异常。此时捕获First的异常");
    		}
    		System.out.println("函数4之后的语句");
    	}
    	
    	/*
    	 * 
    	 */
    	public void CExce()  throws FileNotFoundException{
    		FileInputStream fis=null;
    		FileOutputStream fos=null;
    		try{
    			//文件夹下没有这个文件,会产生FileNoFoundException。
    			fis=new FileInputStream("C:\\Users\\acer\\Pictures\\boke\\neojos.jpg");
    			fos=new FileOutputStream("rt.png");
    			byte[] b=new byte[1024];
    			int count=0;
    			while((count=fis.read(b))!=-1){						//int read(byte[] b)
    				fos.write(b,0,count);							//write(byte[]b,int off,int len)
    			}
    		}
    		catch(IOException e){
    			throw new FileNotFoundException("文件未找到异常");
    		}
    		finally{
    			if(fis!=null){
    				try{
    					fis.close();
    				}
    				catch(IOException e){
    					System.out.println("error1");
    				}
    			}
    			if(fos!=null){
    				try{
    					fos.close();
    				}
    				catch(IOException e){
    					System.out.println("error2");
    				}
    			}
    			//System.out.println("IO over!");
    		}
    	}
    	
    	public static void main(String[] args) {
    		
    		System.out.println("程序运行开始");
    		TryCatch temp=new TryCatch();
    		temp.Four();
    		System.out.println("程序运行结束");
    
    	}
    }
    

        函数执行结果如下:

        这里图片的内容只是用于提示执行的流程,输出文字没有意义









    展开全文
  • python - 异常处理

    2018-09-12 23:28:00
    这种东西加的多了,会导致你的代码可读性变差,只有在有些异常无法预知的情况下,才应该加上try...except,其他的逻辑错误应该尽量修正 转载于:https://www.cnblogs.com/peng104/p/9638109.html

    1, 异常和错误

    1, 程序中难免出现错误,而错误分成两种

    1,语法错误(这种错误,根本过不了python解释器的语法检测,必须在程序执行前就改正)

    #语法错误示范一
    if
    
    #语法错误示范二
    def test:
        pass
    
    #语法错误示范三
    print(haha
    语法错误

    2,逻辑错误

    #用户输入不完整(比如输入为空)或者输入非法(输入不是数字)
    num=input(">>: ")
    int(num)
    
    #无法完成计算
    res1=1/0
    res2=1+'str'
    逻辑错误

     

    2, 什么是异常

    异常就是程序运行时发生错误的信号,在python中,错误触发的异常如下

     

    3, python中的异常种类

    在python中不同的异常可以用不同的类型(python中统一了类与类型,类型即类) 去标识,不同的类对象标识不同的异常,一个异常标识一种错误.

    l = ["aa","bb"]
    l[3] # IndexError: list index out of range
    触发IndexError
    dic = {"name":"deng"}
    dic["age"] # KeyError: 'age'
    触发KeyError
    s = "hello"
    int(s) # ValueError: invalid literal for int() with base 10: 'hello'
    触发ValueError

     

    AttributeError 试图访问一个对象没有的树形,比如foo.x,但是foo没有属性x
    IOError 输入/输出异常;基本上是无法打开文件
    ImportError 无法引入模块或包;基本上是路径问题或名称错误
    IndentationError 语法错误(的子类) ;代码没有正确对齐
    IndexError 下标索引超出序列边界,比如当x只有三个元素,却试图访问x[5]
    KeyError 试图访问字典里不存在的键
    KeyboardInterrupt Ctrl+C被按下
    NameError 使用一个还未被赋予对象的变量
    SyntaxError Python代码非法,代码不能编译(个人认为这是语法错误,写错了)
    TypeError 传入对象类型与要求的不符合
    UnboundLocalError 试图访问一个还未被设置的局部变量,基本上是由于另有一个同名的全局变量,
    导致你以为正在访问它
    ValueError 传入一个调用者不期望的值,即使值的类型是正确的
    常用异常
    ArithmeticError
    AssertionError
    AttributeError
    BaseException
    BufferError
    BytesWarning
    DeprecationWarning
    EnvironmentError
    EOFError
    Exception
    FloatingPointError
    FutureWarning
    GeneratorExit
    ImportError
    ImportWarning
    IndentationError
    IndexError
    IOError
    KeyboardInterrupt
    KeyError
    LookupError
    MemoryError
    NameError
    NotImplementedError
    OSError
    OverflowError
    PendingDeprecationWarning
    ReferenceError
    RuntimeError
    RuntimeWarning
    StandardError
    StopIteration
    SyntaxError
    SyntaxWarning
    SystemError
    SystemExit
    TabError
    TypeError
    UnboundLocalError
    UnicodeDecodeError
    UnicodeEncodeError
    UnicodeError
    UnicodeTranslateError
    UnicodeWarning
    UserWarning
    ValueError
    Warning
    ZeroDivisionError
    更多异常

     

    2, 异常处理

    1, try/except 子句

    在 Python 中,try/except 语句用于处理程序执行过程中出现的一些异常情况。

    在 try 子句中,通常放置的是一个可能引发异常的操作,而处理异常的代码则在 except 子句中。

    • A:你的薪水是多少?
    • B:你猜?
    try:
        salary = int(input("Please ener the salary: "))
        print("So happy %d" % salary)
    except:
        print("It's nor a numder!")
    
    结果一:
    Please ener the salary: 10000
    So happy 10000
    
    结果二:
    Please ener the salary: abc
    It's nor a numder!

    这里,Python 将尝试处理 try 块中的所有语句,一旦发生异常(人家打听你工资,你非要说一个 “abc”),则控制流将立即传递到 except 块,并跳过 try 中的剩余语句。

    注意 : except 子句没有捕获特定异常,这并不是一个好的编程习惯。因为它会捕获所有的异常,并以相同的方式处理所有的情况。

     

    2, 捕获特定异常

    一个 try 子句可以有任意数量的 except 子句,但只有一个将被执行,并且 except 子句可以指定捕获特定的异常。

    来看一段伪代码:

    try:
       # 执行语句
       pass
    
    except ValueError:
       # 处理 ValueError 异常
       pass
    
    except (TypeError, ZeroDivisionError):
       # 处理多个异常 - TypeError 和 ZeroDivisionError
       pass
    
    except:
       # 处理所有其他异常
       pass

    通过使用元组, 可以为except子句指定多个异常.

     

    3, else 子句 

    通常,如果不发生异常,我们往往会希望执行一些额外的代码,这可以通过 else 子句轻松地实现。

    上述示例,我们将 print 语句直接放在 try 块中。这时,只有在转换语句不引发异常的情况下才执行该语句,但将其放在 else 块中才是更好的做法。

    try:
        salaey = int(input("Please enter the salary: "))
    except ValueError:
        print("It's not a number!")
    else:
        print("So happy %d." % salaey)

    也就是说,try 块中唯一的代码应该是有潜在风险的单行(即:要处理的错误的来源)。老实说,大多数人不这样用。

     

    4, finally 子句

    另外,try 语句可以有一个可选的 finally 子句。无论什么情况,该子句都会被执行,通常用于释放外部资源。

    例如,操作一个文件:

    try:
        f = open("a1.txt",encoding="utf-8")
        # 执行文件操作
    finally:
        f.close() # 关闭文件,报错也会执行

    一旦使用,无论文件是否打开成功,都必须清理资源。所以,在 finally 子句中使用 close(),可以确保即使发生异常,文件也能够被关闭

     

    5, 使用异常对象

    异常对象包含的信息不仅仅是错误类型, 也有一些其他信息.

    要访问这些信息,需要能够访问异常对象,可以将其分配给一个变量,然后在 except 子句中使用:

    try:
        salary = int(input("Please enter the salary:"))
    except ValueError as err:
        print(err)
    
    运行结果:
    Please enter the salary:abc
    invalid literal for int() with base 10: 'abc'

    注意: err 不是字符串,但是 Python 知道如何将它转换为一个异常的字符串表示形式。

     

    通常,这些异常信息不是很方便用户 - 如果想向用户报告错误,一般需要编写一个更具描述性的消息(说明错误与用户的某些行为相关)。这时,可以将异常消息与自己的消息相结合:

    try:
        salary = int(input("Please enter the salary: "))
    except ValueError as err:
        print("You entered incorrect salary: %s" % err)
    
    运行:
    Please enter the salary: abc
    You entered incorrect salary: invalid literal for int() with base 10: 'abc'

    注意: 使用 %s 将一个变量插入到格式化的字符串中,也可以将变量转换为字符串。

     

    6, 抛出异常

    在 Python 中,当发生运行时错误,就会出现相应的异常。此外,也可以使用关键字 raise 来强制引发。

    还可以选择为异常传递值,以说明为什么会引发异常:

    try:
        salary = int(input("Please enter the salary: "))
        if salary <= 0:
            raise ValueError("%d is not a valid age, salary must be positive." % salary)
    except ValueError as err:
        print("You entered incorrect salary: %s" % err)
    else:
        print("So happy %d." % salary)
    
    运行:
    Please enter the salary: -10000
    You entered incorrect salary: -10000 is not a valid age, salary must be positive.

    薪资肯定是一个正整数,当输入一个负数或 0 时,我们可以抛出自己的 ValueError

    注意: 之所以选择 ValueError 作为我们的异常类型,是因为它最适合这种错误。当然,这里也可以使用一个完全不合适的异常类,但应该尽量保持一致。

    当这样做时,它与任何其他异常具有完全相同的效果 - 控制流将立即退出 try 子句,并传递给 except 子句。这个 except 子句也可以匹配我们的异常,因为它也是一个 ValueError

     也还可以自定义异常:

    class EvaException(BaseException): # 自定义异常需要继承异常的基类
        def __init__(self,msg):
            self.msg = msg
        def __str__(self):
            return self.msg
    try:
        raise EvaException("自定义类型错误")
    except EvaException as err:
        print(err)

     

    断言:

    # assert 条件
     
    assert 1 == 1
     
    assert 1 == 2

     

    try..except的方式比较if的方式的好处

    try..except这种异常处理机制就是取代if那种方式,让你的程序在不牺牲可读性的前提下增强健壮性和容错性

    异常处理中为每一个异常定制了异常类型(python中统一了类与类型,类型即类),对于同一种异常,一个except就可以捕捉到,可以同时处理多段代码的异常(无需‘写多个if判断式’)减少了代码,增强了可读性 

     

    使用try..except的方式

    1:把错误处理和真正的工作分开来
    2:代码更易组织,更清晰,复杂的工作任务更容易实现;
    3:毫无疑问,更安全了,不至于由于一些小的疏忽而使程序意外崩溃了;

     

    注 : 

    try...except应该尽量少用,因为它本身就是你附加给你的程序的一种异常处理的逻辑,与你的主要的工作是没有关系的
    这种东西加的多了,会导致你的代码可读性变差,只有在有些异常无法预知的情况下,才应该加上try...except,其他的逻辑错误应该尽量修正

    转载于:https://www.cnblogs.com/peng104/p/9638109.html

    展开全文
  • try - ecxept语句 try - except - finally语句 try - except - else语句 raise语句 学习内容: 一、try - except 语句 格式:try: 检测范围 except Exception[as reason]: 出现异常后的处理代码 try语句...
  • to complete BlockStatements 'try' without 'catch' or 'finally'错误样例:class T { void test(){ try{ } }}解决方法:增加catch 或者finallyclass T { void test(){ try{ ...
  • public class Test { public static void main(String[] args) { int a[] = { 3, 9, 8}; //静态初始化 Date days1 [] = { new Date(1, 4, 2004), new Date(2, 4, 2004), new Date(3, 4, ...
  • python - try-except 语句

    千次阅读 2019-09-20 17:46:05
    异常可以通过 try 语句来检测. 任何在 try 语句块里的代码都会被监测, 检查有无异常发生。 try 语句有两种主要形式: try-except 和 try-finally . 这两个语句是互斥的, 也就是说你只能使用其中的一种 . 一个 try ...
  • 今天面试时候遇到一道题,题目差不多就是下面的代码(这是我自己敲得,题大概就是这样)求返回值:...try { result = n+m ; System.out.println( "try: "+result); return result; } finally { result = m-n; System...
  • python异常处理try-except语句

    千次阅读 2020-07-23 16:08:15
    1 为什么用try-except 语句 首先我们来说说,为什么要用try-except 语句。简单来说,为了避免程序意外退出,而需要使用的语句。 首先来看一段代码,你会更加容易理解: try: 1 / 0 except ZeroDivisionError: ...
  • try except

    2019-04-16 10:20:51
    python中try/except/else/finally语句的完整格式如下所示: try: Normal execution block except A: Exception A handle except B: Exception B handle except: Other exception handle else: ...
  • try-catch-finally 规则( 异常处理语句的语法规则 ) 1) 必须在 try 之后添加 catch 或 finally 块。try 块后可同时接 catch 和 finally 块,但至少有一个块。 2) 必须遵循块顺序:若代码同时使用 catch 和 ...
  • else字句的语句将在try语句没有异常时被执行 finally子句的语句在任何情况下都会被执行         示例见:  try_except.py     练习:  写一个函数:  def get_score(): ...
  • Python 异常处理try…except 今天一起来讲解下Python中异常处理(try…except) 1. 异常时什么 首先说一下何谓异常: Python程序的语法是正确的; 但运行期检测到的错误被称为异常。 如:ZeroDivisionError,...
  • 例4 finally的用法 try: 代码块A expect: 代码块B else: 代码块C finally: 代码块D(无论程序是否有异常,都会执行) 例5 嵌套使用 try: 代码块 try: 代码块 except: 代码块 except: 代码块 1...
  • Java throws 字句

    2019-06-26 20:50:34
    第二,main( )必须定义一个try/catch 语句来捕获该异常。正确的例子如下: // This is now correct. class ThrowsDemo { static void throwOne() throws IllegalAccessException { System.out.println("Inside ...
  • # finally字句的用法 except ValueError: print( '苹果不分了' ) except : # 除ValueError异常外的异常 print( '错误值是:0' ) else : # 如果没有异常才执行 print( 'else子句被执行了' ) finally : ...
  • 可见只抛出了空指针异常,而 / by zero 异常丢失了,或者说被finally字句的异常覆盖了。 另外,finally中的return语句也可能导致异常丢失:  public static void main(String[] args) {  // TODO Auto-...
  • 异常处理-try catch

    2017-06-07 18:42:00
    一:try catch是什么 try catch是java程序设计中处理异常的重要组成部分  异常是程序中的一些错误,有些异常需要做处理,有些则不需要捕获处理,异常是针对方法来说的,抛出、声明抛出、捕获和处理异常都是在方法...
  • 5.6 try 语句块和异常处理 5.6.1 throw 表达式 程序的异常检测部分使用 throw 表达式引发一个异常。 throw 表达式包含关键字throw和紧随其后的一个表达式,其中表达式的类型就是抛出的异常类型。 throw 表达式后面...
  • try语句块以try关键字开头,并以一个或多个catch字句结束。在try块中执行的代码所抛出(throw)的异常,通常会被其中一个catch子句处理。由于他们“处理”异常,catch字句也称为处理代码。 3.由标准库定义的一组...
  • try语句和异常 try语句是为了处理错误或者清理对象而定义的语句块。try语句后面必须定义catch语句块或finnally语句块或者后两者都有,当try块执行发生错误时,执行catch块,当结束try块或catch块时,有finally块的...
  • 异常的捕获处理——try{} catch(){} 如果一个异常不去处理,会导致程序无法编译或运行 异常捕获: try{ 写可能出现异常的代码; } catch(异常类型 标识符){ 如果try中的代码出现了异常,并且异常类型和catch的异常...
  • http://www.pythontab.com/html/2013/pythonjichu_0204/210.html 转载于:https://blog.51cto.com/duallay/1942424
  • Python基础之:Python中的异常和错误

    千次阅读 2021-03-29 11:35:42
    <class 'Exception'> ('spam', 'eggs') ('spam', 'eggs') x = spam y = eggs 上面的例子中,我们在try字句中抛出了一个异常,并且指定了2个参数。 抛出异常 我们可以使用raise语句来抛出异常。 >>> raise NameError...
  • throws、throw和try catch

    2018-05-21 12:59:00
    在学习代理模式的时候,编写动态生成代理类.java文件时,用try{}catch(){}捕获异常发现catch(Exception e)报错,得换成catch(Throwable e),然后又查了查两者的区别,在文章最后附上。 这里还是要码一码throws、...
  • 关于try catch的总结

    2018-06-26 15:36:46
    首先是最基本的一点 try catch代码块是可嵌套的try catch嵌套,内层不能捕获时,会考虑外层内否捕获,内层能捕获,则外层catch不执行。那么多个catch怎么执行,看一个例子 public class ExceptionTryCatchTest { ...
  • Java8中,可以实现资源的自动关闭,但是要求执行后必须关闭所有的所有资源必须在try字句中进行初始化,否则编译不通过。代码如下: try (InputStreamReader reader = new InputStreamReader(System.in)) { //读取...
  • Java语言中try-catch-finally的执行顺序 最近遇到一道Java编程题目,让根据以下程序写输出: public static int func (){ try{ return 1; }catch (Exception e){ return 2; }finally{ return...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,483
精华内容 1,393
关键字:

try字句