day12 python学习 装饰器

闭包函数：

内部函数包含对外部作用域而非全剧作用域名字的引用，该内部函数称为闭包函数
#函数内部定义的函数称为内部函数

闭包函数获取网络应用
from urllib.request import urlopen

def index():
    url = "http://www.xiaohua100.cn/index.html"
    def get():
        return urlopen(url).read()
    return get

xiaohua = index()    #层层调用层层返回的一个函数#
content = xiaohua() #每一层得到的返回值都是下一层的函数，执行返回值
                 #就是执行下一层函数。
print(content)

判断闭包函数的公式print(inner.__closure__)

输出的__closure__有cell元素 ：是闭包函数
def func():
    name = 'eva'
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

函数名的本质：

　　就是一个变量，保存了函数所在的内存地址

2.装饰器

装饰器的本质：一个闭包函数

　　装饰器的功能：在不修改原函数及其调用方式的情况下对原函数功能进行扩展

##完美的装饰器
def warpper(func):  #warpper 是装饰器的名字，被传入的参数就是函数的名字
    def inner(*args,**kwargs): #在装饰器中需要定义一个内部函数inner
        """函数前的内容"""
        ret=func(*args,*kwargs)#被装饰的函数，并且要执行
        """函数后的内容"""
        return ret#函数的的返回值
    return inner#将内部函数的名字返回
@warpper   #这个就是语法糖 func=swapper(func) 
def func():
    print('aaa')
func()  执行次布就是在执行  swapper(func)()   swapper(func)先将  inner 返回  然后后边还有一个括号  所以接着执行  inner() 将参数穿进去执行它就会执行它内部的函数  

# #登录   要完成用户一次登录后就不用再登录就可以执行打开网页的功能，
flag=True
def paswer(func):
    def inner(*args,**kwargs):   #先写一个登录的程序，然后将他封装起来，放在内部
        global flag     #这个必须从外部引入一个全局变量Flag然后再在内部将他改变
                        #否则再次想要打开其他的页面的时候，运行那个程序还会再让你登录
        name = 'alex'
        pas = '123'
        if flag:
            username = input('请输入用户名')
            password = input('请输入密码')
            if name == username and pas == password:
                print('登录成功')
                flag = False
        if flag==False:   #这里不能是else 因为因为else的话上边输错密码也会从新登录
            func(*args,**kwargs)
    return inner
@paswer
def func1():
    print ('欢迎来到目录页')
@paswer
def func2():
    print("欢迎来到小结页")

func2()
func1()

开放封闭原则

　　1.对扩展是开放的

　　　　为什么要对扩展开放呢？

　　　　我们说，任何一个程序，不可能在设计之初就已经想好了所有的功能并且未来不做任何更新和修改。所以我们必须允许代码扩展、添加新功能。

　　2.对修改是封闭的

　　　　为什么要对修改封闭呢？

　　　　就像我们刚刚提到的，因为我们写的一个函数，很有可能已经交付给其他人使用了，如果这个时候我们对其进行了修改，很有可能影响其他已经在使用该函数的用户。

装饰器完美的遵循了这个开放封闭原则。

 

  装饰器进阶

#装饰器进阶
#装饰器的进阶有两个
@func1
@func2
def ada()
 #俄罗斯套娃式函数，里边套靠近函数的
#装饰器函数，外边套另一个函数#  要记住是那个套那个的

ef wrapper1(func):
    def inner1(*args,**kwargs):
        print('in wrapper 1,before')
        ret = func(*args,**kwargs)   #qqxing
        print('in wrapper 1,after')
        return ret
    return inner1

def wrapper2(func):     #inner1
    def inner2(*args,**kwargs):
        print('in wrapper 2,before')
        ret = func(*args,**kwargs)   #inner1
        print('in wrapper 2,after')
        return ret
    return inner2
#当一个函数要引用两个装饰器才能完成功能时
@wrapper2  #先在外层执行这个的第一句
@wrapper1  #在执行这个地方执行的所有内容，然后再返回去执行上边的函数剩下的内容
def qqxing():
    print('qqxing')
qqxing()

#装饰器进阶2  带有def  outer():的函数

 1 # 带参数的装饰器：（相当于开关）为了给装饰器传参
 2 # F=True#为True时就把装饰器给加上了
 3 F=False#为False时就把装饰器给去掉了
 4 def outer(flag):
 5     def wrapper(func):
 6         def inner(*args,**kwargs):
 7             if flag:
 8                 print('before')
 9                 ret=func(*args,**kwargs)
10                 print('after')
11             else:
12                 ret = func(*args, **kwargs)
13             return ret
14         return inner
15     return wrapper
16 
17 @outer(F)#@wrapper
18 def hahaha():
19     print('hahaha')
20 
21 @outer(F)
22 def shuangwaiwai():
23     print('shuangwaiwai')
24 
25 hahaha()
26 shuangwaiwai()