精华内容
下载资源
问答
  • Python中关于return语句的理解

    千次阅读 2019-01-24 13:23:42
    在一个定义的函数内部,若出现多个return,该函数会返回哪个return,是函数里第一个遇到的return,还是函数里最后的return. 代码实例1 #!/usr/bin/python # -*- coding: UTF-8 -*- def test1(string,...

    问题描述

    在一个定义的函数内部,若出现多个return,该函数会返回哪个return,是函数里第一个遇到的return,还是函数里最后的return.

    1. 代码实例1
    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    def test1(string,cut=True):
       if string == 'h':
          return['return h']
       if cut:
          return ['b']
       else:
          return [string]
    mu=test1('a')
    print(mu)
    

    运行结果如下:

    ['b']
    
    1. 代码实例2
    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    def test2(string,cut=True):
       if string == 'h':
          return['return h']
       if cut:
          return ['b']
       else:
          return [string]
    mu=test2('h')
    print(mu)
    

    运行结果如下:

    ['return h']
    
    1. 代码实例3
    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    def test3(string,cut=True):
       if string == 'h':
          return['return h']
       if cut:
          return ['b']
       else:
          return [string]
    mu=test3('c',cut=False)
    print(mu)
    

    运行结果如下:

    ['c']
    

    说明

    一个函数内部出现多个return时,返回的是第一次执行的return指向的值

    展开全文
  • 关于Java中try finally return语句的执行顺序分析

    千次阅读 多人点赞 2017-08-22 21:16:22
    finally语句块一定会执行吗? 可能很多人第一反应是肯定要执行的,但仔细一想,如果一定会执行的话 也就不会这么SB的问了。 Demo1 public class Test { public static void main(String[] args) { System.out....

    问题分析

    finally语句块一定会执行吗?
    可能很多人第一反应是肯定要执行的,但仔细一想,如果一定会执行的话 也就不会这么SB的问了。

    Demo1

    public class Test {
        public static void main(String[] args) {
            System.out.println("return value of test(): " + test());
        }
    
        public static int test() {
            int i = 1;
    
            // if (i == 1) {
            // return 0;
            // }
            System.out.println("the previous statement of try block");
            i = i / 0;
    
            try {
                System.out.println("try block");
                return i;
            } finally {
                System.out.println("finally block");
            }
        }
    }

    Demo1的执行结果如下:

    the previous statement of try block
    Exception in thread "main" java.lang.ArithmeticException: / by zero
        at com.becoda.bkms.bus.basics.web.Test2.test(Test2.java:15)
        at com.becoda.bkms.bus.basics.web.Test2.main(Test2.java:5)

    另外,如果去掉上例中的注释,执行结果则是:

    return value of test(): 0

    以上两种情况,finally语句块都没有执行,说明什么问题?只有与finally相对应的try语句块得到执行的情况下,finally语句块才会执行,而上面都是在try语句块之前返回(return)或者抛出异常,所以try对应的finally语句块没有执行。那么,即使与finally相对应的try语句块得到执行的情况下,finally语句块一定会执行吗?但下面例子

    Demo2

    public class Test {
        public static void main(String[] args) {
            System.out.println("return value of test(): " + test());
        }
    
        public static int test() {
            int i = 1;
    
            try {
                System.out.println("try block");
                System.exit(0);
    
                return i;
            } finally {
                System.out.println("finally block");
            }
        }
    }

    Demo2的执行结果如下:

    try block

    finally语句块还是没有执行,为什么呢?因为我们在try语句块中执行了System.exit(0)语句,终止了Java虚拟机的运行,虽然一般情况下我们不会这么干。还有情况是当一个线程在执行try语句块或者catch语句块时被打断(interrupted)或者被终止(killed),与其对应的finally语句块可能不会执行。还有更极端的情况,就是在线程运行 try 语句块或者 catch 语句块时,突然死机或者断电,finally 语句块肯定不会执行了。

    finally 语句示例说明

    下面看一个简单的例子

    Demo3

    public class Test {
        public static void main(String[] args) {
            try {
                System.out.println("try block");
    
                return;
            } finally {
                System.out.println("finally block");
            }
        }
    }

    Demo3的执行结果为:

    try block
    finally block

    Demo3说明 finally 语句块在 try 语句块中的 return 语句之前执行。我们再来看另一个例子。

    Demo4

    public class Test {
        public static void main(String[] args) {
            System.out.println("reture value of test() : " + test());
        }
    
        public static int test() {
            int i = 1;
    
            try {
                System.out.println("try block");
                i = 1 / 0;
    
                return 1;
            } catch (Exception e) {
                System.out.println("exception block");
    
                return 2;
            } finally {
                System.out.println("finally block");
            }
        }
    }

    Demo4的执行结果为:

    try block
    exception block
    finally block
    reture value of test() : 2

    Demo4说明了 finally 语句块在 catch 语句块中的 return 语句之前执行。

    从上面的Demo3和Demo4,我们可以看出,其实finally语句块时在try或者catch中的return语句之前执行的,更加一般的说法是,finally语句块应该是在控制转移语句之前执行,控制转移语句除了return外,还有break和continue。

    再来看下面两个例子

    Demo5

    public class Test {
        public static void main(String[] args) {
            System.out.println("return value of getValue(): " + getValue());
        }
    
        public static int getValue() {
            try {
                return 0;
            } finally {
                return 1;
            }
        }
    }
    

    Demo5的执行结果为:

    return value of getValue(): 1

    Demo6

    public class Test {
        public static void main(String[] args) {
            System.out.println("return value of getValue(): " + getValue());
        }
    
        public static int getValue() {
            int i = 1;
    
            try {
                return i;
            } finally {
                i++;
            }
        }
    }

    Demo6的执行结果为:

    return value of getValue(): 1

    利用我们上面分析得出的结论:finally 语句块是在 try 或者 catch 中的 return 语句之前执行的。 由此,可以轻松的理解Demo5 的执行结果是 1。因为 finally 中的 return 1;语句要在 try 中的 return 0;语句之前执行,那么 finally 中的 return 1;语句执行后,把程序的控制权转交给了它的调用者 main()函数,并且返回值为 1。那为什么Demo6 的返回值不是 2,而是 1 呢?按照Demo5 的分析逻辑,finally 中的 i++;语句应该在 try 中的 return i;之前执行啊?i 的初始值为 1,那么执行 i++;之后为 2,再执行 return i;那不就应该是 2 吗?怎么变成 1 了呢?

    说明这个问题需要了解Java虚拟机是如何编译finally语句块的。

    Java方法是在栈帧中执行,栈帧是线程私有栈的单位,执行方法的线程会为每一个方法分配一小块空间来作为该方法执行时的内存空间,栈帧分为三个区域:

    • 1、操作数栈,用来保存正在执行的表达式中的操作数
    • 2、局部变量区,用来保存方法中使用的变量,包括方法参数,方法内部声明的变量,以及方法中使用到的对象的成员变量或类的成员变量(静态变量),最后两种变量会复制到局部变量区,因此在多线程环境下,这种变量需要根据需要声明为volatile类型
    • 3、字节码指令区

    例如下面这段代码

    try{
       return expression;
    }finally{
       do some work;
    }

    首先我们知道,finally语句是一定会执行,但他们的执行顺序是怎么样的呢?他们的执行顺序如下:

    • 1、执行:expression,计算该表达式,结果保存在操作数栈顶;
    • 2、执行:操作数栈顶值(expression的结果)复制到局部变量区作为返回值;
    • 3、执行:finally语句块中的代码;
    • 4、执行:将第2步复制到局部变量区的返回值又复制回操作数栈顶;
    • 5、执行:return指令,返回操作数栈顶的值;

    我们可以看到,在第一步执行完毕后,整个方法的返回值就已经确定了,由于还要执行finally代码块,因此程序会将返回值暂存在局部变量区,腾出操作数栈用来执行finally语句块中代码,等finally执行完毕,再将暂存的返回值又复制回操作数栈顶。所以无论finally语句块中执行了什么操作,都无法影响返回值,所以试图在finally语句块中修改返回值是徒劳的。因此,finally语句块设计出来的目的只是为了让方法执行一些重要的收尾工作,而不是用来计算返回值的。

    这样就能解释Demo6的问题了

    让我们再来看以下 3 个例子。

    Demo7

    public class Test {
        public static void main(String[] args) {
            System.out.println("return value of getValue(): " + getValue());
        }
    
        @SuppressWarnings("finally")
        public static int getValue() {
            int i = 1;
    
            try {
                i = 4;
            } finally {
                i++;
    
                return i;
            }
        }
    }

    Demo7的执行结果为:

    return value of getValue(): 5

    Demo8

    public class Test {
        public static void main(String[] args) {
            System.out.println("return value of getValue(): " + getValue());
        }
    
        public static int getValue() {
            int i = 1;
    
            try {
                i = 4;
            } finally {
                i++;
            }
    
            return i;
        }
    }

    Demo8的执行结果为:

    return value of getValue(): 5

    Demo9

    public class Test {
        public static void main(String[] args) {
            System.out.println(test());
        }
    
        public static String test() {
            try {
                System.out.println("try block");
    
                return test1();
            } finally {
                System.out.println("finally block");
            }
        }
    
        public static String test1() {
            System.out.println("return statement");
    
            return "after return";
        }
    }

    Demo9的执行结果为:

    try block
    return statement
    finally block
    after return

    总结:

    • 1、finally 语句块不一定会被执行
    • 2、finally 语句块在 try 语句块中的 return 语句之前执行
    • 3、finally 语句块在 catch 语句块中的 return 语句之前执行
    • 4、finally 语句块中的 return 语句会覆盖 try 块中的 return 返回
    • 5、试图在 finally 语句块中修改返回值不一定会被改变
    展开全文
  • return语句的用法

    万次阅读 2018-03-20 10:49:19
    如果在while循环和if语句中return会导致循环中断return语句用于退出函数,向调用方返回一个表达式。return在不带参数的情况下(或者没有写return语句),默认返回None。None是一个特殊的值,它的数据类型是NoneType...

    如果在while循环和if语句中return会导致循环中断

    return语句用于退出函数,向调用方返回一个表达式。

    return在不带参数的情况下(或者没有写return语句),默认返回None。

    None是一个特殊的值,它的数据类型是NoneType。NoneType是Python的特殊类型,它只有一个取值None。

    它不支持任何运算也没有任何内建方法,和任何其他的数据类型比较是否相等时永远返回false,也可以将None赋值给任何变量。。。


    执行到return语句时,会退出函数,return之后的语句不再执行。但将return语句放在try语句块中,是个例外。


    展开全文
  • finally语句与return语句的执行顺序

    千次阅读 2017-11-10 18:19:09
    很多人都说不是,当然他们的回答是正确的,经过我试验,至少有两种情况下finally语句是不会被执行的: try语句没有被执行到,如在try语句之前就返回了,这样finally语句就不会执行,这也说明了finally语句被执行的...

           网上有很多人探讨Java中异常捕获机制try...catch...finally块中的finally语句是不是一定会被执行?很多人都说不是,当然他们的回答是正确的,经过我试验,至少有两种情况下finally语句是不会被执行的:

    1. try语句没有被执行到,如在try语句之前就返回了,这样finally语句就不会执行,这也说明了finally语句被执行的必要而非充分条件是:相应的try语句一定被执行到。
    2. 在try块中有System.exit(0);这样的语句,System.exit(0);是终止Java虚拟机JVM的,连JVM都停止了,所有都结束了,当然finally语句也不会被执行到。

           当然还有很多人探讨Finally语句的执行与return的关系,颇为让人迷惑,不知道finally语句是在try的return之前执行还是之后执行?我也是一头雾水,我觉得他们的说法都不正确,我觉得应该是:finally语句是在try的return语句执行之后,return返回之前执行。这样的说法有点矛盾,也许是我表述不太清楚,下面我给出自己试验的一些结果和示例进行佐证,有什么问题欢迎大家提出来。


    1、finally语句在return语句执行之后return返回之前执行的。

    public class FinallyTest1 {
    
        public static void main(String[] args) {
            
            System.out.println(test1());
        }
    
        public static int test1() {
            int b = 20;
    
            try {
                System.out.println("try block");
    
                return b += 80; 
            }
            catch (Exception e) {
    
                System.out.println("catch block");
            }
            finally {
                
                System.out.println("finally block");
                
                if (b > 25) {
                    System.out.println("b>25, b = " + b);
                }
            }
            
            return b;
        }
        
    }
    运行结果:

    try block
    finally block
    b>25, b = 100
    100

    说明return语句已经执行了再去执行finally语句,不过并没有直接返回,而是等finally语句执行完了再返回结果。

    如果觉得这个例子还不足以说明这个情况的话,下面再加个例子加强证明结论:

    public class FinallyTest1 {
    
        public static void main(String[] args) {
            
            System.out.println(test11());
        }
        
        public static String test11() {
            try {
                System.out.println("try block");
    
               return test12();
          } finally {
               System.out.println("finally block");
           }
      }
    
      public static String test12() {
           System.out.println("return statement");
    
           return "after return";
       }
        
    }
    运行结果:

    try block
    return statement
    finally block
    after return

    说明try中的return语句先执行了但并没有立即返回,等到finally执行结束后再返回。

    这里大家可能会想:如果finally里也有return语句,那么是不是就直接返回了,try中的return就不能返回了?看下面。


    2、finally块中的return语句会覆盖try块中的return返回。

    public class FinallyTest2 {
    
        public static void main(String[] args) {
    
            System.out.println(test2());
        }
    
        public static int test2() {
            int b = 20;
    
            try {
                System.out.println("try block");
    
                return b += 80;
            } catch (Exception e) {
    
                System.out.println("catch block");
            } finally {
    
                System.out.println("finally block");
    
                if (b > 25) {
                    System.out.println("b>25, b = " + b);
                }
    
                return 200;
            }
    
            // return b;
        }
    
    }
    运行结果:

    try block
    finally block
    b>25, b = 100
    200

           这说明finally里的return直接返回了,就不管try中是否还有返回语句,这里还有个小细节需要注意,finally里加上return过后,finally外面的return b就变成不可到达语句了,也就是永远不能被执行到,所以需要注释掉否则编译器报错。

    这里大家可能又想:如果finally里没有return语句,但修改了b的值,那么try中return返回的是修改后的值还是原值?看下面。


    3、如果finally语句中没有return语句覆盖返回值,那么原来的返回值可能因为finally里的修改而改变也可能不变。

    测试用例1:
    public class FinallyTest3 {
    
        public static void main(String[] args) {
    
            System.out.println(test3());
        }
    
        public static int test3() {
            int b = 20;
    
            try {
                System.out.println("try block");
    
                return b += 80;
            } catch (Exception e) {
    
                System.out.println("catch block");
            } finally {
    
                System.out.println("finally block");
    
                if (b > 25) {
                    System.out.println("b>25, b = " + b);
                }
    
                b = 150;
            }
    
            return 2000;
        }
    
    }
    运行结果:

    try block
    finally block
    b>25, b = 100
    100

    测试用例2:

    import java.util.*;
    
    public class FinallyTest6
    {
        public static void main(String[] args) {
            System.out.println(getMap().get("KEY").toString());
        }
         
        public static Map<String, String> getMap() {
            Map<String, String> map = new HashMap<String, String>();
            map.put("KEY", "INIT");
             
            try {
                map.put("KEY", "TRY");
                return map;
            }
            catch (Exception e) {
                map.put("KEY", "CATCH");
            }
            finally {
                map.put("KEY", "FINALLY");
                map = null;
            }
             
            return map;
        }
    }
    运行结果:

    FINALLY

           为什么测试用例1中finally里的b = 150;并没有起到作用而测试用例2中finally的map.put("KEY", "FINALLY");起了作用而map null;却没起作用呢?这就是Java到底是传值还是传址的问题了,具体请看精选30道Java笔试题解答,里面有详细的解答,简单来说就是:finally是在return语句执行之后,返回之前执行的(此时并没有返回运算后的值,而是先把要返回的值保存起来,不管finally中的代码怎么样,返回的值都不会改变,仍然是之前保存的值),所以函数返回值是在finally执行前就已经确定了。Java中只有传值没有传址,这也是为什么map = null这句不起作用。这同时也说明了返回语句是try中的return语句而不是 finally外面的return b;这句,不相信的话可以试下,将return b;改为return 294,对原来的结果没有一点影响。

    这里大家可能又要想:是不是每次返回的一定是try中的return语句呢?那么finally外的return b不是一点作用没吗?请看下面。


    4、try块里的return语句在异常的情况下不会被执行,这样具体返回哪个看情况。

    public class FinallyTest4 {
    
        public static void main(String[] args) {
    
            System.out.println(test4());
        }
    
        public static int test4() {
            int b = 20;
    
            try {
                System.out.println("try block");
    
                b = b / 0;
    
                return b += 80;
            } catch (Exception e) {
    
                b += 15;
                System.out.println("catch block");
            } finally {
    
                System.out.println("finally block");
    
                if (b > 25) {
                    System.out.println("b>25, b = " + b);
                }
    
                b += 50;
            }
    
            return 204;
        }
    
    }
    运行结果:

    try block
    catch block
    finally block
    b>25, b = 35
    85
           这里因 为在return之前发生了除0异常,所以try中的return不会被执行到,而是接着执行捕获异常的catch 语句和最终的finally语句,此时两者对b的修改都影响了最终的返回值,这时return b;就起到作用了。当然如果你这里将return b改为return 300什么的,最后返回的就是300,这毋庸置疑。

    这里大家可能又有疑问:如果catch中有return语句呢?当然只有在异常的情况下才有可能会执行,那么是在finally之前就返回吗?看下面。


    5、当发生异常后,catch中的return执行情况与未发生异常时try中return的执行情况完全一样。

    public class FinallyTest5 {
    
        public static void main(String[] args) {
    
            System.out.println(test5());
        }
    
        public static int test5() {
            int b = 20;
    
            try {
                System.out.println("try block");
                
                b = b /0;
    
                return b += 80;
            } catch (Exception e) {
    
                System.out.println("catch block");
                return b += 15;
            } finally {
    
                System.out.println("finally block");
    
                if (b > 25) {
                    System.out.println("b>25, b = " + b);
                }
    
                b += 50;
            }
    
            //return b;
        }
    
    }
    运行结果:

    try block
    catch block
    finally block
    b>25, b = 35
    35

           说明了发生异常后,catch中的return语句先执行,确定了返回值后再去执行finally块,执行完了catch再返回,finally里对b的改变对返回值无影响,原因同前面一样,也就是说情况与try中的return语句执行完全一样。


    总结


    1、不管有木有出现异常,finally块中代码都会执行;

    2、当try和catch中有return时,finally仍然会执行;

    3、finally是在return语句执行之后,返回之前执行的(此时并没有返回运算后的值,而是先把要返回的值保存起来,不管finally中的代码怎么样,返回的值都不会改变,仍然是之前保存的值),所以函数返回值是在finally执行前就已经确定了;

    4、finally中如果包含return,那么程序将在这里返回,而不是try或catch中的return返回,返回值就不是try或catch中保存的返回值了。


    注:

           1、finally修改的基本类型是不影响返回结果的。(传值的)

           2、修改list ,map,自定义类等引用类型时,是影响返回结果的。(传址的)对象也是传址的但是date类型经过测试是不影响的。有点奇怪。






    展开全文
  • 很多人都说不是,当然他们的回答是正确的,经过我试验,至少有两种情况下finally语句是不会被执行的: (1)try语句没有被执行到,如在try语句之前就返回了,这样finally语句就不会执行,这也说明了finally语句被...
  • return语句执行流程详解

    千次阅读 2018-07-13 09:02:10
    今天去逛论坛 时发现了一个很有趣的问题: 谁能给我我解释一下这段程序的结果为什么是:2.而不是:3 代码如下: class Test { public int aaa() { int x = 1; try { return ++x;...
  • 很多人都说不是,当然他们的回答是正确的,经过我试验,至少有两种情况下finally语句是不会被执行的: (1)try语句没有被执行到,如在try语句之前就返回了,这样finally语句就不会执行,这也说明了finally语句被...
  • 在try中没有异常的情况下try、catch、finally的执行顺序 ...如果try中没有异常并且try中有return这时候正常执行顺序是try ---- finally --- return 如果try中有异常并且try中有return这时候正常执行顺序是try----ca
  • 很多人都说不是,当然他们的回答是正确的,经过我试验,至少有两种情况下finally语句是不会被执行的 try语句没有被执行到,如在try语句之前就返回了,这样finally语句就不会执行,这也说明了finally语句被执行的...
  • 【单选题】以下关于Python的说法正确的是哪一项?【判断题】Python语言是一种面向对象的高级程序设计语言。【简答题】分组名单和每组招标文件以附件形式上传【其它】作业1:数据库连接 连接属性 显示“产品”表的...
  • 网上有很多人探讨Java中异常捕获机制try...catch...finally块中的...很多人都说不是,当然他们的回答是正确的,经过我试验,至少有两种情况下finally语句是不会被执行的: (1)try语句没有被执行到,如在try语句
  • 前言之前在学习Java异常时遇到了try cathc finally中有return的情况,但是到底return执不执行,以怎样的顺序执行,以及原因是什么,还没弄清楚。 1 执行顺序以及原因先来看一个简单的例子,为了便于阅读方法的字节码...
  • 网上有很多人探讨Java中异常捕获机制try...catch...finally块中的...很多人都说不是,当然他们的回答是正确的,经过我试验,至少有两种情况下finally语句是不会被执行的: (1)try语句没有被执行到,如在try
  • 转自:http://www.disandu.com/archives/1181 今天工作时无意中写出了这样的代码 bool func() { try { ...... ... return true; } catch() { return false; } } ...
  • 下列关于JavaBean的说法正确的是: A:Java文件与Bean所定义的类名可以不同,但一定要注意区分字母的大小写 B:在JSP文件中引用Bean,其实就是用语句 C:被引用的Bean文件的文件名后缀为.java D:Bean文件放在...
  • 在Java中当try、finally语句中包含return语句时,执行情况到底是怎样的,finally中的代码是否执行,大家众说纷纭,有的说会执行,有的说不会执行,到底哪种说法正确,现在通过下面的例子加以说明:  第一种情况:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,403
精华内容 14,961
关键字:

关于return语句正确的说法是