1、简单介绍print和return的区别：
⑴print仅仅是打印在控制台，只是为了能在控制台看到某个输出
⑵return则是将return后面的部分作为返回值(作为函数的输出，可以用变量接走，继续使用该返回值做其它事)
2、函数需要先定义后调用，函数体中return语句的结果就是返回值
⑴一个函数可以没有显式的写reutrn语句
⑵函数无reutrn语句时，会隐式的返回一个None(即return None)：返回值是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
1、结束函数调用
2、返回指定的返回值
作用：结束函数调用1、return关键字的第一个作用就是结束函数调用：执行return关键字后就不会在执行return之后的任何代码了
⑴不会执行该函数内的代码：return之后的任何代码
⑵但会继续往下执行不属于函数的代码
例2：
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语句
例3：
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
例4：
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
"""
例5：
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 返回值函数举例例6：
def showplus(x):
result = x + 1
return result # 定义具体返回的值
num = showplus(6) # 将函数的返回值赋值给一个变量：num
print(num)
# 7
隐含 return None 举例
例7：
def showplus(x,y):
print(x + y) #这里仅仅是打印x+y，对具体返回的是什么没有任何影响
num = showplus(6,1) #这里的num才是执行函数后，函数的返回值(将函数的返回值赋值给一个变量)
print(num)
print(type(num))
"""
7
None
"""
函数返回值赋值给变量
例8：函数内调用
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
例9： 函数外调用
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
例10：
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、函数的返回值：作为函数的输出，可以用变量接走，继续使用该返回值做其它事(比如被其他函数使用等)
4、函数的目的是：用于完成某些功能或业务处理(一般来说一个函数对应一个业务、一个功能)
⑴有些函数可能会有返回值：用于其他函数使用这个函数处理后的结果
①函数用于获取数据、处理数据等
⑵有些函数可能没有显式的返回值(默认返回None)：函数只是为了实现某些功能，其他函数不会用到这个函数的处理结果
①函数只是用于执行某种操作，用不到它的返回值，此时就不需要显式的定义返回值了，直接返回None
5、所以我们在定义功能函数的时候一定要清楚该函数需不需要返回值
⑴需要返回值：需要什么就返回什么
⑵不需要返回值：可以不写return(默认返回None)，也可以写return None
1、python 函数使用 return 语句返回 "返回值"，可以将其赋给其它变量作其它的用处
2、所有函数都有返回值，如果没有 return 语句，会隐式地调用 return None 作为返回值；
3、一个函数可以存在多条 return 语句，但只有一条可以被执行，如果没有一条 reutrn 语句被执行，同样会隐式调用 return None 作为返回值；
4、如果有必要，可以显式调用 return None 明确返回一个None(空值对象)作为返回值，可以简写为 return，不过 python 中懒惰即美德，所以一般能不写就不写；
5、如果函数执行了 return 语句，函数会立刻返回，结束调用，return 之后的其它语句都不会被执行了(可用于结束代码块)
⑴所以在for循环或while循环中要注意下return的使用位置：如果用在了循环中，那么程序只会循环一次
例11：
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
"""
例12：
def showplus(x):
print(x + 2)
return x + 1
num = showplus(6) #将返回值赋值给一个变量
print(num)
#上面函数的输出结果为：8、7
例13：
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封装成了一个元祖返回
例14：
def showlist():
return [1,3,5] #多元素，返回的是什么类型
print(type(showlist()))
print(showlist())
"""
输出结果：
[1, 3, 5] #列表类型
"""
例15：
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)
"""
11 10 (11, 1)
"""
例16：
x = 1
y = 2
def add (x, y):
z = x + y
return z
print(add(x,y))
#上面代码的输出结果为：3
例17：
x = 1
y = 2
def add (x, y):
z = x + y
print(z)
print(add(x,y))
#上面代码的输出结果为：3、None
注：
1、在交互模式下，return的结果会自动打印出来，而作为脚本单独运行时则需要print函数才能显示
多个返回值1、前面说了return 只能返回单值，但值可以存在多个元素。其实也就是说return可以有多个返回值。只是说是以元组的形式返回的
例18：
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)
"""
2 3 4
(2, 3, 4)
"""
注：
1、函数有多个返回值时，只能使用相同数量的变量去承接函数的返回值(就是序列解包的规则：变量数量要与元素数量一致)
2、函数有多个返回值时：
⑴如果要使用序列解包去承接函数的返回值：只能使用相同数量的变量去承接函数的返回值(就是序列解包的规则：变量数量要与元素数量一致)
⑵不使用序列解包：那么就只能用一个变量去承接函数的返回值(得到一个元组)
⑶一句话：函数有多个返回值时，要么使用与返回值个数相同的变量去承接，要么使用一个变量去承接
3、需要注意的就是：函数有多个返回值，并使用序列解包将多个返回值分别赋值给多个变量时，对用于承接的变量的定义顺序是没啥要求的。只是跟return中返回值定义顺序有关
例19：
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。
例20：
def outer():
def inner(): #可以理解为内部函数
print("inner")
print("outer")
outer()
#输出结果：outer
注：
此时如果调用 outer()，只会执行 print("outer")，因为 inner 虽然在 outer 函数内，但它也是一个函数，函数如果要调用，就必须用 '函数名( )' 方式。
例21：
def outer():
def inner():
print("inner")
print("outer")
inner()
outer()
#输出结果：outer、inner
调用函数时，必须加括号；如果是return funY,则返回的是这个函数所在的位置；如果后面跟的是函数名，加括号的，则表示调用这个函数。如果没有找到相应的函数，则报错。如果找到了对应的函数，并且对应参数一样，则会调用那个函数。
例22：
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'
"""
例23：
def funx(x):
def funy(y):
return x*y
return funy
print(funx(5)(8))
#上面代码的输出结果为：40
例24：
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 函数进行求和，
"""
上面代码的输出结果：
45
"""
注：
1、闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。即包在里面的函数（本例为sum（）），不要引用外部函数(本例为lazy_sum()的任何循环变量
2、如果一定要引入循环变量，方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变
拓展 返回值补充例25：
def func():
for n in range(5):
pass
return n
print(func())
#0
注：
上面例子中return语句在for循环内，当第一次遍历后就会执行return语句，因此就不会在执行后面的代码(不会执行下一次循环，return语句表示一个函数的结束，与break语句差不多)
例26：
def func():
for n in range(5):
pass
return n #这种写法在编辑器里面会有警告的提示(不会报错)
print(func())
#4
注：
上面例子中：return语句在for循环外(与for语句处于同一缩进)，表示for全部完成后，执行return语句，最后一次遍历出来的元素为4，因此最终结果是4(结果为最后遍历的数)
例27：
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语句差不多)，因此最终只有第一次遍历的结果
例28：
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
例29：
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
例30：
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了)
例31：
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'}
"""
例32：
"""
需求：
遍历传入的列表(嵌套了字典的列表)
⑴如果列表中的某些字典的"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了
例33：
"""
需求：
遍历传入的列表(嵌套了字典的列表)
⑴如果列表中的某个字典的"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'}]
"""
例34；
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的使用位置啊！！！
