python装饰器初级

global与nonlocal

1.global的作用：
可以在局部空间里直接就该全局名称工具中的数据
代码展示：
name = 'moon'       #设置了一个全局变量
def fucn():
    name = 'god'    #设置了一个局部变量
fucn()              #执行函数
print(name)        # moon 因为局部变量只在局部有作用，所以没有更改全局变量name

def fucn():        
    global name      # 使用了global方法，可以在局部空间直接修改全局空间命名
    name = 'god'
fucn()
print(name)       # god  因为global方法，在函数代码体执行时更改了全局变量


2.nonlocal的作用：
可以是内部局部空间修改外层局部空间变量数据

def fucn():       # 1 定义一个函数fucn
    age = 18      # 3 定义变量age = 18
    def fucn2():  # 4 定义一个函数fucn2
        age = 20  # 6 执行函数 age=20 (局部命名仅限fucn2函数中)
    fucn2()       # 5 调用函数fucn2 
    print(age)    # 7 打印 fucn函数体内age  #18 
fucn()           # 2 调用函数fucn代码体

def fucn():
    age = 18
    def fucn2():
        nonlocal age  #使用nonlocal方法，可以更改外层局部空间数据
        age = 20      # 更改了函数fucn中的数据
    fucn2()
    print(age)       # 20  
fucn()

函数名的多种用法

函数名其实也是类似一个变量名，只是一个名字和一个内存地址的链接，该地址内存放的不是数据值而是一端代码，当使用函数名后面加上()时 则会通过这个名字找到这段代码并执行
1.函数名可以用来给变量名赋值
def func():
  name = 'moon'
res = func     # 把函数名func绑定的内存地址 赋予了变量名 res
res()
print(res)

2.可以当做函数的实参
def func():
    print('moon')
def func2(func):    
    print('god')  #god
    print(func)  # 打印函数 func的绑定地址
func2(func)  #把函数名func作为实参传入 func2函数里

3.可以当做函数的返回值
def func()
    print('func')
def func1()
    print('func1')
    return func   #此函数体代码立刻运行完毕，返回 func变量名的内存地址
res = func1()  #func1返回值 func的地址 赋值给 res
print(res)  # func函数的绑定地址
res()   #func  调用res等于调用func


4.函数名也可以当做是容器类型，可以放在字典中
def register():
   	print('注册功能')
def login():
   	print('登录功能')
func_dict = {'1':register,'2':login}    # 函数名被当做字典的值来处理
choice = input('请选择要执行的功能>>>')
if choice in func_dict  
   func_dict.get(choice)()    # 如果用户输入的在功能字典中
   #则调取 功能字典中键对应的值的函数地址 （）并运行
 else:
   print('功能不存在')

闭包函数

1，什么是闭包函数？
在函数体内部的函数，并且用到了外部函数名称空间中的名字
需要满足，定义在函数体内   并且 用到了外部函数名称空间中的名字

代码展示：
def func():
  a = 1
  b = 2
  def func2():
    print(a+b)  #定义在函数体内   并且 用到了外部函数名称空间中的名字
  func2()
func() # 3

2,闭包函数实际应用
 给另外一种函数体代码传参的方式
2.1方式1:代码里面缺什么变量名形参里面就补什么变量名
  def func(a,b):
  a = a
  b = b
  def func2():
    print(a+b)  #定义在函数体内   并且 用到了外部函数名称空间中的名字
  func2()
func(1,2) # 3
func(1,2)
func(1,2)

2.2闭包函数传参
def func(a, b):  # 执行1  先定义一个函数
    def func2():  
        print(a + b)
    return func2   # 执行3 被调用看返回值 返回值是func2 
res = func(2,3)   # 执行2  先看右边 调用函数  func2被赋值给res
res()  #5     执行res 等于执行 func2  所以等于5
res()  #5
res = func(3,3)  
res()  #6
res()  #6 

装饰器简介

1，装饰器的概念
在！不改变被装饰对象的源代码！和！调用方式！的情况下给被装饰的对象添加新的功能
2.本质
是由 函数参数 加上 名称空间 函数名多种用法 闭包函数技术的组合产生的
3.口诀
  对修改封闭 对扩展开发
4,装饰器的推导流程
import time
def index():
    time.sleep(3)
    print('from index')
