day11-高阶函数和装饰器
实参高阶函数
参数是函数的函数就是实参高阶函数
def func4(f):
# f=func1
print(f(10, 20) * 2) # print(func1(10, 20)*2)
def func1(*nums):
return [1, 2]
func4(func1)
系统实参高阶函数的应用
max/min
普通用法:max/min(序列) - 求序列中元素的最大/小值(序列中元素的类型必须一致,而且元素必须支持比较运算)
实参高阶函数:
max/min(序列,key=函数) - 通过函数来定制求最大值的方式
序列 - 需要获取某种最大值/最小值对应的序列
函数 - 又且只有一个参数(指向/代表序列每一个元素);有一个返回值(求最大值的时候的比较对象)
nums = [93, 45, 67, 122]
# 求最大的元素
print(max(nums))
# 求个位数最大的元素
result = max(nums, key=lambda item: item % 10)
print(result) # 67
# 求十位数最大的元素
result = max(nums, key=lambda item: item // 10 % 10)
print(result)
sorted
用法一:sorted(序列) - 将序列中的元素按照元素的大小从小到大排序
用法二:
sorted(序列,key=函数)
函数 - 有且只有一个参数(指向/代表序列中的每个元素);有一个返回值(比较返回值的大小进行排序的;返回值就是排序标准)
nums = [115, 34, 62, 89, 102]
# a.按序列元素大小排序
result = sorted(nums, key=lambda item: item)
print(result) # [34, 62, 89, 102]
# b.按照序列元素的个位数的大小排序
result = sorted(nums, key=lambda item: item % 10)
print(result)
map
用法一:
map(函数,序列) - 通过原序列中元素进行指定的变换后产生一个新的序列(返回的是map对象,本质是序列)
函数 - 有且只有一个参数(指向/代表后面的序列中的元素);有一个返回值(新序列中的元素)
用法二:
map(函数,序列1,序列2) - 产生一个新的序列,序列中的元素是序列1和序列2中元素通过指定的变换产生的
函数 - 有且只有两个参数(这个两个参数分别指向序列1中的元素和序列2中的元素)
有一个返回值(新序列中的元素)
# 产生一个新的列表,列表中是nums中元素的平方
nums = [1, 2, 3, 4]
result = list(map(lambda item: item**2, nums))
print(result) # [1, 4, 9, 16]
# 产生一个新的列表,列表中的元素是seq1中加上seq2中的元素
seq1 = (1, 2, 3, 4)
seq2 = [5, 6, 7, 8]
result = list(map(lambda item1, item2: item1+item2, seq1, seq2))
print(result) # [6, 8, 10, 12]
补充:eval函数的用法
eval(序列字符串) - 将满足规范格式的序列的字符串转换成序列
dict1 = {'name': 'stu7', 'age': 16, 'score': 100, 'sex': '女'}
dict1_str = str(dict1) # "{'name': 'stu7', 'age': 16, 'score': 100, 'sex': '女'}"
dict2 = eval(dict1_str)
print(dict2, type(dict2)) # {'name': 'stu7', 'age': 16, 'score': 100, 'sex': '女'} <class 'dict'>
list_str = "[1, 2, 3, 4]"
list1 = eval(list_str)
print(list1, type(list1)) # [1, 2, 3, 4] <class 'list'>
reduce
使用之前需要从functools模块导入
用法一:
reduce(函数,序列) - 将序列中的元素通过指定的规则合并成一个数据
函数 - 有且只有两个参数, 第一个参数第一次调用的时候指向序列中的第一个元素,从第二次开始都是指向上一次运算的结果;
返回值是每一次合并的结果(用来定制合并规则的)
用法二:
reduce(函数,序列,初始值)
函数:
第一个参数:第一次指向初始值;从第二次开始参数指向上次合并的结果
第二个参数:指向序列中所有的元素
返回值:每一次合并的结果(用来定制合并规则的)
# ==============用法一(了解)=================
nums = [10, 11, 12, 13, 14]
def func1(x, y):
print(f'x:{x}, y:{y}')
return x+y
"""
第一次: x=10; y=11; x=x+y,
第二次: x=21; y=12; x=x+y
第三次: x=33; y=13; x=x+y
第四次: x=46; y=14; x=x+y
...
"""
result = reduce(func1, nums)
print(result)
# ==============用法二(掌握)=================
nums = [10, 11, 12, 13, 14]
def func2(x, y):
print(f'x:{x}, y:{y}')
return x+y
result = reduce(func2, nums, 0)
print(result)
装饰器
装饰器是一种专门用来给其他的函数添加功能的函数
给函数添加统计指向时间的功能
方式一:直接在需要添加功能的函数中添加新功能对应的代码(缺点:同样的功能的代码可能需要写多遍)
def func1():
start = time.time()
print('hello world!')
end = time.time()
print('执行时间:', end-start)
def func2(x, y):
start = time.time()
z = x+y
print('和:', z)
end = time.time()
print('执行时间:', end-start)
func1()
func2(10, 20)
方式二:定义一个实参高阶函数来给指定函数添加功能(缺点:主次颠倒)
def count_time(func, *args, **kwargs):
start = time.time()
# 执行原函数的功能
func(*args, **kwargs)
end = time.time()
print('执行时间:', end-start)
方式三:装饰器
def add_time(func):
def test(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print('action time:', end-start)
return result
return test
@add_time
def func3():
print('你好吗')
@add_time
def func4(num):
print(num*2)
无参装饰器的写法
装饰器 = 实参高阶函数+返回值高阶函数+糖语法
套路:
def 函数名1(参数1):
def 函数名2(*args, **kwarg):
result = 参数1(*args, **kwarg)
实现添加功能的代码段
return result
return 函数名2
说明:
函数名1 - 装饰器的名字(按照当前装饰器添加的功能来命名)
参数1 - 这个参数是用来接受被添加功能的函数(指向原函数),一般直接命名成: func
函数名2 - 表示的是在原函数的基础上添加完功能的新函数, 一般直接命名成一个固定的名字:test、new_func
使用装饰器:在需要添加功能的函数的定义前加:@装饰器名
def end(func):
def new_func(*args, **kwargs):
result = func(*args, **kwargs)
print('======函数结束=======')
return result
return new_func
@end
def func5(x, y):
print(x+y)