函数进阶

　　一、匿名函数

def calc(x, y):
    return x+y

func = lambda x, y: x+y

print(calc(1, 2))
print(func(1, 2))

　　格式：lambda 变量: 逻辑/返回值

　　匿名函数最多支持三元运算，不能实现更复杂的逻辑

def calc(x, y):
    if x < y:
        return x+y
    else:
        return x - y


func = lambda x, y: x+y if x < y else x - y

print(calc(1, 2))
print(func(1, 2))

　　二、高阶函数：接受一个或多个函数作为参数或return返回另外一个函数

　　

　　三、递归

　　在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

　　

def dev(a):
    print(a)
    if a > 0:
        return dev(a // 2)

    return a


result = dev(10)
print(result)

 　　递归特性：

1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

　　四、装饰器

　　1、闭包：在一个函数(outer)内定义一个内部函数(inner)，inner函数可以调用outer函数的变量，而函数outer返回函数inner。

　　　　作用：无论在何处调用inner，都优先使用outer定义的变量。

def outer():
    name = 'eric'

    def inner():
        print("在inner里打印外层函数的变量：", name)

    return inner

f = outer()
f()

　　2、装饰器：装饰器的本质就是返回函数的函数

import time

def outer(func):
    def inner(*args, **kwargs):
        """添加装饰功能"""
        start = time.time()
        print('*****装饰器******')
        ret = func(*args, **kwargs)  # 获取被装饰函数的返回值
        time.sleep(1)
        over = time.time()
        spend = str(over-start)
        print('cost %s secend' % spend)
        return ret
    return inner

@outer   # 调用装饰器
def say(name, age):
    # 函数的参数理论上是无限制的，但实际上最多6个
    print('My name is %s,%d years old'%(name,age))
    return 'say的返回值'

say('alex', 80)

"""@outer 调用装饰器的原理"""
# say = outer(say)  
# say('alex', 20)  # 相当于执行inner('alex', 20)  inner内func == say

　

def sum_list(obj):
    s = []

    def sum_inner(obj1):
        for i in obj1:
            if isinstance(i, list):
                sum_inner(i)
            else:
                s.append(i)
        return sum(s)
    return sum_inner(obj)


lst = [1, 2, 3, [1, 2, [3]], 1, [1, [[1]], [1]]]
print(sum_list(lst))