python：返回值

返回值简介

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

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

def func(x,y):
    num = x + y
    return

print(func(1,2))

#上面代码的输出结果为：None

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

return 语句的作用：

结束函数调用、返回值

指定返回值与隐含返回值：

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

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

指定 return 返回值函数举例：　

def showplus(x):
    print(x)
    return x + 1
     
num = showplus(6)
add = num + 2

print(add)

#上面函数的输出结果为：6、9

隐含 return None 举例：

def showplus(x):
    print(x)
 
num = showplus(6)
print(num)

print(type(num))
 
"""
上面函数的输出结果为：6
6
None
<class 'NoneType'>
"""

函数返回值赋值给变量：

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 )

 

return 语句位置与多条 return 语句

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

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

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

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

5、如果函数执行了 return 语句，函数会立刻返回，结束调用，return 之后的其它语句都不会被执行了(可用于结束代码块)

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
"""

例1：

def showplus(x):
    print(x + 2)
    return x + 1

num = showplus(6)  #将返回值赋值给一个变量
print(num)

#上面函数的输出结果为：8、7

 

返回值类型

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

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

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

例2：

def showlist():
    return [1,3,5]   #多元素，返回的是什么类型

print(type(showlist()))
print(showlist())

"""
输出结果：
<class 'list'>
[1, 3, 5]    #列表类型
"""

例2_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)
"""

例3：

x = 1
y = 2
def add (x, y):
    z = x + y
    return z
	
print(add(x,y))

#上面代码的输出结果为：3

例3_1：

x = 1
y = 2
def add (x, y):
    z = x + y
    print(z)

print(add(x,y))

#上面代码的输出结果为：3、None

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

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

函数嵌套

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

例4：

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

#输出结果：outer

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

例5：

def outer():
    def inner():
        print("inner")
    print("outer")
    inner()

outer()

#输出结果：outer、inner

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

例6：

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'
"""

例7：

def funx(x):
    def funy(y):
        return x*y
    return funy

print(funx(5)(8))

#上面代码的输出结果为：40

例8：

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、如果一定要引入循环变量，方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变