python-函数与Lambda表达式

1.函数传参

必选传参 func(param)、默认传参func(param=value)、可选传参func(*param)、关键字传参func(**param)
（1）必选参数
定义函数时的参数个数，顺序已定义好，在调用函数调时必须和之前一样

def func(param1,param2,param3):
    print(param1)
    print(param2)
    print(param3)
func('I','love','lsgo')
#
I
love
lsgo

（2）默认参数func(param=value）
如果必选参数和默认参数同时存在，则默认参数必须跟在必选参数后面

def func(param1=1,param2=2,param3=3):
    print(param1)
    print(param2)
    print(param3)
func(param2='love',param3='lsgo')
#
1
love
lsgo

*（3）可选传参func(param)
定义函数的时候，在参数前加了一个 * 号，函数可以接收零个或多个值作为参数。返回结果是一个元组。
传递零个参数时函数并不报错，而是返回一个空元组。但以上这种方法也有局限性，它不能收集关键字参数。

def func(*param1):
    print(param1)
func('I','love','lsgo')
func()
#
('I', 'love', 'lsgo')
()

（4）关键字传参func(**param)
使用两个星号 ( ** ) ，用法同上。最后返回一个以参数名为键、参数值为键值的字典。

def func(**param1):
    print(param1)
func(a='I',b='love',c='lsgo')
func()
#
{'a': 'I', 'b': 'love', 'c': 'lsgo'}
{}

2. 函数闭包

所谓的函数闭包本质是函数的嵌套和高阶函数。我们来看看要实现函数闭包要满足什么条件（缺一不可）：

1)必须嵌套函数
2)内嵌函数必须引用一个定义在闭合范围内(外部函数里)的变量——内部函数引用外部变量
3)外部函数必须返回内嵌函数——必须返回那个内部函数
闭包的作用：可以保持程序上一次运行后的状态然后继续执行。

def fun1(x):
    print("调用了fun1")
    def fun2():
        print("调用了fun2")
        nonlocal x
        x=x+2
        return "fun2的返回值"
    return fun2
f=fun1(5)
print(f)
print(f())
#
调用了fun1
<function fun1.<locals>.fun2 at 0x000001F798A633A8>
调用了fun2
fun2的返回值

·关键词nonlocal，：可以在函数内部修改外部变量
·关键词global，：想在函数内部对函数外的变量进行操作，就需要在函数内部声明其为global。

Lambda表达式

lambda匿名函数的格式：冒号前是参数，可以有多个，用逗号隔开，冒号右边的为表达式。其实lambda返回值是一个函数的地址，也就是函数对象。

temp=lambda x,y:x+y
print(temp)
print(temp(3,6))

#
<function <lambda> at 0x000001DFF7D98B88>
9

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

temp=list(filter(lambda x:x%2==1,range(10)))
print(list(range(10)))
print(temp)
#
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 5, 7, 9]

map（）函数用于进行映射

c=[1,2,3,4,5,6,7,8,9]
print (c)
print(map(lambda x:x*2,c))
print(list(map(lambda x:x*2,c)))
#
[1, 2, 3, 4, 5, 6, 7, 8, 9]
<map object at 0x000001C1208EFD48>
[2, 4, 6, 8, 10, 12, 14, 16, 18]