def foo():
    print("foo函数被运行了！")

如果就这样定义了函数，foo函数里面的语句是不会执行的。
python解释器只是简单地在内存定义了一个名为foo的内存地址。

相当于：
foo = print("foo函数被运行了！")


再看看，下面的例子：

def foo():
    print("我是上面的函数定义！")

def foo():
    print("我是下面的函数定义!")

foo()

运行结果：
我是下面的函数定义!

def foo():
    print("foo函数被运行了！")
    return "OK"

分别运行：
foo
foo()

函数名：foo
函数体：1-3行
返回值：字符串"OK"，如不定义，默认返回NONE

函数的内存地址:当函数体被python解释器读进内存后，它有标识符即函数名foo引用，
简单的说，foo指向的是函数体在内存中的保存位置

函数名加括号：foo()，函数的调用方法，只有见到这个括号，程序才会根据函数名从内存中找到函数体并执行。

def outer(func):
    def inner():
        print("我是内层函数！")
    return inner

def foo():
    print("我是原始函数！")
    
outer(foo)
outer(foo())

有一个大公司，下属的基础平台部负责内部应用程序及API的开发
有上百个业务部门负责不同的业务，他们各自调用基础平台部提供的不同函数处理自己的业务
情况如下：
# 基础平台部门开发了上百个函数
def f1():
    print("业务部门1数据接口......")
def f2():
    print("业务部门2数据接口......")
def f3():
    print("业务部门3数据接口......")
def f100():
    print("业务部门100数据接口......")
    
#各部门分别调用
f1()
f2()
f3()
f100()

由于公司在创业初期，基础平台部开发这些函数时，
由于各种原因，比如时间，比如考虑不周等等，没有为函数调用进行安全认证。
现在，平台部主管决定弥补这个缺陷，于是：

def f1():
    #加入认证程序代码
    print("业务部门1数据接口......")
def f2():
    # 加入认证程序代码
    print("业务部门2数据接口......")
def f3():
    # 加入认证程序代码
    print("业务部门3数据接口......")
def f100():
    #加入认证程序代码
    print("业务部门100数据接口......")

#各部门分别调用
f1()
f2()
f3()
f100()

##########################
def login():
    print("认证成功！")
    
    
def f1():
    login()
    print("业务部门1数据接口......")
def f2():
    login()
    print("业务部门2数据接口......")
def f3():
    login()
    print("业务部门3数据接口......")
def f100():
    login()
    print("业务部门100数据接口......")

#各部门分别调用
f1()
f2()
f3()
f100()
##########################
以上实现方法虽然可行，但是它对已经实现的功能代码内部进行了修改。违反了“开放-封闭”原则

再继续往下看：

def outer(func):
    def inner():
        print("认证成功！")
        result = func()
        print("日志添加成功")
        return result
    return inner

@outer
def f1():
    print("业务部门1数据接口......")

@outer
def f2():
    print("业务部门2数据接口......")
@outer
def f3():
    print("业务部门3数据接口......")

@outer
def f100():
    print("业务部门100数据接口......")

#各部门分别调用
f1()
f2()
f3()
f100()

对于上述代码，也是仅需对基础平台的代码进行拓展，就可以实现在其他部门调用函数 f1 f2 f3 f100 之前都进行认证操作。
在操作结束后保存日志，并且其他业务部门无需他们自己的代码做任何修改，调用方式也不用变。

一个装饰器：
def deco(func):
    def inner():
        print("这是inner函数")
        result = func()
        return result
    return inner

@deco
def func1():
    print("这个是func1")

func1()


实际上相当于：
fun1 = deco(func1)

一个参数的情况：
def outer(func):
    def inner(username):
        print("认证成功！")
        result = func(username)
        print("日志添加成功")
        return result
    return inner

@outer
def f1(name):
    print("%s 正在连接业务部门1数据接口......"%name)

# 调用方法
f1("jack")


在inner函数的定义部分也加上一个参数，调用func函数的时候传递这个参数，很好理解吧？
可问题又来了，那么另外一个部门调用的f2有2个参数呢？f3有3个参数呢？你怎么传递？

很简单，我们有*args和**kwargs嘛！号称“万能参数”！简单修改一下上面的代码：
def outer(func):
    def inner(*args,**kwargs):
        print("认证成功！")
        result = func(*args,**kwargs)
        print("日志添加成功")
        return result
    return inner

@outer
def f1(name,age):
    print("%s 正在连接业务部门1数据接口......"%name)

# 调用方法
f1("jack",18)

def outer1(func):
    def inner(*args,**kwargs):
        print("认证成功！")
        result = func(*args,**kwargs)
        print("日志添加成功")
        return result
    return inner


def outer2(func):
    def inner(*args,**kwargs):
        print("一条欢迎信息。。。")
        result = func(*args,**kwargs)
        print("一条欢送信息。。。")
        return result
    return inner


@outer1
@outer2
def f1(name,age):

    print("%s 正在连接业务部门1数据接口......"%name)

# 调用方法
f1("jack",18)


执行结果：

认证成功！
一条欢迎信息。。。
jack 正在连接业务部门1数据接口......
一条欢送信息。。。
日志添加成功

# 认证函数
def  auth(request,kargs):
    print("认证成功！")
# 日志函数
def log(request,kargs):
    print("日志添加成功")
# 装饰器函数。接收两个参数，这两个参数应该是某个函数的名字。
def Filter(auth_func,log_func):
    # 第一层封装，f1函数实际上被传递给了main_fuc这个参数
    def outer(main_func):
        # 第二层封装，auth和log函数的参数值被传递到了这里
        def wrapper(request,kargs):
            # 下面代码的判断逻辑不重要，重要的是参数的引用和返回值
            before_result = auth(request,kargs)
            if(before_result != None):
                return before_result;

            main_result = main_func(request,kargs)
            if(main_result != None):
                return main_result;

            after_result = log(request,kargs)
            if(after_result != None):
                return after_result;

        return wrapper
    return outer
# 注意了，这里的装饰器函数有参数哦，它的意思是先执行filter函数
# 然后将filter函数的返回值作为装饰器函数的名字返回到这里，所以，
# 其实这里，Filter(auth,log) = outer , @Filter(auth,log) =  @outer
@Filter(auth,log)
def f1(name,age):

    print("%s 正在连接业务部门1数据接口......"%name)

# 调用方法
f1("jack",18)


运行结果：

认证成功！
jack 正在连接业务部门1数据接口......
日志添加成功

带有参数的多个装饰器：
@deco1(deco_arg)
@deco2()
def foo():
    pass

实际上相当于：
def foo():
    pass

foo = deco1(deco_arg)(deco2(foo))