Python入门第十一天-高阶函数

最新推荐文章于 2025-04-15 21:20:27 发布
原创 最新推荐文章于 2025-04-15 21:20:27 发布 · 421 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #数据结构 #java #列表 #shell

这篇博客详细介绍了Python中的高阶函数，包括函数作为变量的概念，实参高阶函数如max、min、sorted、map和reduce的使用，以及无参装饰器的原理和五种实现方法。通过实例解析了如何利用这些高阶函数增强代码的功能。

day11-高阶函数

一、高阶函数

1、函数就是变量

  • 定义函数就是在定义变量，函数名就是变量名
  • python中定义函数就是定义类型是function的变量，函数名就是变量名
  • 变量能做的函数都能做
  • 函数加括号是在获取返回值，假如使用时没有加括号，就是获得一个函数
x = 100
def func1():
    print('我是一个函数')
  • 一个变量可以给另外一个变量赋值
y = x
print(y + 100)

z = func1
z()        # 我是一个函数,令z调用函数
  • 修改变量的值
x = 'abc'
print(x + '123')     # abc123

func1 = 100        # 由函数变成了数字
print(func1 + 200)   # 300
  • 变量作为序列的元素
x = 100
list1 = [x, 200]
print(list1)      # [100, 200]

list2 = [func1, 200]
list2[0]()      # 调用函数：我是一个函数

list3 = [func1, 200, func1()]
print(list3)          # [<function func1 at 0x000001EF4BEBA048>, 200, None]
  • 变量作为函数的参数
def func2(m):
    print(f'x:{m}')

a = 100
func2(a)      # x:100
func2(func1)   # x:<function func1 at 0x000001B04CC4A048>
  • 变量作为函数的返回值
def func3():
    def s():
        print('我是小函数')
    return s

func3()()   # 我是小函数；func3() ->在调用函数，即s;相当于func3()() -> s()
  • 面试题
# 面试题
list3 = []
for i in range(5):
    list3.append(lambda x: x*i)   # lambda是函数体，定义函数时不会执行函数体
'''
i = 0 : [lambda x :x*i]
i = 1 : [lambda x :x*i, lambda x :x*i]
i = 2 : [lambda x :x*i, lambda x :x*i, lambda x :x*i]
i = 3 : [lambda x :x*i, lambda x :x*i, lambda x :x*i, lambda x :x*i]
i = 4 : [lambda x :x*i, lambda x :x*i, lambda x :x*i, lambda x :x*i, lambda x :x*i]
list3 = [lambda x :x*i, lambda x :x*i, lambda x :x*i, lambda x :x*i, lambda x :x*i] 此处i = 4
'''

print(list3[1](2))   # 8
print(list3[2](2))   # 8

二、实参高阶函数

1、实参高阶函数

  • 参数是函数的函数就是实参高阶函数
# func1就是实参高阶函数
def func1(x):
    print(x())

def func2(m=10):
    print('您好！')

func1(func2)

2、系统常见的实参高阶函数的使用

  • max、min、sorted、map、reduce
（1）max 和 min
  • max（序列） - 比较序列中元素的大小来获取值最大的元素
  • max（序列，key = 函数）- 函数决定求最大值时的比较对象是什么
  • 参数key的要求：
  • a.必须是函数
  • b.这个函数有且只有一个参数（这个参数指向的就是序列中的元素）
  • c.函数要有一个返回值（比较对象）
  • d.key后面一般跟匿名函数，匿名函数后面是比较啥就取啥
nums = [23, 78, 90, 78, 233, 91]
print(max(nums))


# 求列表中个位数最大的元素
nums = [19, 78, 76, 55, 30, 12]
# def f1(item):
#     return item % 10
# result = max(nums, key=f1)
result = max(nums, key=lambda item: item % 10)
print(result)

students = [
    {'name': '小明', 'age': 23, 'score': 90},
    {'name': '张三', 'age': 30, 'score': 78},
    {'name': '小红', 'age': 18, 'score': 82},
    {'name': 'Tom', 'age': 26, 'score': 99}
]

