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

    万次阅读 多人点赞 2018-03-12 08:56:41
    一、返回一般数据类型 比如要根据id 属性获得数据库中的某个字段值。 mapper 接口: // 根据id 获得数据库中的username 字段的值 String getEmpNameById... 指定resultType 返回值类型时String 类型的, str...

    一、返回一般数据类型

    比如要根据 id 属性获得数据库中的某个字段值。

    mapper 接口:

        // 根据 id 获得数据库中的 username 字段的值
        String getEmpNameById(Integer id);

    SQL 映射文件:

        <!-- 
            指定 resultType 返回值类型时 String 类型的,
            string 在这里是一个别名,代表的是 java.lang.String 
    
            对于引用数据类型,都是将大写字母转小写,比如 HashMap 对应的别名是 'hashmap'
            基本数据类型考虑到重复的问题,会在其前面加上 '_',比如 byte 对应的别名是 '_byte'
        -->
        <select id="getEmpNameById" resultType="string">
            select username from t_employee where id = #{id}
        </select>

    二、返回 JavaBean 类型

    比如根据某个字段获得数据库中的信息,把查询的结果信息封装成某个 JavaBean 类型的数据。

    mapper 接口:

        // 根据 id 查询信息,并把信息封装成 Employee 对象
        Employee getEmpById(Integer id);

    SQL 映射文件:

        <!-- 
            通过 resultType 指定查询的结果是 Employee 类型的数据  
            只需要指定 resultType 的类型,MyBatis 会自动将查询的结果映射成 JavaBean 中的属性
        -->
        <select id="getEmpById" resultType="employee">
            select * from t_employee where id = #{id}
        </select>

    三、返回List类型

    有时候我们要查询的数据不止一条,比如:模糊查询,全表查询等,这时候返回的数据可能不止是一条数据,对于多数据的处理可以存放在List集合中。

    mapper 接口:

        // 假如是全表查询数据,将查询的数据封装成 Employee 类型的集合
        List<Employee> getAllEmps();

    SQL 映射文件:

        <!--
            注意这里的 resultType 返回值类型是集合内存储数据的类型,不是 'list'
        -->
        <select id="getAllEmps" resultType="employee">
            select * from t_employee
        </select>

    四、返回Map类型

    MyBatis 还支持将查询的数据封装成Map

    1. 如果查询的结果是一条,我们可以把查询的数据以{表字段名, 对应的值}方式存入到Map中。

    mapper 接口:

        //  根据 id 查询信息,并把结果信息封装成 Map 
        Map<String, Object> getEmpAsMapById(Integer id);

    SQL 映射文件:

        <!-- 
            注意这里的 resultType 返回值类型是 'map'
         -->
        <select id="getEmpAsMapById" resultType="map">
            select * from t_employee where id = #{id}
        </select>

    下面把查询的结果数据贴出来供大家参考:
    这里写图片描述
    2. 如果查询的结果是多条数据,我们也可以把查询的数据以{表中某一字段名, JavaBean}方式来封装成Map

    mapper 接口:

        // 查询所有员工的信息,把数据库中的 'id' 字段作为 key,对应的 value 封装成 Employee 对象
        // @MapKey 中的值表示用数据库中的哪个字段名作 key
        @MapKey("id")
        Map<Integer, Employee> getAllEmpsAsMap();

    SQL 映射文件:

        <!--
            注意 resultType 返回值类型,不再是 'map',而是 Map 的 value 对应的 JavaBean 类型
        -->
        <select id="getAllEmpsAsMap" resultType="employee">
            select * from t_employee
        </select>

    下面是查询的结果 (只截取了一部分):
    这里写图片描述

    MyBatis 允许查询的结果封装成Map,这种机制是极好的。

    五、扩展

    扩展. 上面返回结果的形式都是基于查询 (select) 的,其实对于增删改的操作也可以返回一定类型的数据,比如BooleanInteger等。

    总结. 这篇博文主要介绍了在开发中常用的几种数据返回值类型,希望能够为你提供帮助。

    展开全文
  • C/C++ 引用作为函数的返回值

    万次阅读 多人点赞 2018-08-04 13:19:48
    语法:类型 &...2.用引用作函数的返回值的最大的好处是在内存中不产生返回值的副本 //代码来源:RUNOOB #include&lt;iostream&gt; 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的使用位置啊!!!

     

    展开全文
  • 函数返回值

    2019-05-31 04:58:58
    函数返回值 c++语言中规定函数的返回值类型是由定义该函数时所指定的函数类型决定 (1)return语句可以是一个表达式,函数先计算表达式后再返回值。 (2)函数的返回值通过return语句获得。函数只能有唯一...

    函数返回值

    c++语言中规定函数的返回值类型是由定义该函数时所指定的函数类型决定

    (1)return语句可以是一个表达式,函数先计算表达式后再返回值。

    (2)函数的返回值通过return语句获得。函数只能有唯一的返回值。若return后有多个返回值且以逗号隔开,以最后的表达式值为准。

    (3)return语句可以终止函数,并将控制返回到主调函数;一个函数中可以有一个以上的return语句,执行到哪一个return语句,哪一个语句起作用。

     

    案例:计算2和3加减乘除结果,要求加减乘除各一个方法,且方法中不输出结果由主函数输出。

     

     

     

     

    展开全文
  • system返回值

    2019-02-18 15:48:55
    例: status = system("./test.sh"); 1、正确退出后。还需要再判断,操作成功或者操作失败。...(2)shell返回值:指system所调用的shell命令的返回值,比如上例中,test.sh中返回的值为shell返回值。...
  • 场景:在微服务中,一般...返回值对象 package com.study.auth.comm; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.annotation.JSONField; import com.alibaba.fastjson.serializer.Serialize..
  • 对比有返回值和无返回值 题目1:定义一个方法,求出两数之和。 题目2:定义一个方法,打印两数之和。 */ package com.xiaxia; public class Method4 {// Method:方法 public static void main(String[] args) { ...
  • 剩下的都交给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; 可以简单理解为对象数组... 返回值:数组结果,其中每一个结果都是...
  • 输出返回值

    2018-08-08 19:05:47
    1.比较语句返回值的输出  bollean b = p2.compare(p1);  System.out.println(b); 在学习过程中遇到这个问题,借此分享 2.直接把函数调用的代码放到打印语句中...
  • 方法返回值类型

    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...
  • C语言标准中,main函数的返回值类型为________,它有________个参数。
  • (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的地址指针...
  • 知道调用这个方法,每次都是直接写完这个方法,还要写返回值,idea给他们提供了相关的自动补全功能 更好用的是IDEA 强大的 Live Templates(转) 再比如说,想遍历某个list,可以直接list.for 回车就可以自动...
  • golang命名返回值

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

    2019-08-12 18:49:17
    多态作为返回值 返回值类型 基本类型(前面讲过,不解释) 引用类型 普通类 当一个方法的返回值是一个普通的类时,实际上返回的是该类的对象,我们可以使用该类的对象接收 抽象类 当一个方法的返回值是一个抽象...
  • 匿名返回值顾名思义,未对函数的返回值作命名,是隐藏的,如下代码: func anonymousReturnValues() int { var res int defer func() { res++ fmt.Println("defer") }() return re...
  • IDEA返回值快捷键

    千次阅读 2020-01-15 10:04:55
    IDEA 将光标定位到需要生成返回值那行的末尾处,使用下面快捷键 Ctrl + Alt + v
  • @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后面用逗号隔开就可以的 当...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 231,778
精华内容 92,711
关键字:

返回值