11高阶函数

高阶函数

• 高阶函数

# 1.函数就是变量
# Python中定义函数就是定义类型中function的变量，函数名就是变量名
a = 10
b = lambda x:x*2
c = {'a':10,'b':100}
print(type(a),type(b),type(c))

x = 100
def func1():
    print('这是一个函数')

# 1)一个变量可以给另外一个变量赋值
y = x
print(y+100)
z = func1
z()

# 2)修改变量的值
# x = 'abc'
# print(x+'123')
#
# func1 = 100
# print(func1+200)

# 3)变量作为序列的元素
list1 = [x,200]
print(list1) # [100,200]
print(list1[0] - 100)

list2 = [func1, 200, func1()]
print(list2) # [<function func1 at 0x000002157382D048>, 200, None]
list2[0]()

# 4)变量作为函数的参数
def func2(m):
    print(f'x:{m}')

a = 100
func2(a)

func2(func1)

# 5)变量作为函数的返回值
def func3(m):
    # s = m*2
    def s():
        print('我是小函数')
    return s

# 面试题
list3 = []
for i in range(5):
    list3.append(lambda x:x*i)

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

• 实参高阶函数

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

def func2(m=10):
    print('hello')

func2(func2)

# 2.系统常见的实参高阶函数的使用
# max,min,sorted,map,reduce

# 1)max,min
"""
max(序列) - 比较序列中元素的大小来获取值最大的元素
max(序列,key=函数) - 函数决定求最大值的时候的比较对象
参数key的要求：a.是一个函数 b.这个函数有且只有一个参数（这个参数指向的就是序列中的元素）
             c.函数要有一个返回值（比较对象）
"""

nums = [23,78,90,78,233,91]
print(max(nums)) # 233

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

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=lambda item:item['score']))

# 求年龄最小的学生
print(min(students,key=lambda item:item['age']))


# 练习：获取列表中数字各位数的和最大的元素
# nums = [23, 78, 90, 73, 233, 91]
# 5， 15， 9， 10， 8， 10   -> 78
nums = [23, 78, 90, 73, 233, 91]
def f3(item):
    n = [int(x) for x in str(item)]
    return sum(n)
print(max(nums, key=f3))

# 2)sorted
"""
sorted(序列) - 比较序列中元素的大小对序列中的元素从小到大排序
sorted(序列, key=函数) - 函数决定排序的时候比较大小的比较对象
函数要求：a.是一个函数 b.需要一个参数(指向序列中的元素) c.需要一个返回值(比较对象)
"""

nums = [19,78,76,55,30,12]
result = sorted(nums)
print(result)

# 练习1：让列表中的元素按照个位数的大小从小到大排序
nums = [19,78,76,55,30,12]
def f4(item):
    n = item % 10
    return n
print(sorted(nums, key=f4))

# 练习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(函数,序列1,序列2) - 根据序列1和序列2创建一个新的序列
函数：a.有两个参数，分别指向两个序列中的元素
     b.需要一个返回值(新序列中的元素)
"""
# 用法一：
nums = [19,78,76,55,30,12]
result = map(lambda item:item % 10,nums)
print(list(result))

# 用法二：
names = ['张三', '李四', '小明', '小花']
ages = [19, 29, 30, 17]
result = map(lambda item1,item2:{'name':item1,'age':item2}, names, ages)
print(list(result))

# 练习：获取班级所有学生的总成绩
c = [90, 89, 88, 99, 27, 76, 56]
e = [98, 78, 66, 82, 90, 12, 78]
m = [23, 98, 100, 72, 69, 27, 96]
result = map(lambda item1,item2,item3:item1+item2+item3, c, e, m)
print(list(result))

# 4)reduce
from functools import reduce
"""
reduce(函数,序列,初始值)
函数的要求：a.需要两个参数：
           第一个参数 - 第一次指向初始值；从第二次开始指向上一次的运算结果
           第二个参数 - 指向序列中的每个元素
          b.需要一个返回值(决定运算规则)
           
"""
# 累计求乘积
nums = [8,9,5,2]
result = reduce(lambda s,item:s*item,nums,1)
print(result)

# 将数字序列中的元素全部拼接在一起
# [10,89,78,20]
nums = [10,89,78,20]
result = reduce(lambda s,item:s + str(item),nums,'')
print(result)

• 无参装饰器

# 1.什么是装饰器
"""
作用：装饰器是用来给函数添加功能
本质：就是一个函数(实参高阶函数+返回值高阶函数+糖语法)
用法：
def 函数名1(参数1):
    def 函数名2(*args, **kwarg):
        新增功能的代码
        原函数的返回值 = 调用原函数的代码:参数1(*args, **kwarg)
        return 原函数的返回值
    return 函数名2

说明：
1)函数名1 - 装饰器名称，根据新增的功能来命名
2)参数1 - 需要添加功能的函数(原函数)，一般命名成f,fn
3)函数名2 - 添加完功能的新函数名,new_f,new_fn
"""

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

@start
def func1():
    print('hello')

@start
def func2(a, b):
    return a*b

func1()
print(func2(10,20))