Task05：函数与Lambda表达式
函数
介绍
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
定义
简单的规则：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
- 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，并且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
>>> def area(width, height):
return width * height
>>> area(3,4)
12
调用
定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。
def f1(a,b):
print(a*b)
f1(8,9)
f1([1,2,3],3)
# 72
# [1, 2, 3, 1, 2, 3, 1, 2, 3]
函数文档
>>> def f1(a,b):
"计算面积"
print(a*b)
>>> help(f1)
Help on function f1 in module __main__:
f1(a, b)
计算面积
>>>
函数传递
可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
- 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5
被丢弃，不是改变a的值，相当于新生成了a。 - 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la
的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
- 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在
fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。 - 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
==形参：==函数定影过程中的参数
==形参：==实际传递进来的参数
函数参数
Python 的函数具有非常灵活多样的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。从简到繁的参数形态如下：
- 位置参数 (positional argument)
- 默认参数 (default argument)
- 可变参数 (variable argument)
- 关键字参数 (keyword argument)
- 命名关键字参数 (name keyword argument)
- 参数组合
位置参数
位置参数 ，这些参数在调用函数 (call function) 时位置要固定。
默认参数
默认参数 = 默认值，调用函数时，默认参数的值如果没有传入，则被认为是默认值。
默认参数一定要放在位置参数 后面，不然程序会报错。
可变参数
可变参数就是传入的参数个数是可变的，可以是 0, 1, 2 到任意个，是不定长的参数。
def functionname(arg1, arg2=v, *args):
"函数_文档字符串"
function_suite
return [expression]
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vartuple)
# 调用printinfo 函数
printinfo( 70, 60, 50 )
#70
#(60, 50)
关键字参数
def functionname(arg1, arg2=v, *args, **kw):
"函数_文档字符串"
function_suite
return [expression]
**kw - 关键字参数，可以是从零个到任意个，自动组装成字典。
def printinfo( arg1, **vardict ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vardict)
# 调用printinfo 函数
printinfo(1, a=2,b=3)
#1
#{'a': 2, 'b': 3}
「可变参数」和「关键字参数」的同异总结如下：
可变参数允许传入零个到任意个参数，它们在函数调用时自动组装为一个元组 (tuple)。
关键字参数允许传入零个到任意个参数，它们在函数内部自动组装为一个字典 (dict)。
命名关键字参数
- *, nkw - 命名关键字参数，用户想要输入的关键字参数，定义方式是在nkw 前面加个分隔符 *。
- 如果要限制关键字参数的名字，就可以用「命名关键字参数」
- 使用命名关键字参数时，要特别注意不能缺少参数名。
def functionname(arg1, arg2=v, *args, *, nkw, **kw):
"函数_文档字符串"
function_suite
return [expression]
def printinfo(arg1, *, nkw, **kwargs):
print(arg1)
print(nkw)
print(kwargs)
printinfo(70, nkw=10, a=1, b=2)
# 70
# 10
# {'a': 1, 'b': 2}
printinfo(70, 10, a=1, b=2)
# TypeError: printinfo() takes 1 positional argument but 2 were given
注：没有写参数名nwk，因此 10 被当成「位置参数」，而原函数只有 1 个位置函数，现在调用了 2 个，因此程序会报错。
参数组合
在 Python 中定义函数，可以用位置参数、默认参数、可变参数、命名关键字参数和关键字参数，这 5 种参数中的 4 个都可以一起使用，但是注意，参数定义的顺序必须是：
-
位置参数、默认参数、可变参数和关键字参数。
-
位置参数、默认参数、命名关键字参数和关键字参数。
要注意定义可变参数和关键字参数的语法：
-
*args 是可变参数，args 接收的是一个 tuple
-
**kw 是关键字参数，kw 接收的是一个 dict
命名关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。
定义命名关键字参数不要忘了写分隔符 *，否则定义的是位置参数
警告：虽然可以组合多达 5 种参数，但不要同时使用太多的组合，否则函数很难懂。
函数返回
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
变量作用域
-
定义在函数内部的变量拥有局部作用域，该变量称为局部变量。
-
定义在函数外部的变量拥有全局作用域，该变量称为全局变量。
-
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。
-
当内部作用域想修改外部作用域的变量时，用到global
-
不到万不得已不要使用全局变量，简洁的概括为：
a) 代码可读性变差
b) 代码安全性降低
内嵌函数
在嵌套的函数中，如果希望在内部函数修改外部函数的局部变量，应该使用nonlocal 关键字
>>> def Fun1():
x = 5
def Fun2():
nonlocal x
x *= x
return x
return Fun2()
>>> Fun1()
25
闭包
- 是函数式编程的一个重要的语法结构，是一种特殊的内嵌函数。
- 如果在一个内部函数里对外层非全局作用域的变量进行引用，那么内部函数就被认为是闭包。
- 通过闭包可以访问外层非全局作用域的变量，这个作用域称为 闭包作用域。
def outer(): #------别人家
x = 10 #别人家里的东西
def inner(): #内部函数------别人家的小孩
print(x) #外部函数的一个变量
return inner #------返回小孩
f = outer() #到别人家 “套近乎”别人的小孩，套出（返回）小孩f
f() #f小孩执行
# 调用inner()函数的方法
1、法一
outer()()
2、法二
f = outer()
f()
def funX():
x = 5
def funY():
nonlocal x
x += 1
return x
return funY
a = funX()
print(a())
print(a())
print(a())
# 6
# 7
# 8
怎么跟全局变量一样了？局部变量 x 不是应该在每次调用的时候都重新初始化了吗？！
其实大家仔细看看就明白了，当 a = funX() 的时候，只要 a 变量没有被重新赋值，funX() 就没有被释放，也就是说局部变量 x 就没有被重新初始化。
所以当全局变量不适用的时候，可以考虑使用闭包更稳定和安全。
递归
如果一个函数在内部调用自身本身，这个函数就是递归函数。
例子：求n！
循环法：
n = 5
for k in range(1, 5):
n = n * k
print(n) # 120
递归法：
def factorial(n):
if n == 1:
return 1
return n * fact(n - 1)
print(factorial(5)) # 120
Lambda 表达式
介绍
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
lambda [arg1 [,arg2,.....argn]]:expression
实例
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
#相加后的值为 : 30
#相加后的值为 : 40
参考资料
- LSGOGroup 老马的程序人生
- FishC.com
- Runoob.com
- https://www.cnblogs.com/clairedandan/p/10976678.html