Python记录9：函数4：名称空间作用域+闭包函数+装饰器

'''
一: 名称空间namespaces
    名称空间就是存放名字与值绑定关系的内存空间

二: 名称空间分为三种
    内置名称空间:
        1. 特点: 存放是python解释器自带的名字,len,print
        2. 生命周期: 解释器启动则产生,解释器关闭则销毁
    全局名称空间
        1. 特点: 存放是全局的名字(没有任何缩进\顶头定义的名字)
        x=10
        y=20
        def func():
            pass
        print(x)

        if True:
            x=1111
        2. 生命周期: python文件执行时则创建,文件执行完毕则销毁
    局部名称空间:
        1. 特点: 在函数内定义的名字
        2. 生命周期: 在函数调用时临时创建,函数调用完毕则立即销毁

三 名称空间总结:
    1. 加载顺序:
        先产生内置名称空间
        再产生全局名称空间
        如果调用函数则会临时局部名称空间

    2. 名字的查找顺序:
        从当前位置向上查找
        def func():
        #     # len=2222
        #     print(len)
        # len=1111
        # func()
    3. 函数的局部名称空间彼此隔离,但是全局名称空间与内置名称空间是所有函数共享的
    4. 名称空间的嵌套关系是在函数定义(检测语法)就固定死的与调用位置无关,即无论在
       何处调用函数都必须老老实实地按照定义阶段规定的嵌套关系去查找名字
'''
#示范一
# mmm=11111111111111
# # x='aaaa'
# def f1():
#     x=1
#     def f2():
#         # x=2
#         def f3():
#             # x=3
#             print(x)
#         f3()
#     f2()
#
#
# f1()
#
# def foo():
#     xxx=1111
#     print(mmm)
#     print(len)
#
# def bar():
#     yyy=2222
#     print(mmm)
#     print(len)
#
#
# foo()
# bar()


#示范二
# def f1():
#     # x=1111
#     def f2():
#         # x=333333333333333333333
#         print('from f2',x)
#     return f2
#
# xxx=f1()
# x='全局'
#
# def foo():
#     x='foo'
#     xxx()
#
# def bar():
#     x='bar'
#     xxx()
#
# def func():
#     x='func'
#     xxx()
#
#
# foo()
# bar()
# func()


#示范三
# yyy=111
# def func():
#     print(yyy)
#     xxx=2222
#
# func()


'''
全局作用域:内置名称空间+全局名称空间
    特点:全局存活,全局有效
    
局部作用域:局部名称空间
    特点:临时存活,函数内有效

'''
# 关键字: global
# 如果想要在局部修改全局名字对应的值是不可变类型时.必须在局部用global关键字加以声明
# x=111
# def func():
#     global x
#     x=222
#
# func()
# print(x)

#如果想要在局部修改全局名字对应的值是可变类型时,直接修改即可
# l=[1,2,3]
# def func():
#     l.append(4)
#
# func()
# print(l)

# nonlocal
# x=2222
# def f1():
#     x=1111
#     def f2():
#         # global x
#         nonlocal x
#         x=0
#     f2()
#     print('在f1内的x的值===>',x)
#
# f1()
# print(x)


aaaaaa=1111111111111
# print(globals())

def func():
    x=1
    y=2
    print(locals())

func()

'''
1. 什么是闭包函数=>函数嵌套+函数对象+名称空间与作用域
    闭:定义在函数内的函数
    包:该内部函数需要访问一个名字,该名字属于外层函数作用域的(强调:不是全局作用域)
2. 为何要用闭包函数
    为了实现装饰器
3. 如何用闭包函数
    def outter(xxx):
        def inner():
            xxx
        return inner
'''
# def outter():
#     xxx=111
#     def inner():
#         print(xxx)
#     return inner
#
# f=outter()
# def foo():
#     xxx=2222
#     f()
# foo()

# 为函数体传参的两种解决方案
# 方案一: 直接以参数的形式传入
# def func(xxx):
#     print(xxx)
# func(111)

#方案二:
def outter(xxx):
    # xxx=111
    def func():
        print(xxx)
    return func

