返回值 订阅
一个函数的函数名既是该函数的代表,也是一个变量。由于函数名变量通常用来把函数的处理结果数据返回给调用函数,即递归调用,所以一般把函数名变量称为返回值,函数的返回值类型是在定义函数时指定的。 [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、结束函数调用

    2、返回指定的返回值

     

     

    作用:结束函数调用

    1、return关键字的第一个作用就是结束函数调用:执行return关键字后就不会在执行return之后的任何代码了(函数内的代码)

    例1_1:

    def func(a,b):
        return a + b
        print("a")
    
    print(func(1,2))
    print("aaa")
    
    """
    3
    aaa
    """

    注:

    1、上面例子中:print("a")语句虽然不会报错,但是编辑器会有提示,因为他毫无意义
        ⑴因为函数在执行return语句后,就会停止(不会继续往下执行),因此这里的print("a")没有任何意义,永远不也不会执行
        ⑵当然return语句仅仅是结束函数的调用,如果后面还有其他代码(不属于函数的代码),也会继续往下执行:print("aaa")

    2、结束函数调用:也并不意味着一个函数体中只能有一个return语句

    例1_2:

    def testReturn(x):
        if x > 100:
            return x # 满足该分支条件时,执行return语句,结束整个函数的调用
            # print("a") # 这条语句实际是没有任何意义的,执行return后结束函数调用,永远也不会执行该条语句
        else:
            return x + 1
        # print("a") # 这条语句实际是没有任何意义的,不管语句走哪条分支,都会执行对应的return,不管怎么样都不会执行到该条语句
    
    print(testReturn(999))
    # return使用说明:
    # (1)返回函数的返回值
    # (2)终止程序的运行,提前退出.(例如:当函数内有错误发生时,使用return可以终止函数的运行)
    
    # 999

    例1_3:

    def testReturn(x):
        if x > 100:
            return x #满足该分支条件时,执行return语句,结束整个函数的调用,即使是后面与if同一级的代码也不会执行
            # print("a") # 这条语句实际是没有任何意义的,执行return后结束函数调用,永远也不会执行该条语句
        else:
            print("a") # else分支中无return,走该分支时代码可以继续往下走(相当于就是在分支语句中留了一个缺口,代码可以在经过判断后从这个缺口继续往下走,这个缺口留在if条件中意思也是一样的)
        print("b")
        return x + 1 # 在这里才会结束函数调用
    
    print(testReturn(9))
    # return使用说明:
    # (1)返回函数的返回值
    # (2)终止程序的运行,提前退出.(例如:当函数内有错误发生时,使用return可以终止函数的运行)
    
    """
    a
    b
    10
    """

    例1_4:

    def testReturn(x):
        if x > 100:
            return x #满足该分支条件时,执行return语句,结束整个函数的调用,即使是后面与if同一级的代码也不会执行
            # print("a") # 这条语句实际是没有任何意义的,执行return后结束函数调用,永远也不会执行该条语句
        else:
            print("a") # else分支中无return,走该分支时代码可以继续往下走
        print("b")
        return x + 1 # 在这里才会结束函数调用
    
    print(testReturn(199))
    
    """
    199
    """

     

    作用:返回值

    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的使用位置啊!!!

     

    展开全文
  • 上述函数中返回值只指定是int,并未指定返回值名称,必须在函数内部return语句后进行指定返回值名称,不指定则报错! 二、命名返回值 命名返回值顾名思义就是可以给一个函数的返回值指定名字。如果指定了一个
  • 作为程序猿,我们都知道参数和返回值是编程领域不可分割的两大块,此前分享了下WebApi的传参机制,今天再来看看WebApi里面另一个重要而又基础的知识点:返回值。还是那句话:本篇针对初初使用WebApi的同学们,比较...
  • shell查看返回值,shell查看返回值,shell查看返回值,shell查看返回值
  • 主要介绍了Mysql带返回值与不带返回值的2种存储过程写法,需要的朋友可以参考下
  • 知道调用这个方法,每次都是直接写完这个方法,还要写返回值,idea给他们提供了相关的自动补全功能 更好用的是IDEA 强大的 Live Templates(转) 再比如说,想遍历某个list,可以直接list.for 回车就可以自动...

    写代码的时候,我们经常会遇到使用某个类的某个方法,比如nio中Selector.open()。知道调用这个方法,每次都是直接写完这个方法,还要写返回值,idea给他们提供了相关的自动补全功能

    更好用的是 IDEA 强大的 Live Templates(转)

    再比如说,想遍历某个list,可以直接list.for 回车就可以自动生成for (XXX xxx : lsit)的代码结构了。

    再比如说,想输出1 + 2 的结果,可以直接1 + 2.sout 回车就可以自动生成System.out.println(1+2)

    再比如说,new A(),想要声明一下, 直接new A().var,就会生成 A a = new A()

    command  + enter 这个快捷键简直神器,小伙伴们,可以搜搜别人都是如何使用的。

    展开全文
  • C++返回值

    千次阅读 2019-04-28 23:27:45
    返回值函数 没有返回值的return语句只能用在返回类型是void的函数中,这类函数在最后一句后面会隐式执行return语句,一个返回类型是void的函数也能使用return加表达式,不过此时这个表达式必须是另一个返回void的...

    无返回值函数

    没有返回值的return语句只能用在返回类型是void的函数中,这类函数在最后一句后面会隐式执行return语句,一个返回类型是void的函数也能使用return加表达式,不过此时这个表达式必须是另一个返回void的函数。

    void func1(int value)
    {
    	std::cout << value << std::endl;
    }
    
    void func2(int value)
    {
    	return func1(value);
    }
    
    
    int main(void)
    {
    	func2(100);
    	system("pause");
    	return 0;
    }
    

    返回“值”和返回引用的区别

    返回一个值的方式和初始化一个变量或形参的方式完全一样,如果返回值的类型是非引用类型,则会发生拷贝,否则不会。

    std::string g_str="hello";
    
    std::string func1()
    {
    	return g_str;
    }
    
    std::string& func2()
    {
    	return g_str;
    }
    
    
    int main(void)
    {
    	func1() = "123";
    	std::cout << g_str << std::endl;//hello
    	func2() = "456";
    	std::cout << g_str << std::endl;//456
    	system("pause");
    	return 0;
    }
    

    不要返回局部对象的引用或指针

    函数完成后,它所占用的存储空间也随之释放,因此,函数终止意味着局部变量的引用将指向不再有效的内存区域。

    std::string &func()
    {
    	std::string ret = "111";
    	return ret;
    }
    
    int main(void)
    {
    	//严重错误
    	std::cout << func() << std::endl;
    	system("pause");
    	return 0;
    }
    

    返回数组类型

    因为数组不能被拷贝,所以函数不能返回数组,不过函数可以返回数组的指针或引用,从语法上来讲,最简单的方式是定义数组的类型别名,然后再使用其指针或引用类型,直接使用数组的指针或引用比较麻烦。

    typedef int XYArray[10];
    
    XYArray* func(XYArray* value)
    {
    	*value[0] = 10;
    	return value;
    }
    
    
    int main(void)
    {
    	XYArray array1 = { 0 };
    	(*func(&array1))[1]=100;
    	std::cout << array1[0] << std::endl;
    	std::cout << array1[1] << std::endl;
    	system("pause");
    	return 0;
    }
    

    如果要定义一个返回数组指针的函数,则数组的维度必须跟在函数名字和形参列表之后:
    Type (*function(paramlist)) [dimension]

    typedef int XYArray[10];
    
    
    int(* func(XYArray* value))[10]
    {
    	*value[0] = 10;
    	return value;
    }
    
    
    int main(void)
    {
    	XYArray array1 = { 0 };
    	(*func(&array1))[1]=100;
    	std::cout << array1[0] << std::endl;
    	std::cout << array1[1] << std::endl;
    	system("pause");
    	return 0;
    }
    

    为什么返回数组指针的函数要多加一对括号呢,因为和下面的代码一样,如果不加括号,则会被定义成含有x个指针的数组。

    	int arr[10];//含有10个int的数组
    	int *arr1[10];//含有10个指针的数组
    	int(*arr2)[10];//指向含有10个int的数组的指针
    

    尾置返回类型

    在C++11新标准中还有一种可以简化上述函数声明的方法,就是尾置返回类型,这种形式对于返回类型比较复杂的函数最有效。尾置返回类型跟在形参列表后面并以一个->符号开头,原本的返回类型则替换成auto。

    typedef int XYArray[10];
    
    
    auto func(XYArray* value)->int (*)[10]
    {
    	*value[0] = 10;
    	return value;
    }
    
    
    int main(void)
    {
    	XYArray array1 = { 0 };
    	(*func(&array1))[1]=100;
    	std::cout << array1[0] << std::endl;
    	std::cout << array1[1] << std::endl;
    	system("pause");
    	return 0;
    }
    
    展开全文
  • GetLastError返回值

    2012-08-09 10:28:57
    GetLastError返回值,详细描述GetLastError返回值的意义
  • 主要介绍了Python函数返回值,实例分析了Python中返回一个返回值与多个返回值的方法,需要的朋友可以参考下
  • 函数的返回值

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

    千次阅读 2019-02-18 15:48:55
    例: status = system("./test.sh"); 1、正确退出后。还需要再判断,操作成功或者操作失败。...(2)shell返回值:指system所调用的shell命令的返回值,比如上例中,test.sh中返回的值为shell返回值。...
  • 在获取update操作的返回值时遇到了一个问题,似乎 Mybatis 进行 update 操作得到的 int 返回值并不是影响的行数,下面通过本文给大家分享Mybatis Update操作返回值问题,需要的朋友参考下吧
  • 易语言DLL返回值扩展源码,DLL返回值扩展,子程序_模拟DLL模块,API_复制内存
  • return返回值用法

    万次阅读 2017-03-15 19:48:25
    //这个类就意味着是一个有返回值为int的类 //一般不需要返回值就把int换为void //然后是代码 return x+y; //return int型的值 } 返回值是必须有的,作用就是把固定不变的、常用的代码封装起来写在类里...
  • GetLastError返回值.docx

    2019-05-09 08:20:47
    GetLastError返回值总结整理,包含3259个返回值类型。
  • 0x 00 返回值简介 回顾下,上一节简单介绍了函数及其各种参数,其中也有简单介绍 print 和 return 的区别,print 仅仅是打印在控制台,而 return 则是将 return 后面的部分作为返回值作为函数的输出,可以用变量接...
  • Laravel返回值

    千次阅读 2019-01-18 16:40:36
    先理解几个概念: StdClass 对象 =&gt; 基础的对象 Eloquent 模型对象(Model 对象) =&gt; 和模型相关的类对象 Eloquent 集合 =&gt; 可以简单理解为对象数组... 返回值:数组结果,其中每一个结果都是...
  • 剩下的都交给idea好了,idea会自动判断返回值的类型,以及建议返回值的名称 具体操作 写完代码再行尾 使用快捷键 ctrl alt v 或者干脆 在行尾加 .var 回车即可 但是有时候idea 在写scala 的时候不会自动添加...
  • printf函数返回值

    2015-08-26 10:39:25
    printf函数返回值
  • java return 返回值

    2018-05-31 09:38:49
    java 中的返回值return的简单应用,及一个代码,更利于大家学习java中的return章节
  • js获取ajax返回值代码

    2020-10-26 00:26:14
    主要介绍了js如何获取ajax的返回值,需要的朋友可以参考下
  • golang命名返回值函数与未命名返回值函数介绍 1、golang函数返回值可在定义时给出变量名称 //未命名返回值函数 func test1(num int) int { return num + 1 } //命名返回值函数 func test2(num int) (res int...
  • 本文介绍在自定义PowerShell函数时,如何设置返回值的数据类型。PowerShell函数的返回值可以有类型,也可以没有类型,跟输入参数相似。   定义PowerShell函数的返回值类型,要使用OutputType这个指令。将这个指令放...
  • 主要介绍了python读取oracle函数返回值的相关资料,感兴趣的小伙伴们可以参考一下
  • 返回值类型详解

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

    千次阅读 2019-04-01 11:16:08
    如何返回值 1.返回值非引用 primer说函数返回值用于初始化函数调用点的一个临时对象,所以返回值到临时对象是第一次拷贝,临时对象到接收值的变量是第二次拷贝。 string make_plural(size_t ctr, const string &...
  • 无参无返回值 //打印输出星号的方法 //创建一个MethodDemo类的对象myMethodDemo //使用对象名。方法名()去调用方法 无参带返回值 //求长方形面积的方法 //返回语句 无参无返回值 //求最大的方法 等Java的方法和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,091,264
精华内容 836,505
关键字:

返回值