def home():
    time.sleep(1)
    print('from home')
--------现在如果我们想在 index函数体代码前后添加代码-------
start_time = time.time()
index()
end_time = time.time()
print('函数index的执行时间为>>>:', end_time-start_time)
--------现在如果这段代码需要在不同地方反复使用 我们再把他们包装成函数-------
def get_time():
   start_time = time.time()
   index()
   end_time = time.time()
   print('函数index的执行时间为>>>:', end_time-start_time)
get_time()

--------现在如果这段代码需要在不同地方反复使用 并且是不同的函数体-------
def get_time(xxx): #设置一个形参
   start_time = time.time()
   xxx()   #这样就可以根据不同传参 这里的函数也会更改
   end_time = time.time()
   print('函数index的执行时间为>>>:', end_time-start_time)
get_time(index)
get_time('其他实参') # 这样也就可以实现 同样的功能对不同的实参是实施

------------更加完善一点，加上闭包函数的功能---------------
def outer(xxx)：
	def get_time():
     start_time = time.time()
     xxx()   #这里的xxx其实就是对应形参的xxx 因为局部空间没有这个就会在外层找
     end_time = time.time()
     print('函数index的执行时间为>>>:', end_time-start_time)
  return get_time
res = outer(index)  # 这里就是用res来接受这个闭包变量名(index) 的返回值
# 先执行outer函数体，实参为index函数，这个函数体返回值为 get_time函数，所以现在
#  res = get_time  实参为 index
res() 

------------更加完善一点，如果传递的函数本身还有形参---------------
import time
def index(a):
  	print(a)
    time.sleep(3)
    print('from index')
def home(a,b):
    time.sleep(1)
    print('from home')

def outer(xxx)：  #形参被传入实参 被装饰函数
	def get_time(a):
     start_time = time.time()
     xxx(a)    #局部空间没有，向外找，找到了 是index 但是这个函数需要有传参 他的传参哪里找。可以通过get_time的形参去获取，
     end_time = time.time()
     print('函数index的执行时间为>>>:', end_time-start_time)
  return get_time
res = outer(index)  # 给被装饰函数outer传参 index 然后returun了 get_time 给了 res
res(a)    # res传参等于 给get_time传参  为什么要给get_time传参 因为内部函数体index需要参数。
#所以这个代码就成功运行了

------------更加完美，被装饰函数不确认有多少传参---------------

def outer(xxx)：  #形参被传入实参 被装饰函数
	def get_time(*regs,**wregs): # 更加完善，这里可以接受任意的数据
     start_time = time.time()
     xxx(*regs,**wregs)     #也是可以接收任意的数据
     end_time = time.time()
     print('函数index的执行时间为>>>:', end_time-start_time)
  return get_time
res = outer(index)  
res(a，2，2，3，2)  


------------被装饰函数如果有返回值---------------

import time
def index(*args):
    print(args)
    time.sleep(2)
    print('from index')
    return '我是index'
def moon(a,b):
    time.sleep(1)
    print('from MOON')
    return '我是moon'
def outer(xxx):
    def get_time(*args,**kwargs):
        start_time = time.time()
        res = xxx(*args,**kwargs)  #这里使用了res来接受这个函数体的返回值
        end_time = time.time()
        print('函数index的执行时间为>>>:', end_time - start_time)
        return res   #这里证明get_time代码运行接受返回值为 res
    return get_time


res = outer(moon) 
print(res(123,222)) #成功运行

装饰器固定模板

def 装饰器函数名(被装饰函数名):
  def inner(*args,**kwargs):
    #执行被装饰对象 之前可以做的额外操作
    res = 被装饰函数名(*args,**kwargs)
    #执行被装饰对象之后可以做的额外操作
    return res
  return inner

装饰器语法糖

def outer(func_name):
  def inner(*args,**kwargs):
    #执行被装饰对象 之前可以做的额外操作
    res = func_name(*args,**kwargs)
    #执行被装饰对象之后可以做的额外操作
    return res
  return inner

@outer      # 这个代表  func = outer(func)
def func():
  print('im func')
  return 'func'

#注意一定要紧挨被装饰的函数， 会自动已被装饰函数名 来接收装饰后的结果