返回值 订阅
一个函数的函数名既是该函数的代表,也是一个变量。由于函数名变量通常用来把函数的处理结果数据返回给调用函数,即递归调用,所以一般把函数名变量称为返回值,函数的返回值类型是在定义函数时指定的。 [1] 展开全文
一个函数的函数名既是该函数的代表,也是一个变量。由于函数名变量通常用来把函数的处理结果数据返回给调用函数,即递归调用,所以一般把函数名变量称为返回值,函数的返回值类型是在定义函数时指定的。 [1]
信息
返    回
函数处理结果
外文名
return
类    型
函数中定义
用    途
返回函数处理结果进行下一步处理
中文名
返回值
返回值概述
函数可以有返回值,也可以没有返回值。(1)没有返回值的函数:功能只是完成一个操作,应将返回值类型定义为void,函数体内可没有return语句。(2)有返回值的函数:函数的最后会有一个返回值return,可以用来获取该函数执行结果返回给该函数,让外部调用该函数的。返回值可指定,如果不指定默认返回None。 [2]  函数的返回值类型是在定义函数时指定的。return 语句中表达式的类型应与定义函数时指定的返回值类型一致。如果不一致,则以函数定义时的返回值类型为准,对 return 语句中表达式的类型自动进行转换,然后再将它返回给主调函数使用。在调用函数时,如果需要从被调函数返回一个值供主调函数使用,那么返回值类型必须定义成非 void 型。此时被调函数中必须包含 return 语句,而且 return 后面必须要有返回值,否则就是语法错误。一个函数中可以有多个 return 语句,但并不是所有的 return 语句都起作用。执行到哪个 return 语句,就是哪个 return 语句起作用,该 return 语句后的其他语句都不会执行。 [1] 
收起全文
精华内容
下载资源
问答
  • C/C++ 引用作为函数的返回值

    万次阅读 多人点赞 2018-08-04 13:19:48
    语法:类型 &...2.用引用作函数的返回值的最大的好处是在内存中不产生返回值的副本 //代码来源:RUNOOB #include<iostream> using namespace std; float temp; float fn1(float r){ ...
    语法:类型 &函数名(形参列表){ 函数体 }

    特别注意:

    1.引用作为函数的返回值时,必须在定义函数时在函数名前将&

    2.用引用作函数的返回值的最大的好处是在内存中不产生返回值的副本

    //代码来源:RUNOOB
    #include<iostream>
    using namespace std;
    float temp;
    float fn1(float r){
        temp=r*r*3.14;
        return temp;
    } 
    float &fn2(float r){ //&说明返回的是temp的引用,换句话说就是返回temp本身
        temp=r*r*3.14;
        return temp;
    }
    int main(){
        float a=fn1(5.0); //case 1:返回值
        //float &b=fn1(5.0); //case 2:用函数的返回值作为引用的初始化值 [Error] invalid initialization of non-const reference of type 'float&' from an rvalue of type 'float'
                               //(有些编译器可以成功编译该语句,但会给出一个warning) 
        float c=fn2(5.0);//case 3:返回引用
        float &d=fn2(5.0);//case 4:用函数返回的引用作为新引用的初始化值
        cout<<a<<endl;//78.5
        //cout<<b<<endl;//78.5
        cout<<c<<endl;//78.5
        cout<<d<<endl;//78.5
        return 0;
    }

    case 1:用返回值方式调用函数(如下图,图片来源:伯乐在线):

    返回全局变量temp的值时,C++会在内存中创建临时变量并将temp的值拷贝给该临时变量。当返回到主函数main后,赋值语句a=fn1(5.0)会把临时变量的值再拷贝给变量a

    case 2:用函数的返回值初始化引用的方式调用函数(如下图,图片来源:伯乐在线)

    这种情况下,函数fn1()是以值方式返回到,返回时,首先拷贝temp的值给临时变量。返回到主函数后,用临时变量来初始化引用变量b,使得b成为该临时变量到的别名。由于临时变量的作用域短暂(在C++标准中,临时变量或对象的生命周期在一个完整的语句表达式结束后便宣告结束,也就是在语句float &b=fn1(5.0);之后) ,所以b面临无效的危险,很有可能以后的值是个无法确定的值。

     如果真的希望用函数的返回值来初始化一个引用,应当先创建一个变量,将函数的返回值赋给这个变量,然后再用该变量来初始化引用:

      int x=fn1(5.0);
      int &b=x;

     case 3:用返回引用的方式调用函数(如下图,图片来源:伯乐在线)

    这种情况下,函数fn2()的返回值不产生副本,而是直接将变量temp返回给主函数,即主函数的赋值语句中的左值是直接从变量temp中拷贝而来(也就是说c只是变量temp的一个拷贝而非别名) ,这样就避免了临时变量的产生。尤其当变量temp是一个用户自定义的类的对象时,这样还避免了调用类中的拷贝构造函数在内存中创建临时对象的过程,提高了程序的时间和空间的使用效率。

    case 4:用函数返回的引用作为新引用的初始化值的方式来调用函数(如下图,图片来源:伯乐在线)

    这种情况下,函数fn2()的返回值不产生副本,而是直接将变量temp返回给主函数。在主函数中,一个引用声明d用该返回值初始化,也就是说此时d成为变量temp的别名。由于temp是全局变量,所以在d的有效期内temp始终保持有效,故这种做法是安全的。

    3.不能返回局部变量的引用。如上面的例子,如果temp是局部变量,那么它会在函数返回后被销毁,此时对temp的引用就会成为“无所指”的引用,程序会进入未知状态。

    4.不能返回函数内部通过new分配的内存的引用。虽然不存在局部变量的被动销毁问题,但如果被返回的函数的引用只是作为一个临时变量出现,而没有将其赋值给一个实际的变量,那么就可能造成这个引用所指向的空间(有new分配)无法释放的情况(由于没有具体的变量名,故无法用delete手动释放该内存),从而造成内存泄漏。因此应当避免这种情况的发生

    5当返回类成员的引用时,最好是const引用。这样可以避免在无意的情况下破坏该类的成员。

    6.可以用函数返回的引用作为赋值表达式中的左值

    #include<iostream>
    using namespace std;
    int value[10];
    int error=-1;
    int &func(int n){
        if(n>=0&&n<=9)
            return value[n];//返回的引用所绑定的变量一定是全局变量,不能是函数中定义的局部变量 
        else
            return error;
    }
    
    int main(){
        func(0)=10;
        func(4)=12;
        cout<<value[0]<<endl;
        cout<<value[4]<<endl;
        return 0; 
    }

    D.用引用实现多态

    在C++中,引用是除了指针外另一个可以产生多态效果的手段。也就是说一个基类的引用可以用来绑定其派生类的实例

    class Father;//基类(父类)
    class Son:public Father{.....}//Son是Father的派生类
    Son son;//son是类Son的一个实例
    Father &ptr=son;//用派生类的对象初始化基类对象的使用

    特别注意:

    ptr只能用来访问派生类对象中从基类继承下来的成员如果基类(类Father)中定义的有虚函数,那么就可以通过在派生类(类Son)中重写这个虚函数来实现类的多态。

     

     
    展开全文
  • python:返回值

    万次阅读 多人点赞 2018-10-14 22:56:40
    返回值简介 1、简单介绍 print 和 return 的区别,print 仅仅是打印在控制台,而 return 则是将 return 后面的部分作为返回值:作为函数的输出,可以用变量接走,继续使用该返回值做其它事。 2、函数需要先定义后...

    返回值简介

    1、简单介绍 print return 的区别:print 仅仅是打印在控制台,而 return 则是将 return 后面的部分作为返回值(作为函数的输出,可以用变量接走,继续使用该返回值做其它事)

    2、函数需要先定义后调用,函数体中 return 语句的结果就是返回值。如果一个函数没有 reutrn 语句,其实它有一个隐含的 return 语句,返回值是 None,类型也是'NoneType'

    例1:

    def func(x,y):
        num = x + y
        print(num)   #只是打印,函数具体返回什么由return决定,这里只是打印num
        return
    
    print(func(1,2))  #这里是打印函数的返回值
    
    """
    3
    None
    """

    注:

    1、从上面例子可以看出print( )只是起一个打印作用,函数具体返回什么由return决定

    2、这个例子中没有指return什么,因此默认return的是None


     

    return 语句的作用

    结束函数调用、返回指定的返回值


     

    指定返回值与隐含返回值

    1、函数体中 return 语句有指定返回值时返回的就是其值

    2、函数体中没有 return 语句时,函数运行结束会隐式返回一个 None 作为返回值,类型是 NoneType,与 return 、return None 等效,都是返回 None

     

    指定 return 返回值函数举例 

    例2:

    def showplus(x):
        print(x)
        return x + 1
         
    num = showplus(6) 
    
    print(num )
    
    """
    6
    7
    """

     

    隐含 return None 举例

    例3:

    def showplus(x,y):
        print(x + y)    #这里仅仅是打印x+y,对具体返回的是什么没有任何影响
    
    num = showplus(6,1)  #这里的num才是执行函数后,函数的返回值(将函数的返回值赋值给一个变量)
    
    print(num)
    print(type(num))
    
    """
    7
    None
    <class 'NoneType'>
    """

     

    函数返回值赋值给变量

    例4:函数内调用

    def add(a,b):
        c = a + b
        return c
    
    def func(x,y):
        d = add(1,2)    #函数内调用其他函数,并将add()函数的返回值赋值给一个变量d
        z = d + x + y   #在其他函数内使用其他函数的返回值(用于计算)
        return z
    
    print(func(3,4))
    
    #10

    例4_1: 函数外调用

    def add(a,b):
        c = a + b
        return c
    
    def func(x,y):
        z =  x + y
        return z
    
    d = add(1,2)   #调用函数后,将其返回值赋值给一个变量d
    z = func(d,3)  #将其他函数的返回值作为一个参数,传给自己的函数使用
    print(z)
    
    #6

    例4_2:

    import os
    import sys
    import subprocess
    
    def get_manifest_xml_path():
        xml_path = input()
        if os.path.exists( xml_path ):
            return xml_path
        else:
            print('AndroidManifest.xml not found!')
    
    
    def get_out_path( xml_path ):
        return os.path.dirname( os.path.abspath( xml_path ) ) + os.sep + 'AndroidManifest.txt'
    
    
    def convert_xml_to_txt( xml_path, out_path ):
        convert_cmd = 'java -jar AXMLPrinter2.jar %s>%s' % ( xml_path, out_path )
        subprocess.Popen( convert_cmd, shell=True )
    
    if __name__ == "__main__":
        xml_path = get_manifest_xml_path()
        out_path = get_out_path( xml_path )
        convert_xml_to_txt( xml_path, out_path )

    注:从上面例子中可以看出

    1、print()函数仅仅是打印在控制台,打印一些东西(方便调试程序之类的)

    2、 return 是指定函数的返回值(函数需要返回个什么东西):将 return 后面的部分作为返回值返回

    3、函数的返回值:作为函数的输出,可以用变量接走,继续使用该返回值做其它事(比如被其他函数使用等)

     

     

    return 语句位置与多条 return 语句

    1、python 函数使用 return 语句返回 "返回值",可以将其赋给其它变量作其它的用处

    2、所有函数都有返回值,如果没有 return 语句,会隐式地调用 return None 作为返回值;

    3、一个函数可以存在多条 return 语句,但只有一条可以被执行,如果没有一条 reutrn 语句被执行,同样会隐式调用 return None 作为返回值;

    4、如果有必要,可以显式调用 return None 明确返回一个None(空值对象)作为返回值,可以简写为 return,不过 python 中懒惰即美德,所以一般能不写就不写;

    5、如果函数执行了 return 语句,函数会立刻返回,结束调用,return 之后的其它语句都不会被执行了(可用于结束代码块)
        ⑴所以在for循环或while循环中要注意下return的使用位置:如果用在了循环中,那么程序只会循环一次

    例5:

    def testReturn(x):
        if x > 10000:
            return
        elif x > 1000:
            return 100
        elif x > 100:
            return 10
        elif x > 10:
            return 1
        else:
            return 0
    
    print(testReturn(9999999))
    print(testReturn(9999))
    print(testReturn(999))
    print(testReturn(99) )
    print(testReturn(9))
    
    # return使用说明:
    # (1)返回函数的返回值
    # (2)终止程序的运行,提前退出.(例如:当函数内有错误发生时,使用return可以终止函数的运行)
    
    """
    None
    100
    10
    1
    0
    """


    例5_1:

    def showplus(x):
        print(x + 2)
        return x + 1
    
    num = showplus(6)  #将返回值赋值给一个变量
    print(num)
    
    #上面函数的输出结果为:8、7

    例5_1:

    def func():
        for i in range(5):
            return i
    
    print(func())
    
    """
    输出:0
    可以看到在实际执行循环时,只执行了一次循环,整个循环就结束了,所以在循环中一定要注意return的使用位置
    这是因为执行return后,就会立马结束函数的调用,这里其实跟循环中的break关键字差不多
    """
    
    for i in range(5):
        print(i)
        break
    #0

     

     

    返回值类型

    1、无论定义的是返回什么类型,return 只能返回单值,但值可以存在多个元素

    2、return [1,3,5] 是指返回一个列表,是一个列表对象,1,3,5 分别是这个列表的元素

    3、return 1,3,5 看似返回多个值,隐式地被Python封装成了一个元祖返回

    例6:

    def showlist():
        return [1,3,5]   #多元素,返回的是什么类型
    
    print(type(showlist()))
    print(showlist())
    
    """
    输出结果:
    <class 'list'>
    [1, 3, 5]    #列表类型
    """

    例6_1:

    def Add(x,y):
        a = x + y
        b = x - y
        if x <= y:
            return a
        else:
            return a,b   #返回多个值
    
    num_1 = Add(5,6)
    num_2 = Add(5,5)
    num_3 = Add(6,5)     #以元组的形式返回
    
    print(type(num_3))
    print(num_1,num_2,num_3)
    
    
    """
    <class 'tuple'>
    11 10 (11, 1)
    """

    例6_2:

    x = 1
    y = 2
    def add (x, y):
        z = x + y
        return z
    	
    print(add(x,y))
    
    #上面代码的输出结果为:3

    例6_3:

    x = 1
    y = 2
    def add (x, y):
        z = x + y
        print(z)
    
    print(add(x,y))
    
    #上面代码的输出结果为:3、None

    注:

    1、代码6_2中的结果是打印返回值而得到的,例6_3中的结果是在打印函数add (x, y)时,add (x, y)执行print (z)语句而得到的,其返回值是None,所以输出结果应为3、None(返回值只有打印才能得到)

    2、在交互模式下,return的结果会自动打印出来,而作为脚本单独运行时则需要print函数才能显示

     

    多个返回值

    前面说了return 只能返回单值,但值可以存在多个元素。其实也就是说return可以有多个返回值。只是说是以元组的形式返回的

    例7:

    def func(x,y,z):
        x += 1
        y += 1
        z += 1
        return x,y,z   #这里存在多个返回值:隐式的以元组的形式返回
    
    print(type(func(1,2,3)))
    x,y,z = func(1,2,3) #使用序列解包,将返回的多个返回值分别赋值给x,y,z三个变量
    print(x,y,z)
    
    x1 = func(1,2,3) #这里就没有使用序列解包,而是使用一个变量来承接函数的返回值,更清晰的看出是一个元组
    print(x1)
    
    """
    <class 'tuple'>
    2 3 4
    (2, 3, 4)
    """

    注:

    1、函数有多个返回值时,只能使用相同数量的变量去承接函数的返回值(就是序列解包的规则:变量数量要与元素数量一致)

    2、函数有多个返回值时:
        ⑴如果要使用序列解包去承接函数的返回值:只能使用相同数量的变量去承接函数的返回值(就是序列解包的规则:变量数量要与元素数量一致)
        ⑵不使用序列解包:那么就只能用一个变量去承接函数的返回值(得到一个元组)
        ⑶一句话:函数有多个返回值时,要么使用与返回值个数相同的变量去承接,要么使用一个变量去承接

    3、需要注意的就是:函数有多个返回值,并使用序列解包将多个返回值分别赋值给多个变量时,对用于承接的变量的定义顺序是没啥要求的。只是跟return中返回值定义顺序有关

    例7_1:

    def func(x,y,z):
        x += 1
        y += 1
        z += 1
        return x,y,z   #这里存在多个返回值:隐式的以元组的形式返回
    
    
    a,b,c = func(1,2,3) #使用序列解包,将返回的多个返回值分别赋值给a,b,c三个变量
    print(a,b,c)  #函数第一个返回的是x,a变量是第一个,那么变量a对应的就是x了,按顺序来赋值的
    
    c,a,b = func(1,2,3) #使用序列解包,将返回的多个返回值分别赋值给c,a,b三个变量
    print(c,a,b)       #函数第一个返回的是x,c变量是第一个,那么变量c对应的就是x了,按顺序来赋值的
    
    
    """
    2 3 4
    2 3 4
    """

     

     

    函数嵌套

    函数有可见范围(内外可见关系),这就是作用域的概念;内部函数不能被外部直接调用,会抛异常 NameError。

    例8:

    def outer():
        def inner():  #可以理解为内部函数
            print("inner")  
        print("outer")
    outer()
    
    #输出结果:outer

    注:
    此时如果调用 outer(),只会执行 print("outer"),因为 inner 虽然在 outer 函数内,但它也是一个函数,函数如果要调用,就必须用 '函数名( )' 方式。

    例8_1:

    def outer():
        def inner():
            print("inner")
        print("outer")
        inner()
    
    outer()
    
    #输出结果:outer、inner
    

    调用函数时,必须加括号;如果是return funY,则返回的是这个函数所在的位置;如果后面跟的是函数名,加括号的,则表示调用这个函数。如果没有找到相应的函数,则报错。如果找到了对应的函数,并且对应参数一样,则会调用那个函数。

    例8_2:

    def funx(x):
        def funy(y):
            return x*y      #在外部函数中,不可以使用内部函数的参数,所以return funY(y)时,y是没有定义的
        return funy() 
    
    print(funx(5)(8))
    
    """
    上面代码的输出结果为:
    return funy()
    TypeError: funy() missing 1 required positional argument: 'y'
    """

    例8_3:

    def funx(x):
        def funy(y):
            return x*y
        return funy
    
    print(funx(5)(8))
    
    #上面代码的输出结果为:40

    例8_4:

    def lazy_sum(*args):
        def sum():
            x=0
            for n in args:
                x=x+n
            return x
        return sum
    
    
    lazy_sum(1,2,3,4,5,6,7,8,9) #这时候lazy_sum 并没有执行,而是返回一个指向求和的函数的函数名sum 的内存地址。
    f=lazy_sum(1,2,3,4,5,6,7,8,9)
    print(type(f))
    print(f())  # 调用f()函数,才真正调用了 sum 函数进行求和,
    
    """
    上面代码的输出结果:
    <class 'function'>
    45
    """

    注:
    1、闭包时牢记的一点就是:返回函数不要引用任何循环变量,或者后续会发生变化的变量。即包在里面的函数(本例为sum()),不要引用外部函数(本例为lazy_sum()的任何循环变量

    2、如果一定要引入循环变量,方法是再创建一个函数,用该函数的参数绑定循环变量当前的值,无论该循环变量后续如何更改,已绑定到函数参数的值不变

     

     

    拓展

    返回值补充

    例9:

    def func():
        for n in range(5):
            pass
            return n
    
    print(func())
    
    #0

    注:

    上面例子中return语句在for循环内,当第一次遍历后就会执行return语句,因此就不会在执行后面的代码(不会执行下一次循环,return语句表示一个函数的结束,与break语句差不多)

    例9_1:

    def func():
        for n in range(5):
            pass
        return n #这种写法在编辑器里面会有警告的提示(不会报错)
    
    print(func())
    
    #4

    注:

    上面例子中:return语句在for循环外(与for语句处于同一缩进),表示for全部完成后,执行return语句,最后一次遍历出来的元素为4,因此最终结果是4(结果为最后遍历的数)

    例9_2:

    def func():
        list = []
        for n in range(5):
            list.append(n)
            return list
    
    print(func())
    
    #[0]

    注:

    1、有时候我们需要在for循环外用到所有遍历出来的值,因此我们可以:新建一个容器来装遍历出来的元素,新建容器的语句需要在for循环之前,如果在循环内则会被初始化(下一次循环时被初始化)

    2、在上面的例子中:return该容器的语句在for循环内(属于for循环代码块),从输出结果可以看出最后的结果也只有第一次遍历的结果。这是因为return表示函数的结束,在第一次遍历后执行return语句并返回,函数就结束了(此时与break语句差不多),因此最终只有第一次遍历的结果

    例9_3:

    def func():
        list = []
        for n in range(5):
            list.append(n)
        return list
    
    print(func())
    
    #[0, 1, 2, 3, 4]

    注:

    1、在上面的例子中:return该容器的语句在for循环外(与for语句处于同一缩进),表示执行完所有遍历并加入到列表后(执行完for循环语句块后代码继续往下执行)在执行return语句,因此最终结果中是所有遍历出来的元素的列表 

    2、从例子中也可以看出:在这种用法中retuen语句与建立容器的语句处于同一缩进

     

     

    return语句与for循环、if语句一起使用

    需求

    遍历传入的列表(嵌套了字典的列表)
        ⑴如果列表中的某个字典的"C"键值符合要求(这里是dict["C"] == "6"),则返回对应字典(前提:只有单个字典符合条件)
        ⑵如果列表中的所有字典的"C"键值都不符合要求(这里是dict["C"] == "6"),则返回False
    例10:

    dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"6"}]
    
    def func(data):
        for eachDict in data:
            print("---",eachDict)
            if eachDict["C"] == "6":
                return eachDict
            else:
                return False
    
    result = func(dict)
    print(result)
    
    """
    输出结果:
    --- {'A': '1', 'B': '2', 'C': '3'}
    False
    """

    注:
    1、可以看到这里实际的输出结果跟我们预期的结果是不一样的:列表中的第二个字典是满足要求的,但是返回的是False(走的else)

    2、这个是因为:遍历出第一个字典时,此时这个字典时不满足要求的(不满足 if dict["C"] == "6"),因此它走的是else,并执行了"return False",执行return后for循环结束,不再继续遍历。因此根本就不会走到第二个字典那里了

    3、因此正确代码流程是:遍历完整个列表中的所有字典后,都没有满足要求的字典,这个时候才return False

    例10_1:

    dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"6"}]
    
    def func1(data):
        for eachDict in data:
            print("---",eachDict)
            if eachDict["C"] == "6":
                return eachDict
        else:
            return False
    
    result1 = func1(dict)
    print(result1)
    
    """
    --- {'A': '1', 'B': '2', 'C': '3'}
    --- {'A': '4', 'B': '5', 'C': '6'}
    {'A': '4', 'B': '5', 'C': '6'}
    """

    注:
    1、所以啊,在for循环或者while循环中使用return一定要注意return的使用位置以及分清楚具体的数据、场景是什么样的啊,想清楚所需要的代码流程是什么

    2、当然这种写法的话就必须满足:列表里面只有一个字典满足条件(dict["C"] == "6"),如果有多个字典满足条件那么就又有问题了

    3、如果在for和else之间(循环体内)存在if,也不会影响for和else的关系。因为for的级别比if高,else又是一个攀附权贵的家伙,根本不在乎是否有if,以及是否执行了满足if条件的语句。else的眼里只有for,只要for顺利执行完毕,else就会屁颠儿屁颠儿地跑一遍(这个例子中执行完if语句时会执行return语句,因此会介绍for循环,就不会执行else了)

    例11:

    dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"6"},{"A":"7","B":"8","C":"6"}]
    
    def func(data):
        for eachDict in data:
            print("---",eachDict)
            if eachDict["C"] == "6":
                return eachDict
        else:
            return False
    
    result = func(dict)
    print(result)
    
    """
    --- {'B': '2', 'C': '3', 'A': '1'}
    --- {'B': '5', 'C': '6', 'A': '4'}
    {'B': '5', 'C': '6', 'A': '4'}
    """


    例11_2:

    """
    需求:
    遍历传入的列表(嵌套了字典的列表)
        ⑴如果列表中的某些字典的"C"键值符合要求(这里是dict["C"] == "6"),则将其加到一个列表中并返回这个列表
        ⑵如果列表中的所有字典的"C"键值都不符合要求(这里是dict["C"] == "6"),则返回False
    
    """
    dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"6"},{"A":"7","B":"8","C":"6"}]
    
    resultList = []
    def func(data):
        for eachDict in data:
            print("---",eachDict)
            if eachDict["C"] == "6":
                resultList.append(eachDict)
        #else:    #这个时候else就不能在这里写else了,这样写的话return resultList就没意义了
            #return False
        return resultList
    
    result = func(dict)
    print(result)
    """
    --- {'C': '3', 'B': '2', 'A': '1'}
    --- {'C': '6', 'B': '5', 'A': '4'}
    --- {'C': '6', 'B': '8', 'A': '7'}
    [{'C': '6', 'B': '5', 'A': '4'}, {'C': '6', 'B': '8', 'A': '7'}]
    """

    注:
    1、如果要实现这个需求的话,肯定就不能按照上面这里例子这样来写了,因为这些写的话是不能同时满足需求1和需求2的,因此只能换一个思路来实现

    2、思路:因为要把满足条件的字典添加到列表中,如果for循环全部完成之后,对列表进行判断,如果列表还是空列表的话,说明所有字典都不满足条件,这个时候就可以返回False了

    例11_3:

    """
    需求:
    遍历传入的列表(嵌套了字典的列表)
        ⑴如果列表中的某个字典的"C"键值符合要求(这里是dict["C"] == "6"),则将其加到一个列表中并返回这个列表
        ⑵如果列表中的所有字典的"C"键值都不符合要求(这里是dict["C"] == "6"),则返回False
    
    """
    dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"6"},{"A":"7","B":"8","C":"6"}]
    
    
    def func(data):
        resultList = []
        for eachDict in data:
            print("---",eachDict)
            if "C" in eachDict and eachDict["C"] == "6": #判断"C"键在字典中并且"C"键值为6
                resultList.append(eachDict)
        if resultList:
            return resultList
        else:
            return False
    result = func(dict)
    print(result)
    
    """
    --- {'C': '3', 'B': '2', 'A': '1'}
    --- {'C': '6', 'B': '5', 'A': '4'}
    --- {'C': '6', 'B': '8', 'A': '7'}
    [{'C': '6', 'B': '5', 'A': '4'}, {'C': '6', 'B': '8', 'A': '7'}]
    """

    例11_4;

    dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"1"},{"A":"7","B":"8","C":"1"}]
    
    
    def func(data):
        resultList = []
        for eachDict in data:
            print("---",eachDict)
            if "C" in eachDict and eachDict["C"] == "6": #判断"C"键在字典中并且"C"键值为6
                resultList.append(eachDict)
        if resultList:
            return resultList
        else:
            return False
    result = func(dict)
    print(result)
    
    """
    --- {'B': '2', 'A': '1', 'C': '3'}
    --- {'B': '5', 'A': '4', 'C': '1'}
    --- {'B': '8', 'A': '7', 'C': '1'}
    False
    """

    注:
    1、Python中的for循环提供了python中最强大的循环结构(for循环是一种迭代循环机制,而while循环是条件循环,迭代即重复相同的逻辑操作,每次操作都是基于上一次的结果,而进行的)

    2、Python for循环可以遍历任何序列的项目,如一个列表或者一个字符串
        ⑴for循环可以用来遍历某一对象(遍历:通俗点说,就是把这个循环中的第一个元素到最后一个元素依次访问一次)
        ⑵一般来说for循环的执行过程为:迭代出一个元素后,继续执行for循环所属代码块,后面的代码块(属于for循环代码块的代码)执行完后,在进行下一个迭代。所有元素遍历完成后,再执行与for循环同一层级的代码
        ⑶比如这个例子中的for循环与if...else处于相同缩进的,是并列关系的(同一代码块),因此会执行完for循环后再执行if...else

    3、当return语句用在for循环、while循环中时,一定要注意return的使用位置啊!!!

     

    展开全文
  • system返回值

    2019-02-18 15:48:55
    例: status = system("./test.sh"); 1、正确退出后。还需要再判断,操作成功或者操作失败。...(2)shell返回值:指system所调用的shell命令的返回值,比如上例中,test.sh中返回的值为shell返回值。...

    例:

    status = system("./test.sh");

    1、正确退出后。还需要再判断,操作成功或者操作失败。

    2、错误退出。

    1、先统一两个说法:
    (1)system返回值:指调用system函数后的返回值,比如上例中status为system返回值
    (2)shell返回值:指system所调用的shell命令的返回值,比如上例中,test.sh中返回的值为shell返回值。

    2、如何正确判断test.sh是否正确执行?
    仅判断status是否==0?或者仅判断status是否!=-1?

    都错!

    3、man中对于system的说明

    RETURN VALUE
           The value returned is -1 on error (e.g.  fork() failed), and the return
           status  of  the command otherwise.  This latter return status is in the
           format specified in wait(2).  Thus, the exit code of the  command  will
           be  WEXITSTATUS(status).   In  case  /bin/sh could not be executed, the
           exit status will be that of a command that does exit(127).
    看得很晕吧?

    system函数对返回值的处理,涉及3个阶段:
    阶段1:创建子进程等准备工作。如果失败,返回-1。
    阶段2:调用/bin/sh拉起shell脚本,如果拉起失败或者shell未正常执行结束(参见备注1),原因值被写入到status的低0~7比特位中。system的man中只说明了会写了127这个值,但实测发现还会写126等值。低8bit为0
    阶段3:如果shell脚本正常执行结束,将shell返回值填到status的高8~15比特位中。
    备注1:
    只要能够调用到/bin/sh,并且执行shell过程中没有被其他信号异常中断,都算正常结束。
    比如:不管shell脚本中返回什么原因值,是0还是非0,都算正常执行结束。即使shell脚本不存在或没有执行权限,也都算正常执行结束。
    如果shell脚本执行过程中被强制kill掉等情况则算异常结束。

    如何判断阶段2中,shell脚本是否正常执行结束呢?系统提供了宏:WIFEXITED(status)。如果WIFEXITED(status)为真,则说明正常结束。
    如何取得阶段3中的shell返回值?你可以直接通过右移8bit来实现,但安全的做法是使用系统提供的宏:WEXITSTATUS(status)。


    由于我们一般在shell脚本中会通过返回值判断本脚本是否正常执行,如果成功返回0,失败返回正数。
    所以综上,判断一个system函数调用shell脚本是否正常结束的方法应该是如下3个条件同时成立:
    (1)-1 != status
    (2)WIFEXITED(status)为真 低8bit为0
    (3)0 == WEXITSTATUS(status)  高8bit为0

    注意:
    根据以上分析,当shell脚本不存在、没有执行权限等场景下时,以上前2个条件仍会成立,此时WEXITSTATUS(status)为127,126等数值。
    所以,我们在shell脚本中不能将127,126等数值定义为返回值,否则无法区分中是shell的返回值,还是调用shell脚本异常的原因值。shell脚本中的返回值最好多1开始递增。

    判断shell脚本正常执行结束的健全代码如下
     

    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/wait.h>
    #include <sys/types.h>
     
    int main()
    {
        pid_t status;
     
     
        status = system("./test.sh");
     
        if (-1 == status)
        {
            printf("system error!");
        }
        else
        {
            printf("exit status value = [0x%x]\n", status);
     
            if (WIFEXITED(status))// //正确退出
            {
                if (0 == WEXITSTATUS(status))//操作成功
                {
                    printf("run shell script successfully.\n");
                }
                else
                {
                    printf("run shell script fail, script exit code: %d\n", WEXITSTATUS(status));
                }
            }
            else
            {
                printf("exit status = [%d]\n", WEXITSTATUS(status));
            }
        }
     
        return 0;
    }
    

    WIFEXITED(stat_val) Evaluates to a non-zero value if status
    was returned for a child process that
    terminated normally.

    WEXITSTATUS(stat_val) If the value of WIFEXITED(stat_val) is
    non-zero, this macro evaluates to the
    low-order 8 bits of the status argument
    that the child process passed to _exit()
    or exit(), or the value the child
    process returned from main().
    ---------------------  
    作者:cheyo车油  
    来源:CSDN  
    原文:https://blog.csdn.net/cheyo/article/details/6595955  
    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • 对比有返回值和无返回值 题目1:定义一个方法,求出两数之和。 题目2:定义一个方法,打印两数之和。 */ package com.xiaxia; public class Method4 {// Method:方法 public static void main(String[] args) { ...

    /*
    对比有返回值和无返回值

    题目1:定义一个方法,求出两数之和。
    题目2:定义一个方法,打印两数之和。
    

    */
    package com.xiaxia;

    public class Method4 {// Method:方法

    public static void main(String[] args) {
    	System.out.println("===赋值调用 有返回值的test1方法===");
    	int num1 = test1(2, 3);
    	System.out.println(num1);
    
    	System.out.println("===打印调用 有返回值的test1方法===");
    	System.out.println(test1(2, 3));
    
    	System.out.println("===单独调用 有返回值的test1方法(但是没有用到返回值,无结果)===");
    	test1(2, 3);
    
    	System.out.println("===单独调用 无返回值的test2方法(无返回值的方法只能单独调用)===");
    	test2(2, 3);
    
    }
    
    public static int test1(int a, int b) {// 有返回值int,谁调用就把计算结果告诉谁
    	int c = a + b;
    	return c;
    }
    
    public static void test2(int a, int b) {// 无返回值
    	int c = a + b;
    	System.out.println(c);
    }
    

    }

    在这里插入图片描述

    展开全文
  • C++返回值

    千次阅读 2019-04-28 23:27:45
    返回值函数 没有返回值的return语句只能用在返回类型是void的函数中,这类函数在最后一句后面会隐式执行return语句,一个返回类型是void的函数也能使用return加表达式,不过此时这个表达式必须是另一个返回void的...
  • 剩下的都交给idea好了,idea会自动判断返回值的类型,以及建议返回值的名称 具体操作 写完代码再行尾 使用快捷键 ctrl alt v 或者干脆 在行尾加 .var 回车即可 但是有时候idea 在写scala 的时候不会自动添加...
  • C++ 返回值

    2018-05-15 17:12:01
    c++ 返回值用到一个列表,返回值是list&amp;,发现执行完函数返回一个空列表,原因是函数内返回的临时列表变量,当函数执行完毕,临时变量回收,返回的别名和指针也就空了,当返回不是指针或别名时,列表就不空...
  • 函数返回值(包含const返回值解析)

    千次阅读 2019-04-01 11:16:08
    如何返回值 1.返回值非引用 primer说函数返回值用于初始化函数调用点的一个临时对象,所以返回值到临时对象是第一次拷贝,临时对象到接收值的变量是第二次拷贝。 string make_plural(size_t ctr, const string &...
  • 函数的返回值

    千次阅读 2019-06-30 18:52:19
    1.什么是函数的返回值? print 和 return 的区别,print 仅仅是打印在控制台,而 return 则是将 return 后面的部分作为返回值作为函数的输出 可以用变量接走,继续使用该返回值做其它事 函数需要先定义后调用,...
  • java中有返回值的函数中throw new exception会给函数返回值吗?返回值是什么?
  • typeof返回值

    千次阅读 2018-10-13 22:05:45
    对于js中的typeof几个特殊值的返回类型总是记不太清楚,记录下来方便自己记忆,有错的地方也欢迎...typeof返回值也有六种,分别是: number string Boolean object undefined function 可以看到,typeof...
  • Laravel返回值

    千次阅读 2019-01-18 16:40:36
    先理解几个概念: StdClass 对象 =&gt; 基础的对象 Eloquent 模型对象(Model 对象) =&gt; 和模型相关的类对象 Eloquent 集合 =&gt; 可以简单理解为对象数组... 返回值:数组结果,其中每一个结果都是...
  • 知道调用这个方法,每次都是直接写完这个方法,还要写返回值,idea给他们提供了相关的自动补全功能 更好用的是IDEA 强大的 Live Templates(转) 再比如说,想遍历某个list,可以直接list.for 回车就可以自动...
  • 输出返回值

    2018-08-08 19:05:47
    1.比较语句返回值的输出  bollean b = p2.compare(p1);  System.out.println(b); 在学习过程中遇到这个问题,借此分享 2.直接把函数调用的代码放到打印语句中...
  • 场景:在微服务中,一般...返回值对象 package com.study.auth.comm; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.annotation.JSONField; import com.alibaba.fastjson.serializer.Serialize..
  • mybatis返回值

    2018-11-07 17:50:17
    mybatis的返回值resultmap和resulttype 1 resulttype 使用的是“automapper”自动映射。意思就是,不需要配置属性和列的对应关系,在属性和列同名的情况下,查询的结果会自动匹配。   2 resultmap 1)单表查询 ...
  • 方法返回值类型

    2019-09-28 08:27:47
    方法返回值类型 首先,在方法声明中我们必须指定返回值类型,如果一个方法没有返回值类型,则必须使用void关键字作为返回值类型,如果方法声明时指定了返回值类型,就必须在方法体中使用return语句返回相应类型的值...
  • 看旋转编码器程序的时候,遇见了一些关于函数返回值的函数,感觉很懵逼,就百度了一下C语言函数调用,感觉写的挺好的, 原链接:http://c.biancheng.net/view/204.html   通常我们希望通过函数调用使主调函数能...
  • golang命名返回值函数与未命名返回值函数介绍 1、golang函数返回值可在定义时给出变量名称 //未命名返回值函数 func test1(num int) int { return num + 1 } //命名返回值函数 func test2(num int) (res int...
  • (1)system返回值:指调用system函数后的返回值,比如上例中status为system返回值 (2)shell返回值:指system所调用的shell命令的返回值,比如上例中,test.sh中返回的值为shell返回值。 2、如何正确判断...
  • (tip)谨慎使用defer修改返回值

    万次阅读 2020-09-22 21:32:33
    golang在defer修改返回值时需要格外注意! 如果未提前声明返回值的话,在defer中修改返回值是无效的操作。原因如下: package main func test1() int { i := 1 defer func() { // 实际则是将局部变量i的地址指针...
  • golang命名返回值

    2019-09-19 10:21:25
    go函数命名返回值 函数接收参数 在go中函数可以返回多个结果参数 而不仅仅是一个值 他们可以像变量那样命名和使用 如果命名了返回值参数 一个没有参数的return语句 会将当前的值作为返回值返回 注意 如果...
  • 返回值类型详解

    2019-08-12 18:49:17
    多态作为返回值 返回值类型 基本类型(前面讲过,不解释) 引用类型 普通类 当一个方法的返回值是一个普通的类时,实际上返回的是该类的对象,我们可以使用该类的对象接收 抽象类 当一个方法的返回值是一个抽象...
  • IDEA返回值快捷键

    千次阅读 2020-01-15 10:04:55
    IDEA 将光标定位到需要生成返回值那行的末尾处,使用下面快捷键 Ctrl + Alt + v
  • 匿名返回值顾名思义,未对函数的返回值作命名,是隐藏的,如下代码: func anonymousReturnValues() int { var res int defer func() { res++ fmt.Println("defer") }() return re...
  • @Repository public interface ... //返回值用接口类型接收(DicItemVO 为接口类型,无需自己实现) List<DicItemVO> findByIseffectTrueAndIsdeleteFalse(); } 返回值类型 public interface DicItemVO {
  • jQuery Ajax 返回值

    千次阅读 2017-10-08 21:58:44
    Ajax返回值 ,无法获取返回值问题,undefined
  • return返回值调用

    2020-03-09 15:56:58
    函数中的返回值: 函数中的返回值是由return来决定的 函数中可不可返回两个值? 可以 函数中没有return就没有返回值,调用函数得到的结果就是None 函数中返回多个值,直接写在return后面用逗号隔开就可以的 当...
  • swagger 返回值描述

    千次阅读 2019-01-17 20:15:35
    今天被前端训了一顿,慌得一逼,说你们写的接口,返回值写的是什么东西,只有公共的三个字段......我们的API文档是基于 swagger组件写的.如是有了下面的东东示例:1.1. 返回字段1.1.1. 返回字段(对象)1. 将现有接口 @...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 222,802
精华内容 89,120
关键字:

返回值