第11天 高阶函数和装饰器

一、实参高阶函数

1.什么是实参高阶函数

参数是函数的函数就是实参高阶函数

def func4(f):
    # f=func1
    print(f(10, 20) * 2)   # print(func1(10, 20)*2)


def func1(*nums):
    return [1, 2]


func4(func1)

2.系统实参高阶函数的应用

max/min, sorted, map, reduce

1)max、min

a.普通用法：max(序列) - 求序列中元素的最大值(序列中元素的类型必须一致，而且元素本身必须支持比较运算)
b.实参高阶函数：
max(序列,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)

# 求各位数之和最大的元素
# 12， 15， 13， 5
nums = [930, 456, 67, 122]


# 方法一：
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([x for x in students if x['sex'] == '女'], key=lambda item: item['age'])
print('女生年龄最大的：', result)
# 4）求男生中年龄最小的学生信息


nums = [10, 23, 30, 40, 51]

推导式使用情况一：对原序列中的所有元素或者部分元素进行变换

1）所有元素乘以2

nums2 = [2*x for x in nums]
print(nums2)   # [20, 46, 60, 80, 102]

2）所有偶数乘以2

nums3 = [x if x & 1 else x*2 for x in nums]
print(nums3)   # [20, 23, 60, 80, 51]

推导式使用情况2：提取(删除)部分元素

3）获取奇数元素

nums4 = [x for x in nums if x & 1]
print(nums4)   # [23, 51]

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]

b.按照序列元素的个位数的大小排序

result = sorted(nums, key=lambda item: item % 10)
print(result)

3) map

用法一:
map(函数, 序列) - 通过原序列中元素进行指定的变换后产生一个新的序列(返回的是map对象，本质是序列)
a. 函数 - 有且只有一个参数(指向/代表后面的序列中的元素)；有一个返回值(新序列中的元素)

用法二
map(函数, 序列1, 序列2) - 产生一个新的序列，序列中的元素是序列1和序列2中元素通过指定的变换产生的
a.函数 - 有且只有两个参数(这个两个参数分别指向序列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]

练习：将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('方法二：', result)

# "{'name': 'stu7', 'age': 16, 'score': 100, 'sex': '女', "

补充：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'>

4）reduce

使用之前需要从functools模块导入
用法一(了解)：
reduce(函数, 序列) - 将序列中的元素通过指定的规则合并成一个数据
a. 函数 - 有且只有两个参数, 第一个参数第一次调用的时候指向序列中的第一个元素，从第二次开始都是指向上一次运算的结果; 第二个参数指向除了第一个元素以外的所有元素;
返回值是每一次合并的结果（用来定制合并规则的）

用法二(掌握)：
reduce(函数, 序列, 初始值)
a. 函数：
第一个参数：第一次指向初始值; 从第二次开始参数指向上次合并的结果
第二个参数：指向序列中所有的元素
返回值：每一次合并的结果（用来定制合并规则的）

# 计算[29, 38, 90, 34, 67]元素个位数的和
nums = [29, 38, 90, 34, 67]
# 错误方法：
# result = reduce(lambda x, y: x % 10 + y % 10, nums)
# print(result)

# 拼接nums中所有数字的个位数："98047"
# reduce(lambda x, y: str(x % 10)+str(y % 10), nums)

=(掌握)===

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: x+str(y % 10), nums, '')
print(result)   # '98047'

练习：求students中所有学生的总分数

result = reduce(lambda x, y: x+y['score'], students, 0)
print(result)   # 514

二、装饰器

1.什么是装饰器

装饰器是一种专门用来给其他的函数添加功能的函数

2.给函数添加统计执行时间的功能

方式一：直接在需要添加功能的函数中添加新功能对应的代码（缺点：同样的功能的代码可能需要写多遍）

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)


func3()
# count_time(func3)

func4(10)
# count_time(func4, 5)

3.无参装饰器的写法

装饰器 = 实参高阶函数+返回值高阶函数+糖语法

套路：
def 函数名1(参数1):
def 函数名2(*args, **kwarg):
result = 参数1(*args, **kwarg)
实现添加功能的代码段
return result
return 函数名2

说明:
函数名1 - 装饰器的名字（按照当前装饰器添加的功能来命名）
参数1 - 这个参数是用来接收被添加功能的函数(指向原函数)， 一般直接命名成: func
函数名2 - 表示的是在原函数的基础上添加完功能的新函数， 一般直接命名成一个固定的名字：test、new_func

使用装饰器：在需要添加功能的函数的定义前加: @装饰器名

print(’==================================’)

示例1： 写一个装饰器，在原函数结束后打印 ‘函数结束=’

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)


@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, 30)
func6()
re = func7(5)
print('re:', 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(20, 30))   # 0b110010
print(func7(1.23, 2.34))   # 3.57
print(func7('abc', '123'))   # abc123