高阶函数

1.函数作为变量

释义：python中声明函数就是声明一个类型是function的变量，函数名就是变量名，普通变量能做的事情函数都可以做

1.声明函数就是声明变量，函数名就是变量名

def func1():
    print('函数1')
    return 100
print(type(func1))
a = 100
print(type(a))
func2 = lambda x: x*2
"""
def func2(x):
    return x*2
"""
print(type(func2))

2.普通变量能做的函数都可以做

1)一个变量可以给另外一个变量赋值

a = 100
b = a
print(b, b+10)
def func3():
    print('函数3')
    return 200
b2 = func3
print(type(b2), b2())

2)修改变量的值

a = 'abc'
print(a, a[1:])
func3 = [10, 20]
# func3()   # TypeError: 'list' object is not callable
func3.append(100)
print(func3)

3)变量作为序列元素

a = 10
list1 = [a, 100, 'abc']
print(list1)
def func4():
    print('函数4')
    return 400
list2 = [func4, func4(), 10]
print(list2)
print(list2[0]())    # func4()

4)变量作为函数的参数

def func5(x):
    print('函数5:', x)
a = 100
func5(a)
func5(func4)
print('===================实参高阶函数==================')
def func4():
    print('函数4')
    return 400

1.将函数作为函数的参数 - 实参高阶函数

def func6(x):
    # x = func4
    y = x()  # func4()
    # print('y:', y)
    return y

# func6(a)   # TypeError: 'int' object is not callable
re = func6(func4)
print(re)

2.系统的实参高阶函数

# 列表.sort()、sorted()、max()、min()都是实参高阶函数, 因为这四个函数中都有一个参数key，要求是一个函数
nums = [10, 89, 78, 7]
nums.sort(reverse=True)
print(nums)
# 1）排序方法: 参数key要求是一个函数，作用是用来定制排序的规则(默认按元素的大小从小到大或者从大到小排序)
"""
参数key的要求:
a.key是一个函数
b.函数中有且只有一个参数, 这个参数指向的是序列中的每个元素
c.函数需要一个返回值，这个返回值就是排序的时候比较大小的对象
"""
# 练习: 将nums中的元素按个位数从小到大排序
nums = [100, 39, 51, 62, 58]
# nums = [100, 51, 62, 58, 39]


# def func_key(item):
#     return item % 10
# func_key = lambda item: item % 10

nums.sort(key=lambda item: item % 10)
print(nums)


# 练习2：将学生按成绩从大到小排序
students = [
    {'name': '小明', 'age': 18, 'score': 90},
    {'name': '小花', 'age': 23, 'score': 78},
    {'name': '王五', 'age': 17, 'score': 65},
    {'name': '李四', 'age': 30, 'score': 89}
]
# def func1(item):
#     return item['score']
students.sort(reverse=True, key=lambda item: item['score'])
print(students)

# 练习3: 按学生年龄和分数的和从小到排序
students.sort(key=lambda item: item['age'] + item['score'])
print(students)

# 2) max、min默认是直接比较序列元素的大小求出最大值和最小值
nums = [17, 89, 100, 78, 23]
max1 = max(nums)
print(max1)
# 求nums中个位数最大的元素
max2 = max(nums, key=lambda item: item % 10)
print(max2)
students = [
    {'name': '小明', 'age': 18, 'score': 90},
    {'name': '小花', 'age': 23, 'score': 78},
    {'name': '王五', 'age': 17, 'score': 65},
    {'name': '李四', 'age': 30, 'score': 89}
]
print(max(students, key=lambda item: item['score']))
# 3)max函数的原理(了解)
def yt_max(seq, key=None):
    t_seq = list(seq)
    t_max = t_seq[0]

    if not key:
        for item in t_seq[1:]:
            if item > t_max:
                t_max = item
    else:
        for item in t_seq[1:]:
            if key(item) > key(t_max):
                t_max = item
    return t_max
# max1 = max(nums)
# print(max1)
# max([nums], key=)
max1 = max((10, 9, 8, 67), key=lambda item: item % 10)
print(max1)
max2 = yt_max((10, 12, 8, 67, 29), key=lambda item: item % 10)
print(max2)

2、返回值高阶函数

# 1.变量可以作为函数的返回值
def yt_sum(x, y):
    # x=10, y=20
    t = x+y   # t = 10+20 = 30
    return t  # return 30
print(yt_sum(10, 20))

# 函数作为函数的返回值  -  返回值高阶函数
# func1就是一个返回值高阶函数
def func1():
    def func2():
        print('函数2')

    return func2
print(func1())
func1()()   # func2()
print('=============')
print(func1()())    # func2()  -> None
# 2.闭包 - 函数1中声明了一个函数2，并且在函数2中使用了函数1的数据，那么这个函数1就是一个闭包
# 闭包的特点: 闭包函数中的数据不会因为函数调用结束而销毁
def func3():
    a = 10
    print(id(a))

    def func4():
        print(a)
        print(id(a))

    return func4


t = func3()
t()   # 10

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

