python:返回值

返回值简介

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

 

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 创作都市 设计师:CSDN官方博客 返回首页