一.lambda表达式
lambda的应用场景
如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化。
lambda语法
ambda参数列表：表达式 #参数列表类似于函数定义的形参
ambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用。
lambda表达式能接收任何数量的参数但只能返回一个表达式的值。
def x():
return 1
a = x()
print(a)
x = lambda :1 #用lambda简化只输入一个值的代码(上面的函数)
print(x()) #1
示例：计算a + b
def add(a,b)：
return a+b
x = add (1,2)
print(x) # 3
add = lambda a,b:a+b #用lambda简化上面的函数
print(add(1,2)) ##
lambda的参数形式
1.无参数
x = lambda :1 print(x()) # 1
2.一个参数
`x = lambda a : a #有一个形参 print(x(1)) #1，有一个形参就要有一个对应的值，不输入会报错
3.默认参数
X = lambda a,b,c = 1:a+b+c print(x(1,2,3)) # 6 改变会覆盖原来的值 print(x(1,2))# 4 没有输入第三个参数会默认输入c为1
4.可变参数
x = lambda *args : args print(x(1,2)) #（1,2） print(x(1,2,3)) # (1,2,3) #返回值是元祖
x = lambda **kwargs :kwargs
print(x(age = 10 , name = "nnn"))
# {age = 10 ，name = "nnn"}
5 lambda的应用
1.带判断的lambda
三目运算符，三元表达式有两个形参就要有两个数据ab比大小，谁大返回谁
x = lambda a,b: a if a>b else b print(x(1,2)) #2 #三目运算符a是if条件成立后的值，else后面是不成立时输出的值
2.列表数据按字典key的值排序
students=[{"name":"Alice","age":20}, {"name":"Bob","age":18},
{"name":"Charlie","age":22}]
#sort(key=lambda..,reverse=bool数据)
#1.namekey对应的值进行升序排序students.sort(key=lambdax:x['name'])
print(students)
{"name":"Alice","age":20},{"name":"Bob","age":18},{"name":"Charlie","age":22}
#@2.namekey对应的值进行降序排序
students.sort(key=lambdax :x['name'],reverse=True)
print(students)
{"name":"Charlie","age":22},{"name":"Bob","age":18},{"name":"Alice","age":20}
#age key对应的值进行升序排序
students.sort(key=lambda x:x['age'])
print(students)
# {"name":"Bob","age":18},{"name":"Alice","age":20}, {"name":"Charlie","age":22}
高阶函数
体验高阶函数
abs()函数可以完成对数字求绝对值计算。
print(abs(-1)) # 1
round()函数可以完成对数字的四舍五入计算。
print(round(1.2)) #1 print(ound(1.9)) #2
任意两个数字，先进行数字处理(绝对值或四舍五入)再求和计算
def add_num(a,b): #绝对值 return abs(a)+round(b) result = add_num(-1.1,1.9) print(result) #3.1
内置高阶函数-三个常用的
1 map()
map(func函数名, lst列表序列)，将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表(Python2)/迭代器(Python3)返回。
需求：计算list序列中各个数字的2次方。
list = [1,2,3,4]
def func1(x):
return x**2
a = map(func1,list)
print(a) # [1,3,9,16]
2 reduce()
reduce(func，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累积计算。
list1 = [1,2,3,4,5] #1.导入模块 import functools #导用模块才可以使用 #2.定义功能函数 def func(a,b): return a+b #3.调用reduce，作用：功能函数计算的结果和序列的下一个数据做累计计算 result = functools.reduce(func,list1) print(result) #reduce会将列表的每一个值与下一个值进行需要的计算(定义的函数) #输出的值是 1+2=3 3+3=6 ... 直到加完列表中的所有值
3 filter()
filter(func, lst)函数用于过滤序列,过滤掉不符合条件的元素,返回一个filter对象。如果要转换为列表,可以使用list()来转换。
#1.准备数据序列
list1 = [1,2,3,4,5,6,7,8,9,10]
#2.封装函数，过滤序列中的偶数
def func(x):
returnx%2==0 # 按照工作需求来写代码
# 3.调用filter 验证结果filter 函数过滤掉了不是偶数的数据
result = filter(func,list1)
print(result)
print(list(result))
#4.filter 作用是过滤序列中符合条件的数据对象，留下的是符合条件的，
不符合条件的，被过滤掉了。
# 用filter函数会过滤掉list1中符合func(自己定义函数)的值.
总结
-
lambda
ambda参数列表:表达式
lambda的参数形式
无参数
lambda:表达式
一个参数
lambda参数:表达式
默认参数
lambdakey=value:表达式
不定长位置参数
lambda*args:表达式
不定长关键字参数
lambda**kwargs:表达式
不定长关键字参数
作用：把函数作为参数传入，化简代码
内置高阶函数
map()
reduce()
filter()
闭包的介绍
闭包的介绍
在函数嵌套的前提下，内部函数使用了外部函数的变量，并且外部函数返回了内部函数，我们把这个使用外部函数变量的内部函数称为闭包。
闭包的构成条件
1.在函数嵌套(函数里面再定义函数)的前提下
2.内部函数使用了外部函数的变量(还包括外部函数的参数)
3.外部函数返回了内部函数
函数调用完，函数内定义的变量都销毁了，使用时候需要保存函数内的这个变量，每次在这个变量的基础上完成一些的操作 。
def func1(num1): #定义一个函数
def func2(num2): #在第一个函数内部定义下一个函数
a = num1 + num2 #两个函数值的参数和
print(a) #打印出a
return func2 #在func1被调用后会将func2放在其中储存
f = func1(2) #用f来接受return返回的值(func2),并且第一个函数已经调用了，那么f相当于func2(num2)，就是用f储存了func2
f(2) #f(2)就像func2(2)输入值的时候会调用func2，让num1和num2都存在，并且num1不会因为return使用而销毁，可以重复使用
f(2) #4
f(3) #5
闭包执行结果的说明:通过上面的输出结果可以看出闭包保存了外部函数内的变量num1，每次执行闭包都是在num1 = 1基础上进行计算。
闭包可以保存外部函数内的变量，不会随着外部函数调用完而销毁。
由于闭包引用了外部函数的变量，则外部函数的变量没有及时释放，消耗内存。
1.当返回的内部函数使用了外部函数的变量就形成了闭包
2.闭包可以对外部函数的变量进行保存
闭包的使用
需求:根据配置信息使用闭包实现不同人的对话信息，
例如:对话:张三:到北京了吗?
李四:已经到了，放心吧。
def a(name):
def b(word):
print(f"{name}:{word}")
return b
f = a("张三")
f("到北京了吗？")
t = a("李四")
t("已经到了，放心吧。")
#张三:到北京了吗？
李四:已经到了，放心吧。
修改闭包内使用的外部变量的错误示例:
def func_out(num1):
#定义一个内部函数
def func_inner(num2):
#这里本意想要修改外部num1的值，实际上是在内部函数定义了一个局部变量num1
num1 = 10 #内部函数使用了外部函数的变量(num1)，但并不能改变外部变量,这只是个局部变量，只会在inner内部使用不影响外部
result = num1 + num2
print("结果是:",result)
print(num1) #1
func_inner(1) #即使使用内函数也无法改变外部num1的值
print(num1) #1
外部函数返回了内部函数，这里返回的内部函数就是闭包
return func_inner
f = func_out(1)
正确方法
nonlocal + 要改变的变量值
def func_out(num1):
# 定义一个内部函数
def func_inner(num2):
#这里本意想要修改外部num1的值，实际上是在内部函数定义了一个局部变量num1
nonlocal num1 #告诉解释器，此处使用的是外部变量a
#修改外部变量num1
num1 = 10
#内部函数使用了外部函数的变量(num1)
result = num1 + num2
print("结果是:",result)
print(num1) #1 并没有用内函数改变num1的值
func_inner(1) #使用内函数改变num1的值
print(num1) #10 使用后改变了num1的值
#外部函数返回了内部函数，这里返回的内部函数就是闭包
return func_inne
f = func_out(1)
f(2) # 12 改变了num1的值不把他作为1
作业：
1.使用闭包计算两个数字的和
def func1(num1):
def func2(num2):
a = num1 + num2
print(a)
return func2
x = func1(1)
x(3) #输出的值是4
x(4) #输出的值是5
2.修改外部函数变量值
def x(num1):
def y(num2):
nonlocal num1
num1 = 10
a = num1 +num2
print(a)
return y
f = x(3)
f(2) #输出值为12而不是5，改变了num1的值
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
