day11 高阶函数

本文介绍了Python中的高阶函数,包括匿名函数、函数作为变量的概念,以及max、min、sorted、map、reduce等常见高阶函数的使用。通过实例解析了如何利用这些高阶函数解决实际问题,如查找列表中坐标点的最大值、最小值,以及如何进行列表排序、计算和转换等操作。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

day11 高阶函数

  1. 匿名函数

    1. 匿名函数 - 没有函数名的函数

      • 函数名 = lambda 形参列表: 返回值

      • 相当于:
        def(形参列表):
        return 返回值

      • 注意: 匿名的本质还是函数, 之前函数中除了定义函数的语法以外的内容都适用于匿名

        # 求两个数的和的匿名函数
        sum1 = lambda num1, num2:num1 + num2
        
        # def sum1(num1, num2):
        #     return num1 +num2
        
        print(sum1(10, 20))
        
        
        #  练习: 写一个匿名函数判断指定的年是否是闰年
        is_leap_year = lambda years : (years % 4 == 0 and years % 100 != 0) or years % 400 == 0
        print(is_leap_year(2020))
        if is_leap_year:
            print('是闰年')
        else:
            print('平年')
        
  2. 高阶函数

    1. 函数就是变量

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

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

        x = lambda num: num * 2
        print(type(x))  #<class 'function'>
        print(x(11))
        
        x = 10
        print(type(x))
        
        x = '1, 2, 3'
        print(type(x))
        x.replace()
        
        x = [1, 2, 3]
        print(type(x))
        x.append(100)
        
        x = {'a':'1', 'b':'2'}
        print(type(x))
        print(x[1])
        
        
        #  func3是一个实参高阶函数   -   如果一个函数的参数就是函数, 那么这个函数就是实参高阶函数
        def func3(x, y, z, m):
            # x是长度大于等于2的有序序列
            print(x[1])
        
            # y是任何类型数据
            print(y)
        
            # z是字典
            print(z['a'])
        
            # m是函数
            m()
        
        
        def t1():
            print('x')
        
        func3('abc', 1, {'a':100}, t1)
        func3('abc', 1, {'a':100}, lambda x=10: x*2)
        
        
        #  func4是返回值高阶函数    -   如果一个函数的返回值是函数, 那么这个函数就是返回值高阶函数
        def func4():
            # name = '张三'
            # return name
            def t2():
                print('你好!')
            return  t2
        
        result = func4()()
        print('===================', result)
        
        
        # 练习:
        list3 = []
        for x in range(5):
            list3.append(lambda i: x*i)
        print(list3[0][2])
        print(list3[1][2])
        print(list3[2][2])
        
    2. 实参高阶函数

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

        1. max和min

          • max(序列, key=函数) - 按照key对应的函数指定的规则来获取序列中元素的最大值
          • 函数的要求: 1) 有且只有一个参数 (这个参数指向的是序 列中的元素)
            2) 有一个返回值 (比较大小的对象)
        2. sorted

          • sorted(序列, key = 函数)

            students = [
                {'name': '小明', 'age': '18', 'score': '52'},
                {'name': '小红', 'age': '12', 'score': '98'},
                {'name': '小白', 'age': '16', 'score': '78'}
            ]
            
            nums = [29, 80, 7, 56, 23]
            
            # 示例1: 获取nums中个位数最大的元素
            # 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: 获取tels中尾号最大的元素
            tels = ['17289993', '2828902', '78289191', '1910290']
            result = max(tels, key=lambda item: item[-1])
            print('tels中尾号最大元素:',result)
            
            
            # max min 和sorted的原理
            print('=================================')
            nums = [29, 80, 7, 56, 23]
            
            def temp(item):
                print(f'item:{item}')
                return item % 10
            result = max(nums, key=temp)
            
            result = sorted(nums, key=lambda item: item % 10)
            print(result)
            
            # 练习: 将students按学生分数从大到小排序
            students = [
                {'name': '小明', 'age': 18, 'score': 92},
                {'name': '张三', 'age': 24, 'score': 99},
                {'name': '李四', 'age': 30, 'score': 87},
                {'name': '王五', 'age': 16, 'score': 62}
            ]
            
            result = sorted(students, reverse= True, key=lambda item:item['score'])
            print(result)
            
            # 按年龄从小到大排序
            students.sort(key=lambda item: item['age'])
            print(students)
            
        3. map

          • map(函数, 序列) - 将序列中的元素按照函数指定的规则转换成一个新的序列

            • 函数的要求: 1. 有且只有一个参数 (指向序列中的每个元素)
              2. 需要一个返回值 (返回值就是新序列中的元素)

            • map(函数, 序列1, 序列2)

              • 函数的要求: 1. 有且只有两个参数 (分别指向后面的两个序列中的元素)
                2. 需要一个返回值 (返回值就是新序列中的元素)
              nums = [18, 72, 90, 67, 16]
              new_nums = list(map(lambda item: item % 10, nums))
              print(new_nums)
              
              
              # 练习: 使用map提取所有手机号码的后四位
              tel = ['172829393', '1283929333', '167202928888', '17267382014']
              new_tel = list(map(lambda item: item[-4:], tel))
              print(new_tel)
              
              names = ['小明', '张三', '李四', '王五']
              scores = [90, 89, 67, 92]
              '''
              
              '''
              
              result = list(map(lambda item1, item2: {'name': item1, 'score': item2}, names, scores))
              print(result)
              
              # 练习:
              list1 = [10, 2, 78, 90, 16]
              str1 = 'abcde'
              list2 = [(10, 20), (3, 7), (9, 10), (103, 56), (1, 2)]
              
              result = list(map(lambda item1, item2,item3:f'{item1}{item2}{item3[-1]}',list1, str1, list2))
              print(result)
              
        4. reduce

          • reduce(函数, 序列, 初始值) - 将序列中的元素按照函数指定的规则合并成一个数据

          • 函数的要求: 1) 有且只有两个参数
            第一个参数: 第一次指向初始值, 从第二次开始指向上一次的计算结果
            第二个参数: 指向序列中的每个元素
            2) 描述合并规则

            # [18, 90, 89, 78, 67]
            # ['78', 90, '10', '37']
            '''
            [
                {'name': 'xxx泡面', 'price': 3, 'count': 5},
                {'name': 'xx口红', 'price': 312, 'count': 2},
                {'name': 'xx矿泉水', 'price': 1, 'count': 10}
            ]
            '''
            nums = [20, 30, 40, 67]
            result = reduce(lambda x, y: x+y, nums, 0)
            print(result)
            '''
            第一次: x = 0    y = 20 -> x+y = 20
            第二次: x = 20   y = 30 -> x+y = 50
            第三次: x = 50   y = 40 -> x+y = 90
            第四次: x = 90   y = 67 -> x+y = 157
            '''
            
            # [18, 90, 89, 78, 67], 求元素个位数的和
            nums = [18, 90, 89, 78, 67]
            result = reduce(lambda x, item: x + item % 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, item: x * item, nums, 1)
            print(result)
            
            # 练习2: 求数字序列中所有个位数的乘积
            nums = [18, 90, 89, 78, 67]
            result = reduce(lambda x, item: x * item % 10, nums, 1)
            print(result)
            
            # 练习3: 提取字符串列表中所有的元素的最后一个字符
            # ['abc', 'hello', '你好', '123']  -> 'co好3'
            list1 = ['abc', 'hello', '你好', '123']
            result = reduce(lambda x, item:f'{x}{item[-1]}', list1, '')
            print(result)
            
            # 练习4:计算列表中所有数字元素的和
            # [18, 'abc', 10.3, True, '你好']  -> 28.3
            list1 = [18, 'abc', 10.3, True, '你好']
            result = reduce(lambda x, item: x + item if type(item) in (int, float) else x, list1, 0)
            
            print(result)
            
  3. 作业

    1. 已经列表points中保存的是每个点的坐标(坐标是用元组表示的,第一个值是x坐标,第二个值是y坐标)

      points = [
        (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
      ]
      

      以下问题使用实参高阶函数来解决

      1)获取列表中y坐标最大的点

      max_y_val = max(points, key=lambda item: item[-1])
      print(max_y_val)
      

      2)获取列表中x坐标最小的点

      min_x = min(points, key=lambda item: item[0])
      print(min_x)
      

      3)获取列表中距离原点最远的点

      far_point = max(points, key=lambda item:item[0]**2 + item[-1]**2)
      print(far_point)
      

      4)将点按照点到x轴的距离大小从大到小排序

      distance_x =sorted(points, key=lambda item: abs(item[0]), reverse = True)
      print(distance_x)
      
    2. 求列表 nums 中绝对值最大的元素

      nums = [1, 2, 7, 9, -1, -8]
      max_val = max(nums, key=lambda item: abs(item))
      
    3. 已经两个列表A和B,用map函数创建一个字典,A中的元素是key,B中的元素是value

      A = ['name', 'age', 'sex']
      B = ['张三', 18, '女']
      新字典: {'name': '张三', 'age': 18, 'sex': '女'}
      
      new_dict = dict(map(lambda item1, item2:{item1 , item2}, A, B))
      print(new_dict)
      
    4. 已经三个列表分别表示5个学生的姓名、学科和班号,使用map将这个三个列表拼成一个表示每个学生班级信息的的字典

      names = ['小明', '小花', '小红', '老王']
      nums = ['1906', '1807', '2001', '2004']
      subjects = ['python', 'h5', 'java', 'python']
      结果:{'小明': 'python1906', '小花': 'h51807', '小红': 'java2001', '老王': 'python2004'}
      
      stu_info = dict(map(lambda x, y, z: (x,f'{z}{y}'), names, nums, subjects))
      print(stu_info)
      
    5. 已经一个列表message, 使用reduce计算列表中所有数字的和(用采用列表推导式和不采用列表推导式两种方法做)

      message = ['你好', 20, '30', 5, 6.89, 'hello']
      结果:31.89
      
      # 法一:列表推导式
      result = sum([x for x in message if type(x) in (int, float)])
      print(result)
      # 法二:三目表达式
      from functools import reduce
      result = reduce(lambda x,y: x + y if type(y) in (int, float) else x, message, 0)
      print(result)
      
    6. 已知一个字典列表中保存的是每个学生各科的成绩,

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

      from math import floor
      def avg(dict:dict):
          avg_score = floor((dict['math'] +dict['English'] +dict['Chinese']) / 3)
          dict.setdefault('avg', avg_score)
      
      # list(map(avg, students))
      # print(students)
      
      for x in students:
          avg_score = floor((x['math'] + x['English'] + x['Chinese']) / 3)
          x.setdefault('avg', avg_score)
      print(students)
      list(map(lambda x:x.setdefault('avg', floor((x['math'] + x['English'] + x['Chinese']) / 3)),students))
      print(students)
      
      

      2)按照平均分从高到低排序

      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}
      ]
      
      # 计算平均分
      studens = [
        {'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 = sorted(students, key=lambda x:x['avg'], reverse=True)
      print(result)
      

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值