day 11实参高阶函数

day 11实参高阶函数**

1.实参高阶函数

什么是实参高阶函数

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

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


def func1(x, y, z=10):  # (*num)
    return [1, 2]


func4(func1)

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

max/min, sorted, map, reduce

1)max、min

a.普通用法：max(序列) - 求序列中元素的最大值（序列中元素的类型必须一致，而且元素本身必须支持比较运算）

b.实参高阶函数：

max(序列, key = 函数) - 通过函数来定制求最大值的方式

序列 - 需要获取某种最大值对应的序列

函数 - 有且只有一个参数（指向/代表序列中每一个元素）；有一个返回值（求最大值的时候的比较对象)

nums = [23, 45, 67, 122]
# 求最大的元素
print(max(nums))

# 求个位数最大的元素
# def func2(x):
#     return x % 10
result = max(nums, key=lambda x: x % 10)
print(result)   # 67

# 求十位数最大的元素
result = max(nums, key=lambda x: x // 10 % 10)
print(result)   # 67

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


def sum1(x):
    s = 0
    for i in str(x):
        s += int(i)
    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 i: i['score'])
print(result)
# 2）求列表中成绩最低的学生信息
result = min(students, key=lambda i: i['score'])
print(result)
# 3）求男生中年龄最大的学生信息
result = max([x for x in students if x['sex'] == '男'], key=lambda item: item['age'])
print(result)
# 4）求女生中年龄最小的学生信息
result = min([x for x in students if x['sex'] == '女'], key=lambda i: i['age'])
print(result)

# 补充
# 推导式使用情况一：对原序列中的所有元素或者部分元素进行变换
# 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 = [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)

# 练习：将datas中的元素按照对应的数值大小排序
datas = [23, '78', 56, '34', '102', 79]

result = sorted([int(i) for i in datas])
print(result)  # [23, 34, 56, 78, 79, 102]

result = sorted(datas, key=lambda item: int(item))
print(result)  # [23, '34', 56, '78', 79, '102']

# 将学生列表按照学生的分数按从大到小排序
result = sorted(students, key=lambda item: item['score'], reverse=True)
print(result)

result = sorted([i['score'] for i in students], reverse=True)
print(result)

3）map

用法一：

map(函数，序列) - 通过原序列中的元素进行指定的变换后产生一个新的序列

a.函数 - 有且只有一个参数（指向/代表后面的序列中的元素）；有一个返回值（新序列中的元素）

用法二：

map(函数, 序列1, 序列2) - 产生一个新的序列新序列中的元素是序列1和序列2中的元素通过指定的变换产生的

a.函数 - 有且只有两个参数（这个两个参数分别指向序列1中的元素和序列2中的元素)

​ 有一个返回值（新序列中的元素）

# 产生一个新列表，列表中的元素是nums中元素的平方
result = list(map(lambda item: item ** 2, num))
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 append_tel(item1, item2):
    item1['tel'] = item2
    return item1


result = list(map(append_tel, students, tels))
print(result)


# 方法二：
result = list(map(lambda item1, item2: eval(f'{str(item1)[:-1]}, "tel":"{item2}"'+'}'), students, tels))
print(result)

print(list(map(lambda item1, item2: [item1.setdefault('tel', item2), item1][1], students, tels)))
# 补充：eval函数用法
# eval(序列字符串)   -   将满足规范格式的序列的字符串转换成序列
dict1 = {'name': 'stu1', 'age': 20, 'score': 67, 'sex': '男'}
dict1_str = str(dict1)
print(dict1_str, type(dict1_str))    # {'name': 'stu1', 'age': 20, 'score': 67, 'sex': '男'} <class 'str'>

4）reduce

使用之前需要从functools模块导入

用法一（了解）：

reduce(函数, 序列) - 将序列中的元素通过指定的规则合并成一个数据

a.函数 - 有且只有两个参数，第一个参数第一次调用的时候指向序列中的第一个元素，从第二次开始都是指向上一次运算的结果；第二个参数指向除了第一个元素以外的所有元素
返回值是每一次合并的结果（用来定制合并规则的）

用法二（掌握）：

reduce(函数, 序列, 初始值)

a.函数：

第一个参数：第一次指向初始值；从第二次开始参数指向上次合并的结果

第二个参数：指向序列中所有的元素

返回值：每一次合并的结果（用来定制合并规则的）

from functools import reduce

# ==============用法一（了解）====================
nums = [10, 11, 12, 13, 14]


def func1(x, y):
    print(f'x:{x}y:{y}')
    return x+y


"""
第一次：x:10y:11
第二次：x:21y:12
第三次：x:33y:13
第三次：x:46y:14
...
"""

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, 100)
print(result)
# 计算[29, 38, 90, 34, 67]元素个位的和
nums = [29, 38, 90, 34, 67]


def func3(x, y):
    return x+(y % 10)


result = reduce(func3, nums, 0)
print(result)


def func4(x, y):
    return x + f'{y % 10}'


result = reduce(func4, nums, '')
print(result)

result = reduce(lambda x, y: x+f'{y % 10}', nums, '')
print(result)

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


a = [print('======1'), 1, print('======2')][1]
print(a)                # ======1 ======2 1