day11高阶函数和装饰器

高阶函数和装饰器

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]

3. 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'>

4. 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