高阶函数和装饰器
1.实参高阶函数
1.什么是实参高阶函数
参数是函数的函数就是实参高阶函数
def func1(f):
print(f(10, 20) * 2)
def func2(x, y):
return [x, y]
func1(func2) # [10, 20, 10, 20]
2.系统实参高阶函数的应用
max/min,sorted,map,reduce
1)max/min(只返回一个值)
a.普通用法max/min(序列) - 求序列中元素的最大/小值(序列中元素类型必须一致,而且元素本身必须支持比较运算)
b.实参高阶函数:
max/min(序列,key=函数) - 通过函数来定制求最大/小值的方式
序列 - 需要获取某种最大/小值对应的序列
函数 - 有且只有一个参数(指向/代表序列中的每一个元素);有一个返回值(求最大/小的时候的比较对象)
nums = [93, 23, 45, 67, 122]
# 求nums中最大的元素
print(max(nums))
# 求nums中个位数最大的元素
print(max(nums, key=lambda item: item % 10))
# 求nums中十位数最大的元素
print(max(nums, key=lambda item: item // 10 % 10))
# 求各位数值和最大的元素
nums = [930, 456, 67, 122]
# 方法一
def sum1(item):
sums = 0
for x in str(item):
sums += int(x)
return sums
print(max(nums, key=sum1))
# 方法二
print(max(nums, key=lambda item: sum([int(x) for x in str(item)])))
# 练习:已知以下列表:
students = [
{'name': 'stu1', 'age': 20, 'score': 67, 'sex': '男'},
{'name': 'stu2', 'age': 18, 'score': 82, 'sex': '女'},
{'name': 'stu3', 'age': 19, 'score': 54, 'sex': '女'},
{'name': 'stu4', 'age': 22, 'score': 77, 'sex': '男'},
{'name': 'stu5', 'age': 21, 'score': 56, 'sex': '男'},
{'name': 'stu6', 'age': 18, 'score': 78, 'sex': '男'},
{'name': 'stu7', 'age': 16, 'score': 100, 'sex': '女'}
]
# 1)求列表中年龄最大的学生信息
print('年龄最大的学生信息:', max(students, key=lambda item: item['age']))
# 2)求列表中成绩最低的学生信息
print('成绩最低的学生信息:', min(students, key=lambda item: item['score']))
# 3)求女生中年龄最大的学生信息
print('女生中年龄最大的学生信息:', max([x for x in students if x['sex'] == '女'], key=lambda item: item['age']))
# 4)求男生中年龄最小的学生信息
print('男生中年龄最小的学生信息:', min([x for x in students if x['sex'] == '男'], key=lambda item: item['age']))
2)sorted(只返回一个值)
a.普通用法sorted(序列) - 将序列中的元素按照元素从小到大进行排序
b.实参高阶函数:
sorted(序列, key=函数) - 通过函数来定制排序的方式
函数:有且只有一个参数,(指向或者代表序列中的每一个元素);
有一个返回值(比较返回值的大小进行排序的,返回值的大小就是排序标准)
# 练习:将data_s中的元素按照对应的数值大小排序
data_s = [23, '78', 56, '34', '102', 79]
print(sorted(data_s, key=lambda item: int(item))) # [23, '34', 56, '78', 79, '102']
print(sorted([int(x) for x in data_s])) # [23, 34, 56, 78, 79, 102]
# 将学生列表按照学生的分数从大到小排序
print(sorted(students, key=lambda item: item['score'], reverse=True))
# 将学生列表中学生的分数值从小到大排序 [54, 56, 67, 77, 78, 82, 100]
print(sorted([x['score'] for x in students])) # [54, 56, 67, 77, 78, 82, 100]
- map
用法一
map(函数, 序列) - 通过原序列中元素进行指定的变换后产生一个新的序列
函数 - 有且只有一个参数(指向/代表序列中的每一个元素);有一个返回值(新序列中的元素)
用法二
map(函数, 序列1, 序列2) - 产生一个新的序列,新序列中的元素是序列1和序列2中元素通过指定变换产生的
序列1和序列2中的元素个数一致(类型可以不同)
函数 - 有且只有两个参数(分别指向/代表序列中的元素)
有一个返回值(新序列中的元素)
# 产生一个新的列表,列表中是nums中元素的平方
nums = [1, 2, 3, 4]
print(list(map(lambda item: item ** 2, nums)))
# 将两个序列中的元素一一对应相加,产生一个新的列表
nums = [1, 2, 3, 4]
tuple1 = (5, 6, 7, 8)
print(list(map(lambda item1, item2: item1 + item2, nums, tuple1)))
# 练习:将tels中所有的电话号码一次添加到students中的每个字典中, 产生一个新的列表
students = [
{'name': 'stu1', 'age': 20, 'score': 67, 'sex': '男'},
{'name': 'stu2', 'age': 18, 'score': 82, 'sex': '女'},
{'name': 'stu3', 'age': 19, 'score': 54, 'sex': '女'},
{'name': 'stu4', 'age': 22, 'score': 77, 'sex': '男'},
{'name': 'stu5', 'age': 21, 'score': 56, 'sex': '男'},
{'name': 'stu6', 'age': 18, 'score': 78, 'sex': '男'},
{'name': 'stu7', 'age': 16, 'score': 100, 'sex': '女'}
]
tels = ['110', '120', '114', '119', '12306', '10086', '10000']
def add_key(item1, item2):
item1['tel'] = item2
return item1
print(list(map(add_key, students, tels)))
# 方法2
print(list(map(lambda x, y: eval(str(x)[:-1] + ', "tel":' + y + '}'), students, tels)))
# 补充:eval函数的用法
# eval(序列) - 将满足规范格式的序列的字符串转换成序列
dirt1 = {'name': 'stu1', 'age': 20, 'score': 67, 'sex': '男'}
str1 = str(dirt1)
dict2 = eval(str1)
str2 = '[1, 2, 3, 4]'
list1 = eval(str2)
print(list1, type(list1)) # [1, 2, 3, 4] <class 'list'>
- reduce
使用之前需要从functools模块导入
from functools import reduce
用法一(了解)
reduce(函数, 序列) - 将序列中的元素通过指定的规则合并成一个数据
a.函数 - 有且只有两个参数;
第一个参数第一次调用的时候指向序列中的第一个元素,从第二次开始都是指向上一次运算的结果;
第二个参数指向除了第一个元素以外的所有元素;
返回值:每一次合并的结果(用来定制合并规则的)
用法二(掌握)
reduce(函数, 序列, 初始值)
a.函数
第一次指向初始值,从第二次开始指向上次运算的结果
第二个参数指向序列中所有的元素
from functools import reduce
# 将序列中的元素相加
# ===========用法一(了解)=======================
nums = [10, 11, 12, 13, 14]
print(reduce(lambda x, y: x + y, nums)) # 60
# ===========用法二(掌握)=======================
nums = [29, 38, 90, 34, 67]
# 计算列表中元素个位数的和
print(reduce(lambda x, y: x + y % 10, nums, 0)) # 28
# 拼接列表中元素个位数
a = reduce(lambda x, y: x + str(y % 10), nums, '')
print(a, type(a)) # 98047 <class 'str'>
# 求students中所有学生的总分数
scores = reduce(lambda x, y: x + y['score'], students, 0)
print(f'scores:{scores}') # scores:514
2.装饰器
1.什么是装饰器
装饰器是一种专门用来给其他的函数添加功能的函数
1)无参装饰器的写法
装饰 = 实参高阶函数 + 返回值高阶函数 + 糖语法
套路:
def 函数名1(参数1):
def 函数名2(*args, **kwargs)
参数1(*args, **kwargs)
实现添加功能的代码段
return 函数名2
说明:
函数名1 - 装饰器的名字(按照当前装饰器添加的功能来命名)
参数1 - 用来接收被添加功能的函数(指向原函数),一般直接命名成func
函数名2 - 表示的是在原函数的基础上添加完功能的新函数,一般直接命名成一个固定的名字new_func
使用装饰器:在需要添加功能的函数的定义前添加:@装饰器名
# 示例1:写一个装饰器,在原函数结束后打印'======函数结束======'
def add_print(func):
def new_func(*args, **kwargs):
result = func(*args, **kwargs)
print('======函数结束======')
return result
return new_func
@add_print
def func5(num):
result = reduce(lambda x, y: x*y, range(1, num+1), 1)
return result
print(func5(5))
# 示例2: 写一个装饰器,如果原函数的返回值是整数,就返回这个数的二进制表达式方式
def binary(func):
def new_func(*args, **kwargs):
result = func(*args, **kwargs)
if type(result) != int:
return result
return bin(result)
return new_func
@binary
def func6(x, y):
return x+y
print(func6(3, 4)) # 0b111
print(func6(3.1, 4)) # 7.1