一、高阶函数

定义：

将函数作为参数的函数，即是高阶函数

1.函数作为 变量

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

1.1声明函数就是声明变量，函数名就是变量名

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

1.2.1 一个变量可以给另外一个变量赋值

a = 100
b = a
print(b, b+10)


def func3():
    print('函数3')
    return 200


b2 = func3
print(type(b2), b2())

1.2.2 修改变量的值

a = 'abc'
print(a, a[1:])

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

1.2.3 变量作为序列元素

a = 10
list1 = [a, 100, 'abc']
print(list1)


def func4():
    print('函数4')
    return 400

list2 = [func4, func4(), 10]  # list2 = [func4的地址，400，10]
print(list2)
print(list2[0]())    # func4()

1.2.4 将函数作为函数的参数 - 实参高阶函数

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)

1.2.5 系统的实参高阶函数

列表.sort()、sorted()、max()、min()都是实参高阶函数, 因为这四个函数中都有一个参数key，要求是一个函数

1.2.5.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)

二、返回值高阶函数

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))

2.返回值高阶函数 --- 函数作为函数的返回值

• func1就是以一个返回值高阶函数

def func1():
    def func2():
        print('函数2')

    return func2

3.闭包

函数1中声明了一个函数2，并且在函数2中使用了函数1的数据，那么这个函数1就是一个闭包

3.1 闭包的特点

闭包函数中的数据不会因为函数调用结束而销毁

def func3():
    a = 10
    print(id(a))

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

    return func4


t = func3()
t()   # 10

4.经典面试题

# 面试题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))  #结果8，8，8


# 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())

三、装饰器

1.什么是装饰器

"""
装饰器本质是一个函数 = 返回值高阶函数+实参高阶函数+糖语法
装饰器是python的三大神器之一: 装饰器、迭代器、生成器
作用: 给已经写好的函数添加新的功能
"""
"""
无参装饰器的函数:
def 函数名1(参数1):
    def 函数名2(*args, **kwargs):
        result = 参数1(*args, **kwargs)
        新功能对应的代码段
        return result
    return 函数名2
    
说明: 
函数名1  -  装饰器的名字;一般根据需要添加的功能命名
参数1 - 需要添加功能的函数， 一般命名为fn
函数名2  -  随便命名, 可以用test
"""

2.例

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()

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))

四、迭代器

1.定义

"""
迭代器也是python提供的容器型数据类型

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

"""

2.将数据存入迭代器中

2.1 将别的序列转换成迭代器

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(迭代器)  -> 取出迭代器中最前面的元素
"""

遍历 - 一个一个的取所有的元素
for x in iter2:
    print('x:', x)

作业

#1.为函数写一个装饰器，在函数执行之后输出 after
def add_after(fn):
    def test(*args, **kwargs):
        fn(*args, **kwargs)
        print('after')

    return test

@add_after
def yh_test():
    print('我不需要after')

yh_test()

#2.为函数写一个装饰器，把函数的返回值 +100 然后再返回。

def add_num(fn):
    def test(*args,**kwargs):
        re = fn(*args, **kwargs)
        return re + 100
    return test

@add_num
def yh_sum(x, y):
    return x + y

print(yh_sum(100, 200))

#3.写一个装饰器@tag要求满足如下功能:

def tag(fn):
    def test(*args,**kwargs):
       re =  fn(*args, **kwargs)
       return '<p>' + re + '</p>'
    return test

@tag
def render(text):
    return text

@tag
def render2():
    return 'abc'

print(render('hello'))
print(render2())

# 4.写一个装饰器@tag要求满足如下功能(需要使用带参的装饰器，自己先自学正在一下):
def tag(string):
    def add_str(fn):
        def test(*args, **kwargs):
            re = fn(*args, **kwargs)
            return '<' + string + '>' + re + '</' + string + '>'
        return test
    return add_str

@tag(string = 'p')
def render3(text):
    return text

@tag('div')
def render4():
    return 'abc'

print('=========================')
print(render3('hello'))
print(render4())

# 5.为函数写一个装饰器，根据参数不同做不同操作

def flag(bool):
    def add_sum1(fn):
        def test(*args, **kwargs):
            re = fn(*args, **kwargs)
            if bool:
                return re + 100
            else:
                return re - 100
        return test
    return add_sum1

@flag(bool = False)
def sum2(x, y):
    return x + y

@flag(bool = True)
def sum3(x, y):
    return x + y

print('=========================')
print(sum2(100, 200))
print(sum3(100, 200))