day11-实参高阶函数

实参高阶函数

1.什么是实参高阶函数

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

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

max/min, sorted, map, reduce,

1) max、min

a.普通用法:max(序列)  -   求序列中元素的最大值(序列中元素的类型必须一致,而且元素本身必须支持比较运算)
b.实参高阶函数: 
max(序列, key=函数)   -   通过函数来定制求最大值的方式
序列  -   需要获取某种最大值对应的序列
函数  -   有且只有一个参数(指向/代表序列中每一个元素)；有一个返回值(求最大值的时候的比较对象)

# 求个位数最大的元素
nums = [23, 45, 67, 122]


def func2(x):
    return x % 10


print(max(nums, key=func2))
print(max(nums, key=lambda item: item))
print(max(nums, key=lambda item: item % 10))

# 求各位数之和最大的元素
nums = [930, 459, 99, 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['name'])
# 2) 求列表中成绩最低的学生
result = min(students, key=lambda item: item['score'])
print(result['name'])
# 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 item: item['age'])
print(result)

2) sorted

用法一：sorted(序列) - 将序列中的元素按照元素的大小从小到大排序
用法二：
sorted(序列,key=函数)
函数 - 有且只有一个参数(指向/代表序列中的每一个元素); 有一个返回值(比较返回值的大小进行排序;
返回值就是排序标准)
排序不会对原序列进行修改，只是比较返回值大小

nums = [34, 62, 89, 102]
result = sorted(nums, key=lambda item: item, reverse=True)
print(result)

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)  # [23, '34', 56, '78', 79, '102']

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

# 将学生列表按分数进行从大到小排序

result = sorted(students, key=lambda item: item['score'], reverse=True)
print(result)

# 将学生列表中学生的分数值进行从大到小排序
result = sorted([x['score'] for x in students], key=lambda item: item, reverse=True, )
print(result)  # [100, 82, 78, 77, 67, 56, 54]


def stu(num):
    num1 = num
    return num1

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 = [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 add1(item1, item2):
    item1['tel'] = item2
    return item1


result = list(map(add1, 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(序列字符串)   -   将满足规范格式的序列的字符串转换成序列

4) reduce

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

from functools import reduce
nums = [10, 11, 12, 13, 14]


def func1(x, y):
    return x + y


print(reduce(func1, nums))


# 练习：计算[29, 38, 90, 34, 67]元素个位数的和
nums = [29, 38, 90, 34, 67]

result = reduce(lambda item1, item2: item1 + item2 % 10, nums, 0)
print(result)

# 练习：拼接nums中所有数字的个位数："98047"

result = reduce(lambda item1,item2: str(item1) + str(item2 % 10), nums, '')
print(result)

# 练习: 球student中所有学生的总分数
result = reduce(lambda item1, item2: item1+item2['score'], students, 0)
print(result)