1.什么是实参高阶函数

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

def func4(f):print(f(10, 20) * 2)def func1(x, y):return 89# def func1(x, y, z=6):#     return 89# def funv1(*nums):#     return (1, 2)func4(func1)

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

max/min， sorted， map，reduce

1）max, min

max(序列, key=函数)
通过函数来定制求最大值的方式
序列 - 需要获取某种最大值对应的序列
函数 - 首先需要有一个参数(代表序列中每一个元素)，其次需要一个返回值(求最大值的时候的比较对象)

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

nums = [23, 45, 67, 122]
print(max(nums))

求个位数最大的元素

高阶用法

nums = [23, 45, 67, 93, 122]

def func2(x):

return x % 10

max(nums, key=func2)

result = max(nums, key=lambda item: item % 10)
print(result)result1 = max(nums, key=lambda x: x // 10 % 10)
print(result1)

求各位数之和最大的元素

nums = [930, 4599, 6779, 122]

result2 = max(nums, key=lambda x: x // 100 + x // 10 % 10 + x % 10)

print(result2)

def sum1(item):s = 0for x in str(item):s += int(x)return sresult3 = max(nums, key=sum1)
print(result3)

方法2

result4 = max(nums, key=lambda item: sum([int(x) for x in str(item)]))
print(result4)

练习：已知以下列表

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）求列表中年龄最大的学生信息

result5 = max(students, key=lambda item: item['age'])
print(result5)

2）求列表中成绩最低的学生信息

result6 = min(students, key=lambda item: item['score'])
print(result6)

3）求女生中年龄最大的学生信息

result7 = max((x for x in students if x['sex'] == '女'), key=lambda item: item['age'])print(result7)

4）求男生中年龄最大的学生信息

result8 = max((x for x in students if x['sex'] == '男'), key=lambda item: item['age'])
print(result8)

2)sorted

用法1： sorted(序列) - 将序列中元素按照从小到大排序

用法2： sorted(序列， key=函数)
函数 - 有且只有一个参数（指向/代表序列中的每个元素）；有一个返回值（比较返回值大小排序，返回值是排序标准）

按照序列元素大小

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

按照序列元素的个位数大小

result10 = sorted(nums, key=lambda item: item % 10)

练习

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

练习：分数从大到小排

sorted(students, key=lambda item: item[‘score’], reverse=True)

3）map

用法1.
map(函数，序列) - 通过原序列进过指定的变换后创建一个新的序列
函数 - 有且只有一个参数(指向/代表后面序列中的元素)，有且只有一个返回值
用法2：
map(函数，序列1，序列2) - 产生一个新的序列，序列中的元素是序列1和序列2中元素通过指定变换产生
函数 - 有且只有2个参数(这个两个参数分别指向序列1中的元素和序列2中的元素)

nums = [1, 2, 3, 4]result = list(map(lambda item: item ** 2, nums))
print(result)seq1 = (1, 2, 3, 4)
seq2 = [5, 6, 7, 8]
result = list(map(lambda item1, item2: item1 + item2, seq1, seq2))
print(result)

练习：将tels中所有的电话号码一次添加到students中的每个字典中, 产生一个新的列表

tels = ['110', '120', '114', '119', '12306', '10086', '10000']result = list(map(lambda items1, items2: items1.setdefault('tels', items2), students, tels))
print(result)def new_dict(item1, item2):item1['tels'] = item2return item1result = list(map(new_dict, students, tels))

print(new_dict(students, tels))

print(result)

eval函数 - 将满足规范格式的序列字符串转换成序列

eval(序列字符串)

dict1 = {'name': 'stu1', 'age': 20, 'score': 67, 'sex': '男'}
dict1_str = str(dict1)
dict2 = eval(dict1_str)
print(dict2, type(dict2))

4.reduce

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

主要：
reduce(函数，序列，初始值)
函数：
第一个参数：第一次指向初始值，第二次开始参数指向上次合并的结果
第二个参数：指向序列中所有元素
返回值：每一次合并的结果（用来定制合并规则的）

from functools import reducenums = [10, 11, 12, 13, 14]def func1(x, y):return x + yresult = reduce(func1, nums)
print(result)

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

nums = [29, 38, 90, 34, 67]def func3(x, y):return x + y % 10result = reduce(func3, nums, 0)
print(result)

练习：拼接nums中所有数字的个位数：“98047”

nums = [29, 38, 90, 34, 67]
result = reduce(lambda x, y: x + str(y & 10), nums, '')
print(result)

练习：求students学生总分

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

装饰器

是一种特殊的函数 - 用来给其他函数添加功能

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

直接在需要添加功能的函数中添加对应的代码，但是需要些很多遍

def func1():start = time.time()print('sss')end = time.time()print(end - start)def func2(x, y):z = x + yprint(z)

方式2

def count_time(func):start = time.time()func()end = time.time()print(end - start)def func3():print('sssss')

print(’===========================================’)

示例1：写一个装饰器，在原函数结束后打印 ‘函数结束=’

def end(func):def new_func(*args, **kwargs):result = func(*args, **kwargs)print('======函数结束=======')return resultreturn new_func@end
def func5(x, y):print(x+y)@end
def func6():print('hello, 装饰器')@end
def func7(num):result = reduce(lambda x, y: x*y, range(1, num+1), 1)return resultfunc5(10, 30)
func6()
re = func7(5)
print('re:', re)

示例2：写一个装饰器，如果原函数的返回值是整数，就返回这个数的二进制表达式方式

def binary(func):def new_func(*args, **kwargs):result = func(*args, **kwargs)if type(result) != int:return resultreturn bin(result)return new_func@binary
def func7(x, y):return x+yprint(func7(20, 30))   # 0b110010
print(func7(1.23, 2.34))   # 3.57
print(func7('abc', '123'))   # abc123

实参高阶函数和装饰器相关推荐

python中高阶函数和装饰器_三.Python高阶函数和装饰器
1高阶函数 1.1 数学概念回顾下数学知识: y=f(x) 这是最开始接触的普通函数 y=g(f(x)) 这个就是我们接触到的高阶函数在数学和计算机科学中,高阶函数至少应当是满足下面一个条件的函数: ...
python中高阶函数和装饰器_Python高阶函数与装饰器函数的深入讲解
本文主要介绍的是Python高阶函数与装饰器函数的相关内容,分享给大家,下面话不多说了,来一起看看详细的介绍吧高阶函数 1.可以使用函数对象作为参数的函数 2.或可以将函数作为返回值的函数 3.函数 ...
python高阶函数闭包装饰器_Python_基础_(装饰器，*args,**kwargs，高阶函数，函数闭包，函数嵌套)...
一,装饰器装饰器:本质就是函数,功能是为其它的函数动态添加附加的功能原则:对修改关闭对扩展开放 1.不修改被修饰函数的源代码 2.不修改被修改函数的调用方式装饰器实现的知识储备:高阶函数,函数嵌 ...
python开发基础04-函数、递归、匿名函数、高阶函数、装饰器
匿名函数 lamba lambda x,y,z=1:x+y+z 匿名就是没有名字 def func(x,y,z=1):return x+y+z匿名 lambda x,y,z=1:x+y+z #与函数有 ...
python高阶函数闭包装饰器_5.初识python装饰器高阶函数＋闭包＋函数嵌套＝装饰器...
一.什么是装饰器? 实际上装饰器就是个函数,这个函数可以为其他函数提供附加的功能. 装饰器在给其他函数添加功能时,不会修改原函数的源代码,不会修改原函数的调用方式. 高阶函数+函数嵌套+闭包＝装饰 ...
python高阶函数闭包装饰器_Python自学从入门到就业之高阶函数、嵌套函数、闭包、装饰器...
高阶函数在Python中,函数其实也是一种数据类型. def test(): return 'hello world' print(type(test)) # 函数对应的数据类型是 function ...
递归调用、高阶函数、装饰器
一．递归调用递归调用: 一个函数自己调用自己, 变成一个循环了,最多一个函数递归调用自己999,作用和运行循环是一样的,区别就是循环是没有次数限制的,递归调用最多999次,超过999次会报错: 递归 ...
Python高效技巧（三）---查缺补漏（时间处理、shutill模块、高阶函数、装饰器）
Python高效技巧前言: 函数 1.可接受任意数量参数的函数和关键词参数 2.匿名函数 lambda 二.其他 1.关于序列的各种方法 2.产生器表达式三. 查缺补漏 1.时间处理 1. cal ...
13.函数式编程:匿名函数、高阶函数、装饰器
# def add(x,y): # return x + y # print(add(1,2)) # 3# 匿名函数 # lambda表达式 # f = lambda x,y:x + y # prin ...

实参高阶函数和装饰器