python-函数进阶

 

1. 名称空间

　　 1. 存放变量名字的地方

　     2. 变量x=1是怎么存放的？

　　　　x放在名称空间里，数字 1放在内存。

2. 名称空间有三种

　　1. locals——局部命名空间，用于存放局部变量、形参

　　2. globals——全局命名空间，用于存放全局变量名称

　　3. bulitins——内置命名空间，存放如input，print,str，tuple等方法。

3. 不同变量作用域就是由变量所在名称空间决定

4. 作用域范围

　　1. 全局范围（globals）—— 全局存活，全局有效

　　2. 局部范围（locals）—— 临时存活，局部有效

5.变量加载和取值顺序

加载顺序：程序内置——》全局——》局部——》函数内置

取值顺序：局部调用：程序局部——》内置函数——》全局——》内置

变量引用：

          全局不能用局部的

　　  局部可以使用全局的

2. 闭包：

　　闭：内部函数 ；

       包：包含了外部函数作用域中变量的引用

def bibao():
    x = 20

    def inner():  # 闭包函数
        print(x)
    return inner()


bibao()

判断闭包的方法：__closure__

def bibao():
    x = 20

    def inner():  # 闭包函数
        print(x)
    print(inner.__closure__)  # 有cell返回是闭包函数；
    return inner()


bibao()

def func2():
    def inner():
        print(name)
    print(inner.__closure__)  #返回none  不是闭包
    return inner

func2()

1. 1、A函数定义在B函数内——嵌套函数

2. 2、B函数可以访问A函数的变量、参数——（作用域概念）

3. 3、A函数被调用时，就会形成闭包

　　4. 闭包有什么意义？

1. 闭包所返回函数对象，不仅仅仅是一个函数对象。

2. 而且还返回这个函数外的作用域

3. 使得这个函数无论在何处调用，都优先使用自己外层的作用域

3. 装饰器

1. 有什么用？

　　1. 在不修改原函数及其调用方式的情况下对原函数功能进行扩展

2. 本质

1. 就是一个闭包函数

3. 装饰器执行流程

4. 语法糖

1. 多个参数用法

# 1.被装饰函数时带多个参数的情况


def get_run_time(func):
    def inn(*args, **kwargs):  # 接收函数传进来的多个参数
        start = time.time()
        func(*args, **kwargs)  # 把多个参数传到需要装饰的函数中
        end = time.time()
        print(end - start)
    return inn


@get_run_time  # 这句相当于 ==> func3 = timer(func3)
def func3(*args, **kwargs):
    print('func3')
    print(args, kwargs)


@get_run_time  # 这句相当于 ==> func4 = timer(func4)
def func4(*args, **kwargs):
    print('func4')
    print(args, kwargs)


func3(1)   # 传1个参数
func4(1, str='啊哈')  # 传1个参数,1个字典

2. 返回值用法

# 2.调用被装饰函数时带回返回值的情况

def run_time_return(func):
    def inn(*args, **kwargs):  # 接收函数传进来的多个参数
        start = time.time()
        re = func(*args, **kwargs)  # 把多个参数传到需要装饰的函数中
        end = time.time()
        print(end - start)
        return re
    return inn


@run_time_return  # 这句相当于 ==> func3 = timer(func3)
def func5(*args, **kwargs):
    print(args, kwargs)
    return 'func5 over'     # 被装饰函数有返回值


@run_time_return  # 这句相当于 ==> func4 = timer(func4)
def func6(*args, **kwargs):
    print('func6')
    print(args, kwargs)     # 被装饰没返回值


print(func5(1))   # 传1个参数
func6(1, str='啊哈')  # 传1个参数,1个字典
print(func6(1))    # 返回None

3. 多个语法糖用法

# 3.多个装饰器装饰一个函数


def wine(func):   # 上酒
    def inn(*args, **kwargs):
        print('in wine:before')
        re = func(*args, **kwargs)
        print('in wine:after')
        return re
    return inn


def dishes(func):  # 上菜
    def inn(*args, **kwargs):
        print('in dishes:before')
        re = func(*args, **kwargs)
        print('in dishes:after')
        return re
    return inn


@wine
@dishes
def rice(*args, **kwargs):  # 上米饭
    print('%srice please' % (args))


rice('服务员')

4. 装饰器带参数

# 4.多个装饰器的情况

# 带参数的装饰器：（相当于开关）为了给装饰器传参
# F=True   #为True时就把装饰器给加上了
F = False  # 为False时就把装饰器给去掉了


def candy_flag(flag):    # 判断是否用装饰器
    def run_time_return(func):
        def inn(*args, **kwargs):
            if flag:
                print('flag = True')
                re = func(*args, **kwargs)
            else:
                print('flag = False')
                re = func(*args, **kwargs)
            return re
        return inn
    return run_time_return


@candy_flag(F)  # 这句相当于 ==> func3 = timer(func3)
def func7(*args, **kwargs):
    print(args, kwargs)
    return 'func7 over'     # 被装饰函数有返回值


@candy_flag(F)  # 这句相当于 ==> func4 = timer(func4)
def func8(*args, **kwargs):
    print('func8')
    print(args, kwargs)     # 被装饰没返回值


print(func8(1))   # 传1个参数
func7(1, str='啊哈')  # 传1个参数,1个字典
print(func8(1))    # 返回None

5.统计多少个函数被我装饰

#统计多少个函数被我装饰

ls = list()


def outter(func):
    ls.append(func)

    def inn(*args, **kwargs):
        print('before')
        func(*args, **kwargs)
        print('after')
    return inn


@outter
def f1():
    print('f1')


@outter
def f2():
    print('f2')


@outter
def f3():
    print('f3')


f1()
f2()
f3()

print(ls)