func=outter(111)

'''
1. 什么是装饰器
    装饰器就是用来为被装饰的对象新增功能的工具/函数
    被装饰的对象可以是任意可调用的对象
    装饰器本事也可以是任意可调用的对象

2. 为何要用装饰器
    开放封闭原则:对修改封闭,对扩展开放
    也就是不可以修改源代码，而对原有的功能进行扩展
    装饰器需要遵循的原则:
        1. 不能修改被装饰对象的源代码
        2. 不能修改被装饰对象的调用方式

    装饰器的目标:就是要在遵循原则1和2的前提下,为被装饰对象新增功能

3. 如何实现装饰器

'''
# # 阶段一:
###计算出一段程序执行的时间并打印出来
# import time
# def index():
#     time.sleep(1)
#     print('welcome to index page')
# 
# start=time.time()
# index()
# stop=time.time()
# print('run time is %s' %(stop - start))

# # 阶段二:
# import time
# def index():
#     time.sleep(1)
#     print('welcome to index page')
#
# def wrapper():
#     start=time.time()
#     index()
#     stop=time.time()
#     print('run time is %s' %(stop - start))

# wrapper()


# # 阶段三:
# import time
#
# def index():
#     time.sleep(1)
#     print('welcome to index page')
#
# def wrapper(func):
#     start=time.time()
#     func()
#     stop=time.time()
#     print('run time is %s' %(stop - start))
#
# wrapper(index)

# 阶段四:
# import time
#
# def index():
#     time.sleep(1)
#     print('welcome to index page')
#
# def timmer(func):
#     # func=最原始那个index的内存地址
#     def wrapper():
#         start=time.time()
#         func()
#         stop=time.time()
#         print('run time is %s' %(stop - start))
#     return wrapper
#
# index=timmer(index) #index=wrapper的内存地址
# index() #wrapper()

#############################################################################################################
# 装饰器语法糖
# 在被装饰器对象正上方单独一行写: @装饰器的名字
# 解释器一旦执行到@装饰器的名字就会: 原函数名=装饰器的名字(正下方那个函数)

# import time
#
# def timmer(func):
#     # func=最原始那个index的内存地址
#     def wrapper():
#         start=time.time()
#         func()
#         stop=time.time()
#         print('run time is %s' %(stop - start))
#     return wrapper
#
# @timmer #index=timmer(index) #index=wrapper的内存地址
# def index():
#     time.sleep(1)
#     print('welcome to index page')
#
# index() #wrapper()


# 装饰器修订:
# import time
# 
# def timmer(func):
#     # func=最原始那个index的内存地址
#     def wrapper(*args,**kwargs):
#         start=time.time()
#         res=func(*args,**kwargs)
#         stop=time.time()
#         print('run time is %s' %(stop - start))
#         return res
#     return wrapper
# 
# @timmer #index=timmer(最原始那个index的内存地址) #index=wrapper的内存地址
# def index():
#     time.sleep(1)
#     print('welcome to index page')
# 
# 
# @timmer # home=timmer(最原始那个home的内存地址) #home=wrapper的内存地址
# def home(name):
#     time.sleep(2)
#     print('welcome %s to home page' %name)
#     return 11111
# 
# res=index() #wrapper()
# print('index====>',res)
# res=home('egon') #wrapper('egon')
# print('home====>',res)

装饰器补充：
import time
from functools import wraps

def timmer(func):
    @wraps(func)
    def wrapper(*args,**kwargs):
        start=time.time()
        res=func(*args,**kwargs)
        stop=time.time()
        print('run time is %s' %(stop - start))
        return res
    # wrapper.__doc__=func.__doc__
    # wrapper.__name__=func.__name__
    return wrapper

# @timmer #index=timmer(最原始那个index的内存地址) #index=wrapper的内存地址
def index():
    """
    这是一个index函数
    :return:
    """
    time.sleep(1)
    print('welcome to index page')

# index() #wrapper()

# print(help(index)) #print(index.__doc__)
# print(index.__doc__)

# print(help(index)) #print(wrapper.__doc__)
print(index.__name__)