函数高阶

总结

匿名函数

没有函数名的函数

"""
函数名 = lambda 形参列表:返回值    (返回值就是函数体)

相当于
def 函数名(形参列表):
	return 返回值
	
注意:匿名函数的本质还是函数，之前函数中除了定义函数的语法以外的内容都适用于匿名
"""
# 求两个数的和的匿名函数
sum1 = lambda num1, num2: num1+num2

print(sum1(3, num2=4))

# 练习：写一个匿名函数判断指定年是否是闰年
year = lambda years: years % 4 == 0 and years % 100 != 0 or years % 400 == 0

result = year(1900)
print(result)

if result:
    print('闰年')
else:
    print('不是闰年')

函数就是变量

python中，定义函数就是定义类型是function的变量，函数名就是变量名

普通变量能做的事情，函数都可以做

# func3是一个实参高阶函数：如果一个函数的参数是函数，那么这个函数就是实参高阶函数
def func3(x, y, z, m):
    # x是长度 >= 2 的有序序列
    print(x[1])
    # y是任何类型的数据
    print(y)
    # z是字典
    print(z['a'])
    # m是一个函数
    m()
    
# func4是返回值高阶函数  -  如果一个函数的返回值是函数，那么这个函数就是返回值高阶函数
def func4():
    # name = '张三'
    # return name
    def t2():
        print('你好')
    return t2


result = func4()()  # t2() == None
print('===:', result)

# 练习:
list3 = []
for x in range(5):
    list3.append(lambda i: x*i)
print(list3)
print(list3[0](2))  # x*2 = 4*2 = 8
print(list3[1](2))  # x*2 = 4*2 = 8
print(list3[2](2))  # x*2 = 4*2 = 8
"""
x = 0:[lambda i: x*i]
x = 1:[lambda i: x*i, lambda i: x*i]
x = 2:[lambda i: x*i, lambda i: x*i, lambda i: x*i]
x = 3:[lambda i: x*i, lambda i: x*i, lambda i: x*i, lambda i: x*i]
x = 4:[lambda i: x*i, lambda i: x*i, lambda i: x*i, lambda i: x*i, lambda i: x*i]
"""

实参高阶函数

python中常用的实参高阶函数：max、min、sorted、map、reduce

• max 和 min

"""
max(序列, key=函数)  -  按照key对应的函数指定的规则来获取序列中元素的最大值
函数的要求：a.有且只有一个参数（这个参数指向的是序列中的元素）
	      b.有一个返回值（比较大小的对象）
"""
# 示例1：获取nums中个位数最大的元素
nums = [12, 34, 53, 54, 123, 66]
tel = ['3231231', '9873234', '7623192', '2312312']
# def temp(item):
#     return item % 10
# result = max(nums, key=temp)
result = max(nums, key=lambda item: item % 10)
print(result)

# 示例2：获取nums中最大的元素
result = max(nums, key=lambda item: item)
print(result)

# 示例3：获取tel中尾号最大的元素
result = max(tel, key=lambda x: x[-1])
print(result)

# max、min的原理
print('===================')
nums = [12, 43, 324, 22, 54]


def temp(item):
    print(f'item:{item}')
    return item % 10


# result = max(nums, key=temp)
def max_yt(seq: list, *, key=None):
    if not key:
        m = seq[0]
        for x in seq[1:]:
            if x > m:
                m = x
        return m

    # 有key的时候
    m = seq[0]
    for x in seq[1:]:
        if key(x) > key(m):
            m = x
    return m

• sorted

"""
sorted(序列, key=函数)
函数的要求：1）有且只有一个参数(这个参数指向的是序列中的元素)
          2） 有一个返回值（比较大小的对象）
"""
stu = [
    {'name': '小李', 'age': 18, 'score': 90},
    {'name': '张三', 'age': 24, 'score': 99},
    {'name': '李四', 'age': 11, 'score': 40},
    {'name': '王五', 'age': 20, 'score': 92},
]
# 练习，将stu按学生分数从大到小排序
result_stu = sorted(stu, key=lambda x: x['score'], reverse=True)
print(result_stu)
# 按年龄从小到大排序
stu.sort(key=lambda x: x['age'])
print(stu)

