目录
一、匿名函数与高阶函数
1.lambda表达式
lambda parameter_list: expression
注:此处的expression只能是简单的表达式,而不能实现像函数内部的代码块。
def aa(x,y):
return x+y
print(aa(1,2))
#匿名函数
f = lambda x,y: x+y
print(f(1,2))
'''
output:
3
3
'''
2.三元表达式
格式:条件为真时返回的结果 if 条件判断 else 条件为假时的返回结果
例:x if x > y else y三元表达式经常用于lambada表达式部分
例如:
res=lambda x,y:x if x>y else y
print(res(5,4))
3.map
- map #class map 是一个类
- 不推荐在业务代码中大量用闭包,如果是框架、包、类库可以尝试
- 用法:map(func,list) #第二个参数可以是list 或者其他集合类型
- 意思是 对list运行func函数 然后重新赋值给一个新list
- r = map(func,list) #r返回的是 object map这个对象
- 可以根据需要将r转换为需要的类型
- print(list(r))
list_x = [1,2,3,4,5,6,7,8,9]
def square(x):
return x * x
r = map(square, list_x)
print(r)
print(list(r))
'''
output:
<map object at 0x0046FD10>
[1, 4, 9, 16, 25, 36, 49, 64, 81]
'''
4.map与lambda
map可以结合lambda表达式一起使用
map里的列表的传入个数必须与lambda表达式的参数个数一致
使用map与lambda可以替代函数和for循环,代码看上去更简洁,不过并不会提高运行效率
list_x = [1,2,3,4,5]
list_y = [1,2,3,4,5]
r = map(lambda x, y: x*x + y, list_x, list_y)
#map类的第二个参数是可变参数,可以直接 加入多个列表
5.reduce
reduce用于连续计算,即reduce的第一个函数参数必须至少有两个参数。
- reduce函数是连续计算,当有几个参数,就会连续调用几个参数,然后把这几个参数的结果作为一个参数,在继续往下走;
- 与map函数不同,map函数有几个函数,就必须传入几个序列;
- reduce是一个高度抽象的函数;
- reduce主要用来解决连续计算的问题;
- reduce的最后一个参数,为初始值,这个初始值会在计算时就开始运算;
from functools import reduce
list_x = [1,2,3,4,5,6,7,8,9]
#计算1-9的和 (((((((((1+2)+3)+4)+5)+6)+7)+8)+9)
r = reduce(lambda x,y : x + y, list_x)
print(r)
'''
output:
45
'''
6.filter
过滤掉不符合我们定义规则的元素,可以理解为过滤掉布尔类型为False的元素
注意返回的是集合,不像reduce,是一个数值
此外,filter中的lambda表达式一定是要可以判断真假
list_x=[1,0,0,1,0]
r=filter(lambda x: True if x==1 else False, list_x)
#把数字看成布尔类型的话,用lambda x: x就可以实现相同的功能
print(list(r))
'''
output:
[1,1,1]
'''
二、装饰器
装饰器所要解决的问题:在不修改原始代码逻辑的情况下,增加函数的功能。
对修改是封闭的,对拓展是开放的。
代码一 把函数作为参数传到另一个函数里面
import time
def f1():
print('this is f1')
def f2():
print('this is f2')
def print_current(func):
print(time.time())
func()
print_current(f1)
print_current(f2)
'''
unix时间戳使用time模块下的time函数,可以获得一个时间
定义为从格林威治时间1970年1月1日0分0秒起至运行该time函数为止的总秒数在运行数据库时较常用
'''
'''
output:
1555830288.9995325
this is f1
1555830288.9995325
this is f2
'''
代码二 函数嵌套,要封装的功能在嵌套函数
#这样的写法它的内置性更高一些 真正的业务在wrapper里面
def decorator(func): #实现装饰器要用到嵌套函数
def wrapper():#封装 包装 要封装的功能放这里面
print(time.time())#通过wrapper 封装实现不改变原来的函数实现新的功能
func()#如何体现装饰器的功能这
return wrapper
def f1():
print('This is a function1')
f = decorator(f1) #这样f就是一个函数可以调用
f()#但是这样很不好用 反而写了嵌套函数比较麻烦
'''
output:
1555830723.6593938
This is a function1
'''
代码三 @语法糖
我们可以接受定义的复杂,但我绝不能接受调用时的复杂(可以去了解aop)
只有有了@语法糖才能体现装饰器的优势,使我们的调用方式不变,使我们代码不被破坏(意义所在)