2019-08-05-高阶函数

高阶函数

review

1.匿名函数
函数名 = lambda 参数列表:返回值

def 函数名(参数列表):
return 返回值
​

2.递归函数
3.迭代器
4.生成器

def func1():
    print('======')
    yield 100


gen1 = func1()
print(next(gen1))
# print(next(gen1))
for x in gen1:
    print('x:', x)

1.生成式
生成式就是生成器的简写

1)语法一
生成器 = (表达式 for 变量 in 序列)

a.说明: 表达式 - 任何有结果的语句; 数据,赋值后的变量,非赋值的运算表达式等...
b.展开成生成器:
def 函数名():
for 变量 in 序列:
yield 表达式
生成器 = 函数名()

1.用生成式创建生成器
gen = (x*2 for x in 'hello')
print(type(gen)) #
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))

print(next(gen)) # StopIteration

2. 列表生成式
   list1 = list(x for x in range(5))
   print(list1)

list2 = [x for x in 'abc']
print(list2)

gen2 = (x*10 for x in range(5))
list2 = list(gen2)
print(list2)

print(next(gen2)) # StopIteration

def yt_list(seq):
temp = []
for item in seq:
temp.append(item)
return temp

3.字典生成式
dict1 = dict((x, x*2) for x in range(5))
print(dict1) # {0: 0, 1: 2, 2: 4, 3: 6, 4: 8}

2. 语法二:
   生成器 = (表达式 for 变量 in 序列 if 条件语句)

a.展开成函数
def 函数名():
for 变量 in 序列:
if 条件语句:
yield 表达式
生成器 = 函数名()

gen3 = (x for x in range(10) if x % 2)

def func():
for x in range(10):
if x % 2:
yield x
gen3 = func()
print(list(gen3))
生成式

补充: python中的三目运算符

C、java、js等中的三目运算符: 变量 = 条件语句?表达式1:表达式2
python中的三目运算符： 变量 = 表达式1 if 条件语句 else 表达式2

三目运算符的功能: 判断条件语句是否为True， 如果是结果是表达式，否则结果是表达式2
a = 19
num = None
if a & 1:
num = '奇数'
else:
num = '偶数'

num = '奇数' if a & 1 else '偶数'
print(num)

练习: 使用生成式写一个生产器，能够产生1~10中所有的数能否被3整除的结果
1 -> False 2 - > False 3 -> True 4 -> False, ...

gen4 = (True if num % 3 == 0 else False for num in range(1, 11))
print(list(gen4))  # [False, False, True, False, False, True, False, False, True, False]

函数作为变量

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

a = 10
print(a, type(a), id(a))


def func1():
    print('=====')

print(func1, type(func1), id(func1))

1. 用一个变量给另外一个变量赋值

b = a
print(b, b+20 * 2)

c = func1
c()

2)修改变量的值

a = 'abc'
print(a+'hello')

# func1 = 100
# func1()   # TypeError: 'int' object is not callable

3)变量作为序列的元素

list1 = [a, 10]
print(list1)
print(list1[0].rjust(7, '0'))

list2 = [func1, func1(), 10]
print(list2)
print('~~~~~~~~~~~~~~')
print(list2[0]())

4)变量作为函数的参数

def func2(x):
    print('函数里面:', x)


a = 10
func2(a)
func2(func1)

5)变量作为函数的返回值

def func3(x, y):
    num = x + y
    return num


print(func3(1, 2))


def func4():
    def func5():
        print('函数5')

    return func5


print(func4())
func4()()

高阶函数

装饰器 = 实参高阶函数 + 返回值高阶函数 + 糖语法
1.实参高阶函数
有一个参数是函数的函数就是实参高阶函数

python中内置的sorted、max、min等函数,以及列表的sort方法都是实参高阶函数
这些函数中都有一个参数key，要求传参的时候传一个函数。
这个函数需要一个参数和一个返回值，参数代表序列中的元素，返回值是比较对象

num = [1, 78, 90, 23, 74, 90]
num.sort()
print(num)

问题1： 按个位数的大小对num中的元素从小到大排序
[90, 90, 1, 23, 74, 78]

def func1(item):
    return item % 10


num = [1, 78, 90, 23, 74, 90]
num.sort(key=func1)
num.sort(key=lambda item: item % 10)
print(num)

问题2： 按各位数之和从大到小排序
1, 15, 9, 5, 11, 9 -> [78, 74, 90, 90, 23, 1]

num = [1, 78, 90, 23, 74, 90]
def func2(item):
   sum = 0
   for x in str(item):
       sum += int(x)
   return sum


num.sort(reverse=True, key=func2)
print(num)

问题3：按照字典中key为'score'的值从小到大排序

dicts = [
    {'name': '小明1', 'score': 98},
    {'name': '小明2', 'score': 40},
    {'name': '小明3', 'score': 67},
    {'name': '小明4', 'score': 89}
]
dicts.sort(key=lambda item: item['score'])
print(dicts)


num = [1, 78, 90, 23, 74, 90]
print(max(num, key=lambda item: item%10))

