#普通装饰器
# (@+函数名)，需要记住关键两点：
#功能：
#1、自动执行outer函数，并且将其下面的函数名f1当作参数传递
#2、将outer函数的返回值，重新赋值给f1
# #装饰器必备
# ####第一：函数名和执行函数####
# def foo(): #创建函数
# print('hello') #函数体
# foo #表示是函数名，代指整个函数
# foo() #表示执行f00函数
# # 输出：hello
# ####第二：函数被重新定义###
# def foo():
# print("foo1")
#
# foo = lambda : print("foo2") #lambda表达式，无参数
#
# foo() #执行下面的lambda表达式，而不是原来的foo函数，foo函数已经被重新定义
# #同名函数被覆盖
# def f1(): #1
# print(123)
#
# def f1():#2 #4
# print(456) #5
# f1() #3
# #输出： 456
#f1函数作为参数进行传递
# def f1(): #1 创建f1函数 #6执行f1()函数，结果是打印输出123
# print("123") #7
# #没有return，默认返回None
# def f2(xxx): #2 创建f2函数 #4 接收到传递的f1以后，xxx也是代指f1函数的整体,f2(xxx)就相当于f2(f1)
# ret = xxx() #5 xxx()就等于是f1(),f1()就代表去执行f1()这整个函数。
#
# f2(f1) #3 调用f2函数，f1作为参数（f1没有单引号和双引号是一个函数名; f1没有带括号()，代指的是f1函数的整体，f1作为参数传递给xxx
# #装饰器 流程剖析 分解功能1：自动执行outer()函数，并将下面的函数名f1作为参数传递 （）
# # def outer(): #TypeError: outer() takes 0 positional arguments but 1 was given 翻译：outer需要0个参数，但传递了1个参数
# def outer(func): #1在内存中创建outer函数 #3执行outer(f1)函数 #这是装饰器的基本格式，必须带参数，如果没有参数就会报错。
# print(123) #4 执行函数体：打印123
# print(func) #5 执行函数体：打印func参数，输出:<function f1 at 0x0000000000B28620>
# @outer #2 自动执行outer()函数，并将下面的函数名f1作为参数传递。即@outer等价于outer(f1)
# def f1():
# print("F1")
# #装饰器 流程剖析 分解功能2：将outer函数的返回值111，重新赋值给f1
# def outer(func): #1在内存中创建outer函数 #3执行outer(f1)函数 #这是装饰器的基本格式，必须带参数，如果没有参数就会报错。
# return "111" #4 将outer函数的返回值111，重新赋值给f1。
# @outer #2 自动执行outer()函数，并将下面的函数名f1作为参数传递
# def f1():
# print("F1")
# print(f1) #5 原来的f1函数被覆盖，被重新赋值为111.
#问题解析：
#4 （为什么outer函数的返回值111，就重新赋值给了f1，f1并没有调用outer(f1)函数啊？）这个问题纠结了我至少4个小时。感谢绍宁指点。如下:
# @outter 等价于 outter（f1）
# 等价于f1=outter(f1)
# outter函数的返回值是111
# 所以f1就变成了111
# 装饰器就是在把原来的函数包起来加工一下，但是加工后还是叫原来的函数名，用了装饰器后 原来的函数名 等于装饰器函数的返回值
# 参考链接：http://www.cnblogs.com/rollenholt/archive/2012/05/02/2479833.html
# #函数是一个对象，可以赋值给其他对象变量，通过变量可以调用该函数。
# def foo():
# print("test")
# f = foo #注意没有使用圆括号，因为不是在调用函数
# f()
# # # 输出：test
# print(foo.__name__)#通过函数对象_name_属性，可以拿到函数的名字：
# #输出：foo
# print(f.__name__)
# # 输出：foo
#装饰器 流程剖析 将outer函数的返回值，换成其他函数。
#注：解释器解释后f1函数就等于111，这样f1函数就被成功修改了，那以后外部再来调用f1函数的时候就会调用111，那我们就成功的将f1函数换成了111
#我们能把f1换成111,同理，也能换成一个其他函数。
# def outer(func): #1在内存中创建outer函数 #3执行outer(f1)函数 #这是装饰器的基本格式，必须带参数，如果没有参数就会报错。
# # return "111" #4 将outer函数的返回值111，重新赋值给f1。
# def inner(): #4 在内存中创建inner函数 #8 外部调用f1()函数就等于是调用inner函数，f1函数换成了inner函数，即新f1函数。
# print("在执行老的f1函数之前执行命令") #9 在执行老的f1函数之前执行
# func() #10 第2步时，f1函数作为参数传递给了outer函数的func参数，func代指的就是老的f1函数，即装饰的原函数，func加括号，代表执行老的f1()函数
# print("在执行老的f1函数之后执行命令") #11 在执行老的f1函数之后执行
# return inner #5 inner不加括号代指的是整个inner函数，将outer函数的返回值inner函数，重新赋值给f1,f1就代指的是inner函数。
# #inner()加括号是执行inner函数，代表的是return之前先执行inner函数，然后把返回值(默认为None)赋值给f1，把inner函数
# #执行后的返回值赋值给f1，外部程序再调用时得到的是inner的返回值，不是f1的返回值，这样做会破坏f1函数原有的功能
#
# @outer #2 自动执行outer()函数，并将下面的函数名f1作为参数传递
# def f1():
# print("F1")
# # print(f1) #6 原来的f1函数被覆盖，被重新赋值为inner函数。# <function outer.<locals>.inner at 0x00000000030AF1E0>
# #装饰器 流程剖析 返回值
# #注：解释器解释后f1函数就等于111，这样f1函数就被成功修改了，那以后外部再来调用f1函数的时候就会调用111，那我们就成功的将f1函数换成了111
# #我们能把f1换成111,同理，也能换成一个其他函数。
# def outer(func): #1在内存中创建outer函数 #3执行outer(f1)函数 #这是装饰器的基本格式，必须带参数，如果没有参数就会报错。
# # return "111" #4 将outer函数的返回值111，重新赋值给f1。
# def inner(): #4 在内存中创建inner函数 #8 外部调用f1()函数就等于是调用inner函数，f1函数换成了inner函数，即新f1函数。
# print("在执行老的f1函数之前执行命令") #9 在执行老的f1函数之前执行
# # ret = func() #10 第2步时，f1函数作为参数传递给了outer函数的func参数，func代指的就是老的f1函数，即装饰的原函数，func加括号，代表执行老的f1()函数
# r = func() #10 执行func()函数，等于执行原f1()函数，原f1函数有返回值，定义变量r用于接收原f1函数的返回值
# print("在执行老的f1函数之后执行命令") #11 在执行老的f1函数之后执行
# return r #12 r代表原f1函数的返回值，新f1函数执行之后将原f1函数的返回值返回给函数调用者。（函数遇到return就不再向下执行，所以把return放在最下面）
# return inner #5 inner不加括号代指的是整个inner函数，将outer函数的返回值inner函数，重新赋值给f1,f1就代指的是inner函数。
# #inner()加括号是执行inner函数，代表的是return之前先执行inner函数，然后把返回值(默认为None)赋值给f1，把inner函数
# #执行后的返回值赋值给f1，外部程序再调用时得到的是inner的返回值，不是f1的返回值，这样做会破坏f1函数原有的功能
#
# @outer #2 自动执行outer()函数，并将下面的函数名f1作为参数传递
# def f1():
# print("F1")
# return "原f1函数返回值FFFF" #原f1函数有返回值FFFF
# # print(f1) #6 原来的f1函数被覆盖，被重新赋值为inner函数。# <function outer.<locals>.inner at 0x00000000030AF1E0>
# #装饰器 流程剖析 1个参数
# #注：解释器解释后f1函数就等于111，这样f1函数就被成功修改了，那以后外部再来调用f1函数的时候就会调用111，那我们就成功的将f1函数换成了111
# #我们能把f1换成111,同理，也能换成一个其他函数。
# def outer(func): #1在内存中创建outer函数 #3执行outer(f1)函数 #这是装饰器的基本格式，必须带参数，如果没有参数就会报错。
# # return "111" #4 将outer函数的返回值111，重新赋值给f1。
# def inner(a): #4 在内存中创建inner函数 #8 外部调用f1()函数就等于是调用inner函数，f1函数换成了inner函数，即新f1函数。#8.1外部调用新f1函数的实参，首先传递给形参“a”
# print("在执行老的f1函数之前执行命令") #9 在执行老的f1函数之前执行
# # ret = func() #10 第2步时，f1函数作为参数传递给了outer函数的func参数，func代指的就是老的f1函数，即装饰的原函数，func加括号，代表执行老的f1()函数
# r = func(a) #10 执行func()函数，等于执行原f1()函数，原f1函数有返回值，定义变量r用于接收原f1函数的返回值 #10.1将函数调用者传递的参数传递给原f1()函数。
# print("在执行老的f1函数之后执行命令") #11 在执行老的f1函数之后执行
# return r #12 r代表原f1函数的返回值，新f1函数执行之后将原f1函数的返回值返回给函数调用者。（函数遇到return就不再向下执行，所以把return放在最下面）
# return inner #5 inner不加括号代指的是整个inner函数，将outer函数的返回值inner函数，重新赋值给f1,f1就代指的是inner函数。
# #inner()加括号是执行inner函数，代表的是return之前先执行inner函数，然后把返回值(默认为None)赋值给f1，把inner函数
# #执行后的返回值赋值给f1，外部程序再调用时得到的是inner的返回值，不是f1的返回值，这样做会破坏f1函数原有的功能
#
# @outer #2 自动执行outer()函数，并将下面的函数名f1作为参数传递
# def f1(arg): #10.2接收函数调用者传递的参数arf = a
# # print("F1")
# print(arg)
# return "原f1函数返回值FFFF" #原f1函数有返回值FFFF
# # print(f1) #6 原来的f1函数被覆盖，被重新赋值为inner函数。# <function outer.<locals>.inner at 0x00000000030AF1E0>
#注：解释器解释后f1函数就等于111，这样f1函数就被成功修改了，那以后外部再来调用f1函数的时候就会调用111，那我们就成功的将f1函数换成了111
#我们能把f1换成111,同理，也能换成一个其他函数。
# def outer(func): #1在内存中创建outer函数 #3执行outer(f1)函数 #这是装饰器的基本格式，必须带参数，如果没有参数就会报错。
# # return "111" #4 将outer函数的返回值111，重新赋值给f1。
# def inner(a): #4 在内存中创建inner函数 #8 外部调用f1()函数就等于是调用inner函数，f1函数换成了inner函数，即新f1函数。#8.1外部调用新f1函数的实参，首先传递给形参“a”
# print("在执行老的f1函数之前执行命令") #9 在执行老的f1函数之前执行
# # ret = func() #10 第2步时，f1函数作为参数传递给了outer函数的func参数，func代指的就是老的f1函数，即装饰的原函数，func加括号，代表执行老的f1()函数
# r = func(a) #10 执行func()函数，等于执行原f1()函数，原f1函数有返回值，定义变量r用于接收原f1函数的返回值 #10.1将函数调用者传递的参数传递给原f1()函数。
# print("在执行老的f1函数之后执行命令") #11 在执行老的f1函数之后执行
# return r #12 r代表原f1函数的返回值，新f1函数执行之后将原f1函数的返回值返回给函数调用者。（函数遇到return就不再向下执行，所以把return放在最下面）
# return inner #5 inner不加括号代指的是整个inner函数，将outer函数的返回值inner函数，重新赋值给f1,f1就代指的是inner函数。
# #inner()加括号是执行inner函数，代表的是return之前先执行inner函数，然后把返回值(默认为None)赋值给f1，把inner函数
# #执行后的返回值赋值给f1，外部程序再调用时得到的是inner的返回值，不是f1的返回值，这样做会破坏f1函数原有的功能
#
# @outer #2 自动执行outer()函数，并将下面的函数名f1作为参数传递
# def f1(arg): #10.2接收函数调用者传递的参数arf = a
# # print("F1")
# print(arg)
# return "原f1函数返回值FFFF" #原f1函数有返回值FFFF
# # print(f1) #6 原来的f1函数被覆盖，被重新赋值为inner函数。# <function outer.<locals>.inner at 0x00000000030AF1E0>
#装饰器 流程剖析 函数传递多个参数使用万能参数，*args,**kwargs
def outer(func): #创建outer函数；f2函数作为参数传递给outer函数，func代指装饰的原函数，即原f2函数。
def inner(*args,**kwargs): #创建嵌套的inner函数,a,b接收f2函数调用者传递的参数 #*args,**kwargs可以接收任意参数
# pass
print("before：执行原函数之前")
r = func(*args,**kwargs) #执行原函数，接收原函数返回值；a,b将调用者传递的参数传递给原f2函数。#python自动把*args,**kwargs里面的参数传递给原函数 print("after：执行原函数之后") return r #返回原函数返回值 return inner #将inner函数的返回值重新赋值给f2函数,inner函数即为新f2函数。(inner后面无括号)@outerdef f1(): print("F1") return "f1"@outerdef f2(a1,a2): print(a1,a2) return "f2"
