一. 实参高阶函数
1.什么是实参高阶函数
参数是函数的函数就是实参高阶函数
2.系统实参高阶函数的应用
max/min, sorted, map, reduce
1）max、min
"""
a.普通用法：max(序列) - 求序列中元素的最大值（序列中的元素的类型必须一致，而且元素本身必须支持比较运算）
b.实参高阶函数：
max(序列, key=函数) - 通过函数来定制求最大值的方式
序列 - 需要获取某种最大值对应的序列
函数 - 有且只有一个参数（指向/代表序列中每一个元素）；有且只有一个返回值（求最大值的时候的比较对象）
"""
nums = [23, 145, 59, 87]
# 求最大元素
print(max(nums)) # 87
# 求个位数最大的元素
result = max(nums, key=lambda item: item % 10)
print(result) # 59
# 求十位数最大的元素
result = max(nums, key=lambda item: item//10 % 10)
print(result)
# 求各位数之和最大的元素
# 方法一:
def sum1(item):
s = 0
for x in str(item):
s += int(x)
return s
result = max(nums, key=sum1)
print(result)
# 方法二：
result = max(nums, key=lambda item: sum([int(x) for x in str(item)]))
print(result)
# 练习：已知以下一个列表
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）求列表中年龄最大的学生信息
result = max(students, key=lambda item: item['age'])
print(result)
# 2）求列表中成绩最低的学生信息
result = min(students, key=lambda item: item['score'])
print(result)
# 3）求女生中年龄最大的学生
result = max([i for i in students if i['sex'] == '女'], key=lambda item: item['age'])
print(result)
# 4）求男生中年龄最小的学生信息
result = min([i for i in students if i['sex'] == '男'], key=lambda item: item['age'])
print(result)
# **********************************************
# 推导式使用情况一：对原序列中的所有元素或者部分元素进行变换
# 推导式使用情况二：提取（删除）部分元素
# **********************************************
2)sorted
"""
用法一：sorted(序列) - 将列表中的元素按照元素的大小从小到大排序
用法二：
sorted(序列, key=函数)
函数 - 有且只有一个参数(指向/代表序列中的每个元素)；有一个返回值(比较返回值的大小进行排序的；返回值就是排序标准)
"""
nums = [115, 34, 62, 89, 102]
# a.按序列元素大小排序
result = sorted(nums, key=lambda item: item)
print(result) # [34, 62, 89, 102, 115]
# b.按照序列元素的个位数的大小排序
result = sorted(nums, key=lambda item: item % 10)
print(result)
# 练习：
datas = [23, '78', 56, '34', '102', 79]
result = sorted(datas, key=lambda item: int(item))
print(result)
# 将学生列表按照学生的分数从大到小排序
result = sorted(students, key=lambda item: item['score'], reverse=True)
print(result)
# 将学生列表中学生的分数值从小到大排序
result = sorted([i['score'] for i in students], key=lambda item: item) # [54, 56, 67, 77, 78, 82, 100]
print(result)
3）map
"""
用法一：
map(函数, 序列) - 通过原序列中的元素进行指定的变换后产生一个新的序列(返回的是map对象，本质是序列)
a.函数 - 有且只有一个参数（指向/代表后面的序列中的元素）；有一个返回值（新序列中的元素）
用法二：
map(函数, 序列1, 序列2) - 产生一个新的序列，新序列中的元素是序列1和序列2中的元素通过指定的变换产生的
a.函数 - 有且只有两个参数（这两个参数分别指向序列1中的元素和序列2中的元素）；
有一个返回值（新序列中的元素）
"""
nums = [1, 2, 3, 4]
# 产生一个新列表，列表中是nums中元素的平方
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]
# 练习：将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
result = list(map(add_key, students, tels))
print(result)
# 方法二：强制用匿名函数
result = list(map(lambda x, y: eval(f'{str(x)[:-1]}, "tel":"{y}"}}'), students, tels))
print(f'方法二:{result}')
# 补充：eval函数的用法
# eval(序列字符串) - 将满足规范格式的序列的字符串转换成序列
list_str = "[1, 2, 3, 4]"
list1 = eval(list_str)
print(list1)
4）reduce
"""
使用之前需要从functools模块导入
用法一（了解）：
reduce(函数, 序列) - 将序列中的元素通过指定的规则合并成一个数据
a.函数 - 有且只有两个参数,第一个参数第一次调用的时候指向序列中的一个元素，从第二次开始都是指向
上一次运算的结果；第二个参数指向除了第一个元素以外的所有元素；
返回值：每一次合并的结果（用来定制合并规则的）
用法二（掌握）：
reduce(函数, 序列, 初始值)
a. 函数：
第一个参数：第一次指向初始值；从第二次开始参数指向上次合并的结果
第二个参数：指向序列中所有的元素
返回值：每一次合并的结果（用来定制合并规则的）
"""
# =================用法一（了解）=================
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，返回60
...
"""
result = reduce(func1, nums)
print(result)
# 计算[29， 38， 90， 34， 67]
# 利用reduce做不出来，第一个变量会拿值也会拿结果
# =================用法二（掌握）=================
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)
# 练习：计算[29， 38， 90， 34， 67]元素个位数的和
nums = [29, 38, 90, 34, 67]
result = reduce(lambda x, y: x + y % 10, nums, 0)
print(result)
# 练习：拼接nums中所有数字的个位数："98047"
result = reduce(lambda x, y: f'{x}{y%10}', nums, '')
print(result) # '98047'
# 练习：求students中所有学生的总分数
result = reduce(lambda x, y: x+y['score'], students, 0)
print(result) # 514
二. 装饰器
1.什么是装饰器
"""
装饰器是一种专门用来给其他的函数添加功能的函数
"""
2.给函数添加统计执行时间的功能
# 方式一：直接在需要添加功能的函数中添加新功能对应的代码（缺点：同样的功能的代码可能需要写多遍）
def func1():
strat = time.time()
print('hello world!')
end = time.time()
print(f'执行时间:', end-strat)
def func2(x, y):
strat = time.time()
z = x+y
print('和：', z)
end = time.time()
print(f'执行时间:', end-strat)
func1()
func2(10, 20)
# 方式二：
# 定义一个实参高阶函数来给指定函数添加功能（缺点：主次颠倒）
def count_time(func, *args, **kwargs):
strat = time.time()
# 执行原函数的功能
func(*args, **kwargs) # func()如果里面不写*和**只能调用没有参数的函数，如果有参数的话会报错
end = time.time()
print(f'执行时间:', end - strat)
def func3():
print('你好吗')
def func4(num):
print(num*2)
count_time(func4, 5)
方式三：装饰器
3.无参装饰器的写法
"""
装饰器 = 实参高阶函数+返回值高阶函数+糖语法
套路：
def 函数名1(参数1):
def 函数名2(*args, **kwargs):
result = 参数1(*args, **kwargs)
实现添加功能的代码段
return result
return 函数名2
说明：
函数名1 - 装饰器的名字（按照当前装饰器添加的功能来命名）
参数1 - 用来接受被添加功能的函数（指向原函数），一般直接命名为func
函数名2 - 表示的是原函数的基础上添加完功能的新函数，一般直接命名成一个固定的名字：test、new_func
使用装饰器：在需要添加功能的函数的定义前加：@装饰器名
"""
# 实例1：写一个装饰器，在原函数结束后打印'======函数结束======'
def end(func):
def test(*args, **kwargs):
result = func(*args, **kwargs)
print('======函数结束======')
return result
return test
@end
def func5(x, y):
print(x+y)
@end
def func6():
print('hello, 装饰器')
@end
def func7(num):
result = reduce(lambda x, y: x*y, range(1, num+1), 1)
return result
func5(10, 20)
func6()
re = func7(5)
print(re)
# 实例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 func7(x, y):
return x+y
print(func7(10, 40)) # 0b110010
print(func7(1.1, 1.2)) # 2.3
print(func7('abc', '123')) # abc123