# 求所有学生中成绩最高的学生
def f2(item):
    return item['score']
print(max(students, key= f2))
print(max(students, key=lambda item: item['score']))

def f3(item):
    return item['age']
print(min(students, key=lambda item:item['age']))

# 获取列表中数字的各位数的和最大的元素（取出列表单个元素中的每一个数字，即23 -> 2, 3）
nums = [23, 78, 90, 73, 233, 91]
print(max(nums, key=lambda item: (item % 10) + (item // 100) + (item // 10 % 10)))
# 用推导式将数字转换成字符串再一个一个的拿出来，再转换成整型再相加
print(max(nums, key=lambda item: sum(int(x) for x in str(item))))
（2）sorted
  • sorted（序列） - 比较序列中元素的大小，然后对序列中的元素从小到大的排序
  • sorted（序列， key = 函数） - 函数决定排序的时候比较大小的比较对象
  • 函数的要求：
  • a.是一个函数
  • b.需要一个参数(指向序列中的元素)
  • c.需要一个返回值（比较对象）
nums = [19, 23, 45, 67, 78]
result = sorted(nums)
print(result)

# 练习一：让列表中的元素按照个位数的大小从小到大排序
nums = [19, 23, 45, 67, 78]
print(sorted(nums, key=lambda item: item % 10))

# 练习2：将students按照学生的年龄从大到小排序
students = [
    {'name': '小明', 'age': 23, 'score': 90},
    {'name': '张三', 'age': 30, 'score': 78},
    {'name': '小红', 'age': 18, 'score': 82},
    {'name': 'Tom', 'age': 26, 'score': 99}
]

print(sorted(students, key=lambda item: item['age'], reverse=True))
（3）map
  • 用法一：原序列 -> 新序列
  • map(函数，序列) - 将序列按照指定的方式进行转换，返回值是一个map对象（map对象是序列）
  • 函数：a.有一个参数（这个参数指向原序列元素）；b.需要一个返回值（新序列中的元素）
  • 推导式能完成的功能map都能完成
  • map能完成的推导式不一定能完成
# 用法一：
nums = [19, 23, 45, 67, 78]
result = map(lambda item: item, nums)

result1 = map(lambda item: item % 10, nums)
print(list(result1))        # [9, 3, 5, 7, 8]
result2 = map(lambda item: item * 2, nums)
print(list(result2))        # [38, 46, 90, 134, 156]
  • 用法二：将多个序列按照指定的方式合并成一个新的序列
  • map（函数，序列1，序列2）- 让序列1和序列2根据函数的范式来合并创建一个新的序列，序列1和序列2的个数要对应
  • 函数：a.有两个参数，分别指向两个序列中的元素；b.需要一个返回值（新序列中的元素）
# 用法二
names = ['张三', '李四', '小明', '小花']
ages = [19, 29, 30, 17]
result3 = map(lambda item1, item2: {'name': item1, 'age': item2}, names, ages)
print(list(result3))
# [{'name': '张三', 'age': 19}, {'name': '李四', 'age': 29}, {'name': '小明', 'age': 30}, {'name': '小花', 'age': 17}]

# 练习：获取班级所有学生的总成绩
c = [90, 89, 88, 99, 27, 76, 56]
e = [98, 78, 66, 82, 90, 12, 78]
m = [23, 98, 100, 72, 69, 27, 96]
result4 = map(lambda item1, item2, item3: item1+item2+item3, c, e, m)
print(list(result4))     # [211, 265, 254, 253, 186, 115, 230]
（4）reduce - 产生一个新的结果
  • reduce是没法直接使用的，需要先导入
  • 导入reduce：from functools import reduce
  • 用法：
  • reduce（函数，序列，初始值）
  • 函数的要求：
  • a.需要两个参数:
  • 第一个参数 - 第一次指向初始值；从第二次开始会指向上一次的运算结果
  • 第二个参数 - 指向序列中的每一个元素
  • b. 需要一个返回值
# 累计求和
nums = [10, 89, 78, 20]
from functools import reduce
# result5 = reduce(lambda s, item: s + item, nums, 0)
def f1(s, item):
    print(f's:{s}, item:{item}')
    return s+item
result5 = reduce(f1, nums, 0)
print(result5)      # 197
# s:0, item:10
# s:10, item:89
# s:99, item:78
# s:177, item:20
# 197

# f1(0, 10) -> 10
# f1(10, 89) -> 10 + 89 -> 99
# f1(99, 78) -> 99 + 78 -> 177
# f1(177, 20) -> 177 + 20 -> 197

# 累计求乘积
nums = [8, 9, 5, 2]
result5 = reduce(lambda s, item: s*item, nums, 1)
print(result5)

# 将数字序列中的元素全部合并，即拼接在一起
# [10, 89, 78, 20] -> 10897820
nums = [10, 89, 78, 20]
result6 = reduce(lambda s, item: s + str(item), nums, '')
print(result6)    # 10897820
result7 = reduce(lambda s, item: str(item) + s, nums, '')
print(result7)     # 20788910

三、无参装饰器

1、什么是装饰器

  • 作用： 装饰器是用来给函数添加功能

  • 本质：就是一个函数（实参高阶函数+个返回值高阶函数+语法）

  • 用法（套路）：

  • def 函数名1（参数1）：

    ​ def 函数名2（）

    ​ 新增功能的代码

    ​ 调用原函数的代码 - 参数1（）

    ​ return 函数名2

  • 说明：

  • 函数名1 - 装饰器的名称，根据需要新增的功能来进行命名

  • 参数1 - 需要添加功能的函数（原函数），一般命名成f、fn(实参高阶函数)

  • 函数名2 - 添加完功能的新函数的函数名，new_f、new_fn

  • 新增功能的代码和调用原函数的代码顺序是不一定的，要看具体添加的功能

给函数添加统计函数执行时间的功能

（1）方法一：
  • 给需要添加功能的函数添加新增功能的代码
  • 存在的问题：如果给不同的函数添加相同的功能，需要添加多遍
def func1():
    start = time.time()
    print('函数1的功能')
    end = time.time()
    print(f'执行时间：{end-start}')
def func2(x, y):
    print(x + y)
func1()
（2）方法二
  • 将需要添加的功能封装到一个函数中
  • 存在的问题：原函数并没有新增功能
def func3():
    print('hello word')##
    
def count_time(f):
    # 获取开始时间
    start = time.time()
    # 调用原函数
    f()
    # 获取结束时间
    end = time.time()
    # 计算时间差
    print(f'执行时间：{end-start}')

count_time(func3)
（3）方法三

  • 利用装饰器

  • 存在的问题：当原函数需要赋值变量时就无法给她进行装饰

  • def 函数名1（参数1）：

    ​ def 函数名2（）

    ​ 新增功能的代码

    ​ 调用原函数的代码 - 参数1（）

    ​ return 函数名2

def count_time(f):
    def new_f():
        start = time.time()
        f()
        end = time.time()
        print(f'执行时间：{end - start}')
    return new_f
print('===============================')

def func5():
    print('hello python')

func5()    # hello python

print('=================================')
@count_time
def func5():
    print('hello python')

func5()    # hello python
           # 执行时间：0.0
（4）方法四

  • 可以给任何函数添加功能

  • 存在问题：如果添加的是一个有返回值的函数，最后返回值会全部变成None，无法做到原函数的返回值是多少，新函数的返回值就是多少

  • def 函数名1（参数1）：

    ​ def 函数名2（*args, **kwarg）

    ​ 新增功能的代码

    ​ 调用原函数的代码 - 参数1（*args, **kwarg）

    ​ return 函数名2

def count_time(f):
    def new_f(*args, **kwargs):
        start = time.time()
        f(*args, **kwargs)
        end = time.time()
        print(f'执行时间：{end - start}')
    return new_f
@count_time
def func7(num1, num2):
    print(num1 + num2)

func7(10, 20)
（5）方法五

  • def 函数名1（参数1）：

    ​ def 函数名2（*args, **kwarg）

    ​ 新增功能的代码

    ​ 原函数的返回值 = 调用原函数的代码 - 参数1（*args, **kwarg）

    ​ return 原函数的返回值

    ​ return 函数名2

def count_time(f):
    def new_f(*args, **kwargs):
        start = time.time()
        result = f(*args, **kwargs)
        end = time.time()
        print(f'执行时间：{end - start}')
        return result
    return new_f
def func8(x):
    return x**2
result = func8(9)
print(result)
'''
# 执行时间：0.0009984970092773438
# 81
'''

# 练习：写一个装饰器，在函数开始执行时打开‘start'
def print_start(f):
    def new_f(*args, **kwargs):
        print('start')
        result = f(*args, **kwargs)
        return result
    return new_f

@print_start
def func11(a, b):
    print(a + b)
func11(10, 20)

'''
start
30
'''
C++之类模板最简单的使用
码莎拉蒂
03-21 2806
1、说明类模板 1) 声明类模板时要增加一行 template template意思是“模板”，是声明类模板时必须写的关键字。在template后面的尖括号内的内容为模板的参数表列，关键字class表示其后面的是类型参数 2、写代码理解 3、运行结果 4、总结 上面列出的类模板中的部分成员函数是在类模板内定义，的有一个是在类模板外定义，不
30天Python入门（第十四天：深入了解Python中的高阶函数）)
Science prince的博客
08-07 586
30天带你入门Python，这是第十四天，您将深入了解Python中的高阶函数
python eval 转换k m到乘法计算
weixin_43852674的博客
09-28 829
原数据 lambda函数处理 我之前写了各种if substr函数，各种报错 正确到热泪盈眶的函数 data['Followers/Fans'] = data['Followers/Fans'].str.replace('k|K','*1000').str.replace('m|M','*1000000').fillna('0') data['Followers/Fans'] = data['Followers/Fans'].apply(eval) 报错函数 # def trans(x): #
c语言 方程改main的值_C语言探索之旅 | 第一部分第十一课：函数
weixin_39621774的博客
11-21 235
内容简介前言函数的创建和调用一些函数的实例总结第一部分练习题预告1. 前言上一课是 C语言探索之旅 | 第一部分第十课：第一个C语言小游戏 。这一课我们将会用函数这个重中之重来结束《C语言探索之旅》的第一部分(基础部分)，而第二部分将要迎接我们的就是 C语言的高级技术了。第二部分会比较难，不过不用担心，我们会循序渐进，一点点地学习。只要方向对，肯花时间，C语言一点也不可怕。这一课里我们也...
微信小程序：防止多次点击跳转（函数节流）
Dreawer微信小程序联盟
01-26 1万+
场景 在使用小程序的时候会出现这样一种情况：当网络条件差或卡顿的情况下，使用者会认为点击无效而进行多次点击，最后出现多次跳转页面的情况，就像下图（快速点击了两次）： 解决办法 然后从 轻松理解JS函数节流和函数防抖 中找到了解决办法，就是函数节流(throttle)：函数在一段时间内多次触发只会执行第一次，在这段时间结束前，不管触发多少次也不会执行函数。
Python Lambda - 奇客谷教程
05-26 512
Python 介绍 Python 开发环境搭建 Python 语法 Python 变量 Python 数值类型 Python 类型转换 Python 字符串(String) Python 运算符 Python 列表(list) Python 元组(Tuple) Python 集合(Set) Python 字典(Dictionary) Python If … Else Py...
Python 函数进阶-高阶函数
「 虚幻私塾」
04-25 222
🚀 优质资源分享 🚀 学习路线指引（点击解锁） 知识定位 人群定位 🧡 Python实战微信订餐小程序 🧡 进阶级 本课程是python flask+微信小程序的完美结合，从项目搭建到腾讯云部署上线，打造一个全栈订餐系统。 💛Python量化交易实战💛 入门级 手把手带你打造一个易扩展、更安全、效率更高的量化交易系统 高阶函数 什么是高阶函数 高阶函数就是能够把函数当成参数传递的函数就是高阶函数，换句话说如果一个函数的参数是函数，那么这个函数就是一个高阶函数。 高阶函数可以是你使用d
python入门第十四节--装饰器
m0_68472237的博客
08-18 2530
Python装饰器是一种用于修改函数或方法行为的高级特性。它们允许开发者在不改变函数内部代码的情况下，动态地添加或修改函数的功能。装饰器的本质是一种能够接收函数作为输入并返回一个新函数的高阶函数。装饰器的基本语法非常简单，它通过定义一个接收函数并返回新函数的高阶函数来实现。这个新函数通常在执行原函数前后添加一些额外的操作。func()在这个例子中，是一个装饰器函数，它接收一个函数func作为参数，并返回一个名为wrapper的新函数。在wrapper中，原函数func被调用前后，分别执行了一些额外的操作。
Python-100-Days-master.zip
03-17
6. **函数式编程**：Python也支持函数式编程风格，如高阶函数、闭包、装饰器和生成器，这些可以提升代码的简洁性和可维护性。 7. **异常处理**：通过学习try/except语句，学习者能学会如何优雅地处理程序运行时可能...
Python小白学习教程从入门到入坑------第十七课 内置函数&拆包（语法基础）
qq_64441210的博客
10-27 1566
Python小白学习教程从入门到入坑------第十七课 内置函数&拆包
微信小程序防止多次点击跳转（函数节流）
10-16
主要介绍了微信小程序防止多次点击跳转问题（函数节流）,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
python shuffle函数_python中shuffle()方法的功能详解
weixin_28693309的博客
03-01 1万+
python的概率分布中，洗牌算法是通过shuffle()方法实现的，shuffle()方法将列表的所有元素打乱，随机排列。Python既可以使用random.shuffle对列表进行洗牌，也可以使用random.shuffle随机播放字符串列表，本文向大家介绍python中shuffle()方法的功能详解。一、shuffle()方法是打乱序列里面的元素，并随机排列的。1、shuffle()方法使...
C++ 知识梳理——重載、覆蓋、隱藏
09-30 346
“overload”翻译过来就是：超载，过载，重载，超出标准负荷;“override”翻译过来是：重置，覆盖，使原来的失去效果。 先来说说重载(Overload)的含义，在日常生活中我们经常要清洗一些东西，比如洗车、洗衣服。尽管我们说话的时候并没有明确地说用洗车的方式来洗车，或者用洗衣服 的方式来洗一件衣服，但是谁也不会用洗衣服的方式来洗一辆车，否则等洗完时车早就散架了。我们并不要那么明确地指出来就心知肚明，这就有重载的意思了。在 同一可访问区内被声名的几个具有不同参数列的(参数的类型、个数、顺序不同)同
Python shuffle() 函数
Huiyu Blog
12-07 775
描述 shuffle() 方法将序列的所有元素随机排序。 语法 import random random.shuffle (lst ) 注意：需要导入 random 模块，然后通过 random 静态对象调用该方法。 shuffling 每次都能获得相同的结果 使用随机模块的random.seed（）方法，每次洗牌都可能产生相同的结果。 import random list = [1,2,3,4...
python中lambda的用法
热门推荐
qq_40089648的博客
04-04 10万+
1. lambada简单介绍 lambda 在Python编程中使用的频率非常高，我们通常提及的lambda表达式其实是python中的一类特殊的定义函数的形式，使用它可以定义一个匿名函数。即当你需要一个函数，但又不想费神去命名一个函数，这时候，就可以使用 lambda了。 看个例子： g = lambda x: x+1 # 求 x+1 的和 结果 >>> g(1) 2 &g...
Python中lambda用法
最新发布
riven78的博客
04-15 683
在 Python 中，lambda 是一种创建匿名函数的快捷方式，适合需要临时小函数但不想用 def 定义的场景。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值