# list1 = [lambda x: x*i, lambda x: x*i, lambda x: x*i, lambda x: x*i, lambda x: x*i]
# i = 4
print(list1[1](2), list1[2](2), list1[3](2))

# def func10():
#     print(yyy + 100)

# 面试题2: 函数参数默认值
def func2(seq=[]):
    # seq = []
    seq.append(10)   # [10]
    return seq
print(func2())  # [10]
print(func2())  # [10, 10]
# 练习: 写出打印结果
list3 = [1, 2]
def func3(seq=list3):
    # seq=seq
    seq.append(10)
    return seq
func3()
# list3 = [100, 200]
list3.append(100)
print(func3())

3、装饰器

mport time
# 1.什么是装饰器
"""
装饰器本质是一个函数 = 返回值高阶函数+实参高阶函数+糖语法
装饰器是python的三大神器之一: 装饰器、迭代器、生成器
作用: 给已经写好的函数添加新的功能
"""
# 给函数添加一个功能: 统计函数的执行时间

# ==========方法一: 在每个需要添加功能的函数中加入相应代码=========
def yt_sum(x, y):
    start = time.time()   # 获取当前时间
    sum1 = x + y
    print(sum1)
    end = time.time()
    print('函数执行时间: %fs' % (end - start))
yt_sum(100, 200)
def factorial(n):
    start = time.time()
    sum1 = 1
    for num in range(1, n+1):
        sum1 *= num
    print('%d的阶乘是:%d' % (n, sum1))

    end = time.time()
    print('函数执行时间: %fs' % (end - start))
factorial(5)
# ==============方法二:====================

# 注意: 这个add_time只能给没有参数的函数添加统计执行时间的功能
def add_time(fn):
    # fn=func1
    start = time.time()
    fn()  # func1()
    end = time.time()
    print('函数执行时间: %fs' % (end - start))
def add_time2(fn, *args, **kwargs):
    start = time.time()
    fn(*args, **kwargs)
    end = time.time()
    print('函数执行时间: %fs' % (end - start))
def func1():
    print('=======')
    print('+++++++')

def func2():
    print('你好世界!')
    print('你好python~')
def func3(x, y):
    print('%d+%d=%d' % (x, y, x+y))
add_time(func1)
add_time(func2)
add_time2(func1)
# func3(10, 20)
add_time2(func3, 10, 20)
# 2.装饰器
print('========================装饰器================')
"""
无参装饰器的函数:
def 函数名1(参数1):
    def 函数名2(*args, **kwargs):
        result = 参数1(*args, **kwargs)
        新功能对应的代码段
        return result
    return 函数名2
   
说明: 
函数名1  -  装饰器的名字;一般根据需要添加的功能命名
参数1 - 需要添加功能的函数， 一般命名为fn
函数名2  -  随便命名, 可以用test
"""
# 添加统计函数执行时间的装饰器对应的函数
def add_time3(fn):
    def test(*args, **kwargs):
        start = time.time()
        re = fn(*args, **kwargs)
        end = time.time()
        print('函数执行时间: %fs' % (end - start))
        return re
    return test
@add_time3
def func5():
    print('你好吗')
func5()
@add_time3
def sum3(x, y, z):
    print(x+y+z)
sum3(1, 2, 3)
# 练习: 给所有返回值是整数的函数添加功能: 返回值以16进制形式的数据返回
def add_hex(fn):
    def test(*args, **kwargs):
        re = fn(*args, **kwargs)
        # type(re) == int
        # 判断re是否是整型
        if isinstance(re, int):
            return hex(re)
        return re
    return test
@add_hex
def yt_sum(x, y):
    return x+y
print(yt_sum(10, 20))


@add_hex
def print_star():
    print('******')
print(print_star())

4、迭代器

迭代器也是python提供的容器型数据类型
迭代器存储数据的特点: 一个迭代器可以存储多个数据，如果要获取元素必须将元素从迭代器中取出，而且取一个就少一个；
取出来的数据不能再添加到迭代器中

"""
# 2.将数据存入迭代器中: 1)将别的序列转换成迭代器   2)创建生成器
list1 = [10, 20, 30, 40]
iter1 = iter(list1)
print(iter1)   # <list_iterator object at 0x110190400>
# print(len(iter1))   # TypeError: object of type 'list_iterator' has no len()

iter2 = iter('hello')
print(iter2)    # <str_iterator object at 0x109be0550>

# 3.获取迭代器中的元素
"""
迭代器中的元素不同通过什么方式取出来了，那么这个元素在迭代器中就不存在了

1)获取单个元素:
next(迭代器)  -> 取出迭代器中最前面的元素
"""
print(next(iter1))   # 10
print(next(iter1))   # 20
print(next(iter1))   # 30
print(next(iter1))   # 40
# print(next(iter1))   # StopIteration

# 2)遍历 - 一个一个的取所有的元素
for x in iter2:
    print('x:', x)
# print(next(iter2))    # StopIteration
print('=================')
iter3 = iter('python')
next(iter3)
next(iter3)
for y in iter3:
    print('y:', y)
iter4 = iter('python')
list2 = list(iter4)
print(list2)
print(next(iter4))    # StopIteration