def fun1():
    x = 520
    def fun2():
        print(x)

x = 1200
fun1()
print(x)

# 内部函数包含对外部作用于而非全局作用域的引用

不改变函数体的代码，并且不改变函数的调用方式，为函数添加功能，他本质就是一个函数，附加被装饰器的函数里面。

def login():
    return True


def login_deco(func):
    def wrapper(*args,**kwargs):
        pre_login = login()
        if pre_login:
　　　　　　　# 调用shopping
            res = func(*args,**kwargs)
            return res
    return wrapper

@login_deco
def shopping():
    pass

def jackson(x,y):
    def login_deco(func):
        print(x,y)
        def wrapper(*args,**kwargs):
            pre_login = login()
            if pre_login:
                res = func(*args,**kwargs)
                return res
        return wrapper
    return login_deco

# shopping = login_deco(shopping)
@jackson(1,2)
def shopping():
    pass

自定义的迭代器、函数内部使用yield关键字、有yield关键字的函数只要调用、这个调用后的函数就是生成器。

yield：接收函数返回值，但是会继续执行函数体代码

return:接收函数返回值，但是会终止函数

def f1():
    # yield是接收函数返回值，但是会继续执行函数体代码
    yield 1
    yield 2
    yield 3

g = f1()
# g就是一个迭代器

for i in g:
    print(i)

递归本质上就是函数调用函数本身，必须有结束条件，并且在递归的过程中，问题的规模必须都不断缩小

#  斐波那契数列
# 从第三项开始，每一项都等于前两项之和。 前两项可以写成 n-1 n-2
# 0, 1, 1, 2, 3, 5, 8, 13

def f(n):
    if n <=1:
        return n
    else:
        return (f(n-1) + f(n-2))

for i in range(term):
　　print(f(n))

# 二分法
def find_num(num,lis):

    if len(lis) == 1 and lis[0] != num:
        print(‘没找到‘)
        return

    mid_ind = int(len(lis) / 2)  # 中间索引
    mid_num = lis[mid_ind]  # 中间值
　　# 左边
    if num < mid_num:
        lis = lis[:mid_ind]
        find_num(num,lis)
　　# 右边
    elif num > mid_num:
        lis = lis[mid_ind + 1:]
        find_num(num, lis)
    else:
        print(‘find‘)

lis = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
find_num(20,lis)

匿名函数使用一次就失效了，一般不单独使用，于内置的各种函数连用

lambda  参数 ： 逻辑代码

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

p = lambda x,y:x+y
print(p(4,6))

这里p就是一个函数，一个比较帅的函数，优雅的函数。

其实lambda返回值是一个函数的地址，也就是函数对象。