在一个函数内部再定义一个函数，并且这个函数用到了外面的函数的变量，那么将这个函数以及用到的一些变量称之为闭包

---

def test():

    print("---1---")

    test()

    test

注意：一个是调用函数，一个是返回对象的引用，也就是函数的首地址。

test表示是函数，引用信息，引用对象，首地址。

test（）表示执行test函数

简单版的闭包

def test(number1):

        print("----1--")

        def test_in():

                print("----test_in---")

                print(number1 +100)

        print("---3-----")

        return test_in

res=test(100)    #相当于res=test_in

print("*"*20)  #相当于 print(test_in)

res()   #相当于test_in

结果是---1---

---3----

**************

---test_in-----

200

#####res(1) 相当于 test_in(1)也就是你在调用test_in(1)的时候传递参数了，但是在定义这个函数的时候确没有定义形参,会报错

---

def test(number1):

print("----1--")

        def test_in(number2):

                print("----2---")

                print(number1 +number2)

print("---3---")

        return test_in

res=test(100)   

print("*"*20) 

res(1)   

res(100)

结果是：----1--

---3----

***********

------2-------

101

------2-----

200

---

装饰器

生成器是用来生成东西的，装饰器是用来装饰东西的。

重写：

def test1():

        print("----1-----")

def test1():

        print("-----2----")

test1()

结果是：----2-----

---

lambda函数

def foo():

        print("foo")

foo = lambda x:x+1

foo(2)

结果是3

---

语法糖

def w1(func):

        def inner():

                print("验证权限")

                func()

        return inner

def f1():

        print("===f1")

def f2():

        print("===f2")

A=w1(f1)

A()

运行结果

验证权限

===f1

---

def w1(func):

        def inner("验证权限")

                func()

        return inner

@w1

def f1():

        print("===f1")

def f2():

        print("===f2")

f1()

结果是

验证权限

===f1

---

def login(func): 

         def inner(): 

                 username = input("name")

                 password = input("pwd")    

                 if username=="1" and password=="1": 

                         print("登陆成功") 

                         func() 

                 else: 

                         print("登陆失败"）

        return inner()

 @login 

def f1():

         print("客户是f1")

 @login 

def f2():

         print("f2===============") 

f1() 

f2()

结果是##########################

name1

pwd1

登陆成功

客户是f1

加粗与倾斜共同装饰：

装饰器的功能：

引入日志，函数执行时间统计，执行函数前预备处理，执行函数后清楚处理，权限校验等场景

# 加粗装饰器

def A(fn):

        def aa():

                return"<b>"+fn()+"</b>"

        return aa

def B(fn):

        def aa():

                return "<i>"+fn()+"</i>"

        return aa

@A

def test1():

        return"hello1"

@B

def test2():

        return"hello2"

@A

@B

def test3():

        return "hello3"

print(test1())

print(test2())

print(test3())

结果是

<b>hello1</b>

<i>hello2</i>

<b><i>hello3</i></b>

---

装饰器执行的时间分析

def A(func):

        print("装饰中")

        def inner():

                print("验证")

                func()

        return inner

@A

def aa():

        print("----f1")

# aa()

aa被注释掉的时候，打印装饰中，

aa未被注释的情况下打印      

装饰中

验证

----f1

---

def A(func):

        print("----f1")

                def inner():

                        print("inner1")

                        func()

                        print("inner2")

        print("-----f2")

        return inner

# def test():

#         print("test")

# test = A(test)

# test()

#使用装饰器的形式

@A

def test():

        print("-----test")

test()

结果是：

装饰中

----f1

-----f2

inner1

-----test

inner2

想要传递参数的话：

test(11，22)，

需要同时def inner(a，b):和func(a，b)，

def test(a,b)

print("----%d,%d"%(a,b))

不然会报错

---

# 装饰器对带有返回值的函数进行装饰

def test():

    print("--test--")

    return "haha"

res = test()

print("%s"%res)

 结果是：

--test--

haha

---

def func(ff):

        print("---func--1")

                def func_in():

                        print("in 1")

                        ff()

                        print("in 2")

                        print("---func--2")

                  return func_in

@func

def test():

        print("---test---")

        return "hahah"

res = test()

print("test=%s"%res)

结果是：

---func--1

---func--2

in 1

---test---

in 2

test=None

/////////需要加上

xxx=ff()

return xxx

---