• map

"""
1) map(函数, 序列)  -  将序列中的元素，按照函数指定的规则转换成一个新的序列
函数的要求：a.有且只有一个参数（指向序列中的每个元素）
		  b.需要一个返回值（返回值就是新序列中的元素）
		  
2）map(函数, 序列1, 序列2,...)
函数的要求：a.有且只有两个参数，（分别指向后面的两个序列中的元素）
          b.需要一个返回值（返回值就是新序列中的元素）
"""

# 获取个位数
nums = [123, 898, 35, 412, 219]
new_nums = list(map(lambda x: x % 10, nums))

print(new_nums)  # [3, 8, 5, 2, 9]

# 练习：使用map，提取手机号码的后四位
tel = ['891283479', '76889279', '735423812', '923928321']
new_tel = list(map(lambda x: x[-4:], tel))
print(new_tel)  # ['3479', '9279', '3812', '8321']

names = ['小明', '小李', '小王', '小张']
scores = [90, 80, 70, 60]
"""
[{'name':小明, 'score': 90}]
"""
new_dict = list(map(lambda x, y: {'name': x, 'score': y}, names, scores))
print(new_dict)
# [{'name': '小明', 'score': 90}, {'name': '小李', 'score': 80}, {'name': '小王', 'score': 70}, {'name': '小张', 'score': 60}]

# 练习：
list1 = [10, 20, 30, 40, 50]
str1 = 'abcde'
list2 = [(10, 20), (3, 7), (9, 10), (103, 56), (1, 2)]  # 元组中的元素可以用下标获取到
# ['10a20', '20b7']
new_list = list(map(lambda x, y, z: str(x)+y+str(z[-1]), list1, str1, list2))
print(new_list)  # ['10a20', '20b7', '30c10', '40d56', '50e2']

# 字符串拼接可以用f-string
new_list = list(map(lambda x, y, z: f'{x}{y}{z[-1]}', list1, str1, list2))
print(new_list)  # ['10a20', '20b7', '30c10', '40d56', '50e2']

• reduce

"""
reduce(函数, 序列, 初始值)  -  将序列中的元素按照函数指定的规则合并成一个数据
函数的要求：1）有且只有两个参数：
			第一个参数：第一次指向初始值，从第二次开始指向上一次的计算结果
			第二个参数：指向序列中的每个元素
		 2）描述合并规则
"""

nums = [10, 20, 30, 40]
result = reduce(lambda x, y: x+y, nums, 0)
print(result)  #100
"""
第一次：x = 0，y = 10 -> x+y=10
第二次：x = 10, y = 20 -> x+y=30
第三次：x = 30，y = 30 -> x+y=60
第四次：x = 60,y = 40 -> x+y=100
"""

# 求元素个位数的和
nums = [10, 20, 909, 28, 102]
result = reduce(lambda x, y: x + y % 10, nums, 0)
print(result)

# 求购物车的商品总价
goods = [
    {'name': 'XXX泡面', 'price': 3, 'count': 5},
    {'name': 'XX口红', 'price': 312, 'count': 2},
    {'name': 'xx矿泉水', 'price': 1, 'count': 10}
]

result = reduce(lambda x, item: x + item['price'] * item['count'], goods, 0)
print(result)

# 练习1：求数字序列中所有元素的乘积
nums = [18, 90, 89, 78, 67]
result = reduce(lambda x, y: x * y, nums, 1)
print(result)  # 753484680

# 练习2：求数字序列中所有个位数的乘积
nums = [18, 90, 89, 78, 67]
result = reduce(lambda x, y: x * (y % 10), nums, 1)
print(result)  # 0

# 练习3：提取字符串列表中所有元素的最后一个字符
# ['abc', 'hello', '你好', '123'] -> 'co好3'
list1 = ['abc', 'hello', '你好', '123']
str1 = reduce(lambda x, y: f'{x}{y[-1]}', list1, '')
print(str1)  # co好3