print(max(dicts, key=lambda item: item['score']))

print(max(90, 89))

max函数的内部实现

def yt_max(*args, key=None):
    if not key:
        # print(args)
        # 传的是一个序列,想要求序列中元素的最大值
        if len(args) <= 1:
            seq = list(args[0])
            max = seq[0]
            for x in seq[1:]:
                if x > max:
                    max = x
            return max

        # 传的是多个数据，求多个数据中的最大值
        else:
            max = args[0]
            for x in args[1:]:
                if x > max:
                    max = x
            return max
    else:
        if len(args) <= 1:
            seq = list(args[0])
            max = seq[0]
            for x in seq[1:]:
                if key(x) > key(max):
                    max = x
            return max

        # 传的是多个数据，求多个数据中的最大值
        else:
            max = args[0]
            for x in args[1:]:
                if key(x) > key(max):
                    max = x
            return max


print(yt_max(223, 89, 0))
print(yt_max(87, 89, 560, key=lambda x: x % 10))

返回值高阶函数

1.返回值高阶函数

函数的返回是一个函数,这样的函数就是返回值高阶函数
情况一: 真正的返回值高阶函数

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

情况二: 假的返回值高阶函数

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

def func4():
    return func3

练习: 声明一个函数operation，要求可以接收一个字符参数， 最后根据字符值的不同返回不同功能的函数

• -> 求多个数和功能的函数 - -> 求多个数的差的功能的功能, * -> 求多个数的乘积的功能
  operation('+')(1, 2, 4, 5) -> 12
  operation('-')(1, 2, 4, 5) -> -10
  operation('*')(1, 2, 4, 5) -> 40

def operation(char):
    # char = '+'
    if char == '+':
        def sum(*args):
            # args = (1, 2, 4, 5)
            temp = 0
            for x in args:
                temp += x
            return temp
        return sum

    elif char == '-':
        def diff(*args):
            temp = args[0]
            for x in args[1:]:
                temp -= x
            return temp
        return diff


print(operation('+')(1, 2, 4, 5))
"""
print(sum(1, 2, 4, 5))
print(12)
"""
print(operation('-')(1, 2, 4, 5))

闭包

1.什么是闭包

闭包就是一个函数，这个函数需要满足以下两个个条件:
1.函数的返回值是声明在这个函数中的函数(内函数)
2.这个内函数必须使用外函数中的临时变量(外函数中的局部变量)

闭包的作用: 保存临时变量的值(函数调用结束后，函数中的数据不销毁)

def func11(x):
    a = 10


func11(100)


def func1(x):
    a = 10

    def func2():
        print(a+x)
        print('内函数')
    return func2


func1(10)

装饰器

import time

装饰器是python的三大神器之一

1.什么是装饰器: 装饰器本质还是一个函数

装饰器的作用：在不修改函数本身的前提下给函数添加功能

方式一： 给函数添加功能需要修改原代码

def sum1(x, y):
    start = time.time()
    print('和:', x+y)
    end = time.time()
    print('总时间:', end-start)


sum1(100, 200)

方式二: 调用函数的基础上添加新的功能

def sum11(x, y):
    sum = 100 + 200
    print('x, y:', x, y)
    print('和:', sum)


def func1(x):
    print('+++++')
    print('-----')
    print(x)


def count_time(fn, *args, **kwargs):
    start = time.time()
    fn(*args, **kwargs)
    end = time.time()
    print('总时间:', end - start)


count_time(sum11, 111, 222)
count_time(func1, 'abc')


print('=============')
sum11(100, 200)

方法三：装饰器
语法:

def 函数名1(参数1):
     def 函数2(*args, **kwargs):
        体现为原函数添加功能的代码
        (保证出现: 参数1(*args, **kwargs))
    return 函数2
    
@函数名1
声明需要添加功能的函数

print('===================')


def count_time(fn):
    def test(*args, **kwargs):
        start = time.time()
        fn(*args, **kwargs)
        end = time.time()
        print('总时间:', end - start)
    return test


@count_time    # 糖语法
def func1():
    print('======')

func1()


@count_time
def func2(x, y):
    print(x+y)

func2(1, 2)
​````

 练习: 写一个装饰器，给函数添加权限, 密码是:'321'
​```python
def password(fn):
    def test(*args, **kwargs):
        ps = input('请输入密码:')
        if ps == '321':
            fn(*args, **kwargs)
    return test


@password
def func3():
    print('函数3')


func3()


@password
def func4(x, y):
    print('函数4:', x+y)


func4(10, 20)

回调函数

import itchat
import time

1.什么是回调函数: 函数的调用是在其他函数的内部满足条件的时候自动调用的函数

def func1():
    print('登录成功')


def func2():
    print('退出！')

# itchat.auto_login(loginCallback=func1, exitCallback=func2)
#
# itchat.run()


# 这儿的in_call_back和exit_call_back都是回调函数
def login(in_call_back, exit_call_back):
    in_call_back()
    time.sleep(3)
    exit_call_back()


login(func1, func2)