# 练习4：计算列表中所有数字元素的和
# [18, 'abc', 10.3, True, '你好']  -> 28.3
# 一：
list1 = [18, 'abc', 10.3, True, '你好']
new_int = [y for y in list1 if type(y) in (int, float)]
sum1 = reduce(lambda x, y: x + y, new_int, 0)
print(sum1)  # 28.3
# 二：
list1 = [18, 'abc', 10.3, True, '你好']
sum2 = reduce(lambda x, y: x + (y if type(y) in (int, float) else 0), list1, 0)
print(sum2)  # 28.3

作业

# 1. 已经列表points中保存的是每个点的坐标(坐标是用元组表示的，第一个值是x坐标，第二个值是y坐标)
points = [(10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)]
# 以下问题使用实参高阶函数来解决
# 1）获取列表中y坐标最大的点
max_value = max(points, key=lambda x: x[-1])
print(max_value)  # (0, 100)
# 2）获取列表中x坐标最小的点
min_value = min(points, key=lambda x: x[0])
print(min_value)  # (-10, 20)
# 3）获取列表中距离原点最远的点
lang_value = max(points, key=lambda x: x[0]**2 + x[-1]**2)
print(lang_value)
# 4）将点按照点到x轴的距离大小从大到小排序
sorted_value = sorted(points, key=lambda x: x[-1])
print(sorted_value)
points.sort(key=lambda x: x[-1])
print(points)

# 2.求列表 nums 中绝对值最大的元素
nums = [-20, 100, -101, 200, -382]
max_nums = max(nums, key=lambda x: abs(x))
print(max_nums)

# 3.已知两个列表A和B，用map函数创建一个字典，A中的元素是key，B中的元素是value
# A = ['name', 'age', 'sex']
# B = ['张三', 18, '女']
# 新字典: {'name': '张三', 'age': 18, 'sex': '女'}
A = ['name', 'age', 'sex']
B = ['张三', 18, '女']
new_dict = dict(map(lambda x, y: (x, y), A, B))
print(new_dict)

# 4.已经三个列表分别表示5个学生的姓名、学科和班号，
# 使用map将这个三个列表拼成一个表示每个学生班级信息的的字典
names = ['小明', '小花', '小红', '老王']
nums = ['1906', '1807', '2001', '2004']
subjects = ['python', 'h5', 'java', 'python']
# 结果：{'小明': 'python1906', '小花': 'h51807', '小红': 'java2001', '老王': 'python2004'}
new_dict2 = dict(map(lambda x, y, z: (x, f'{y}{z}'), names, subjects, nums))
print(new_dict2)

# 5.已经一个列表message,
# 使用reduce计算列表中所有数字的和（用采用列表推导式和不采用列表推导式两种方法做）
# 结果 31.89
# 一：
message = ['你好', 20, '30', 5, 6.89, 'hello']
result = reduce(lambda x, y: x + (y if type(y) in (int, float) else 0), message, 0)
print(result)

# 二：
message = ['你好', 20, '30', 5, 6.89, 'hello']
new_int = [x for x in message if type(x) in (float, int)]
result = reduce(lambda x, y: x + y, new_int, 0)
print(result)

# 6.已知一个字典列表中保存的是每个学生各科的成绩，
studens = [
  {'name': 'stu1', 'math': 97, 'English': 67, 'Chinese': 80},
  {'name': 'stu2', 'math': 56, 'English': 84, 'Chinese': 74},
  {'name': 'stu3', 'math': 92, 'English': 83, 'Chinese': 78},
  {'name': 'stu4', 'math': 62, 'English': 90, 'Chinese': 88}
]

# 1)计算并添加每个学生的平均分
# result =


studens_s = [
  {'name': 'stu1', 'math': 97, 'English': 67, 'Chinese': 80, 'avg': 81},
  {'name': 'stu2', 'math': 56, 'English': 84, 'Chinese': 74, 'avg': 71},
  {'name': 'stu3', 'math': 92, 'English': 83, 'Chinese': 78, 'avg': 87},
  {'name': 'stu4', 'math': 62, 'English': 90, 'Chinese': 88, 'avg': 80}
]
# 按照平均分从高到低排序
result_s = sorted(studens_s, key=lambda x: x['avg'], reverse=True)
print(result_s)