装饰器

# 装饰器：
# 开闭原则（开放封闭原则）：对添加功能开放，对修改代码封闭

#举个例子，给一个函数，在不修改原来代码的基础上，添加新功能。
#无参数无返回值
def func():
    print('捏泥人，吹口气')
#装饰器 - 如果天气干燥，需要加水
def wrapper(fn):
    def inner():
        print('加水')
        fn()
    return inner #返回inner这个函数地址
# fun = wrapper(func) #inner这个函数地址
# fun() #调用inner函数
#但是我们不能把功能名字改了，所以
func = wrapper(func) # 我们还用原来的名字替换
func()

#有参数无返回值
def func(name,name1):
    print('你好',name,name1)

def wrapper(fn):
    def inner(*args,**kwargs): # 聚合
        fn(*args,**kwargs) #打散
        print('我想和你做朋友',args)
    return inner
func = wrapper(func) #inner
func('Tom','Jenny')

# 有参数有返回值
def func(name,name1):
    print('你好',name,name1)
    return name

def wrapper(fn):
    def inner(*args,**kwargs): # 聚合
        name = fn(*args,**kwargs) #打散 接收原函数的返回值
        print('我想和你做朋友',args)
        return name
    return inner
func = wrapper(func) #inner
print(func('Tom','Jenny')) #返回值为name


def wrapper(fn):
    def inner(*args,**kwargs): # 聚合
        name = fn(*args,**kwargs) #打散 接收原函数的返回值
        print('我想和你做朋友',args)
        return name
    return inner
@wrapper # 语法糖 相当于 func = wrapper(func)
def func(name,name1):
    print('你好',name,name1)
    return name

#总结
def wrapper(fn):
    def inner(*args,**kwargs):
        目标函数之前要做的操作
        re = fn(*args,**kwargs) re为返回值
        目标函数之后要做的操作
        return re
    return inner
在要用装饰器的函数前加上 @wrapper（语法糖）

# 函数的注释
def test_1(name):
    """
    这个函数是测试函数
    :param name: 指的是函数的参数
    :return: 函数的返回值
    """
    pass
#将被装饰过的函数某些属性改变成原有函数的属性值
from functools import wraps
def wrapper(fn):
    @wraps(fn)
    def inner(*args,**kwargs):
        """目标函数之前要做的事情"""
        ret = fn(*args,**kwargs)
        """目标函数之后要做的事情"""
        return ret
    return inner
@wrapper
def test_2():
    print('I am test_2')
test_2()
print(test_2.__name__) # test_2 打印函数的名字
print(test_2.__doc__) # 函数的注释

#带参数的装饰器 - 天气干燥，就浇水
def wrapper_out(arg):
    def wrapper(fn):
        def inner(*args,**kwargs):
            if arg:
                print('天气干燥，浇水')
                ret = fn(*args, **kwargs)
            else:
                ret = fn(*args,**kwargs)
            return ret
        return inner
    return wrapper #返回一个装饰器

@wrapper_out(True) #先执行@后面的函数，返回一个解释器 ，再和@组合成语法糖
def shenhua():
    print('女娲捏泥人')
shenhua()

#多个装饰器装饰一个函数
def wrapper_1(fn):
    def inner(*args,**kwargs):
        print('wrapper_1 前')
        ret = fn(*args,**kwargs)
        print('wrapper_1 后')
        return ret
    return inner
def wrapper_2(fn):
    def inner(*args,**kwargs):
        print('wrapper_2 前')
        ret = fn(*args,**kwargs)
        print('wrapper_2 后')
        return ret
    return inner
@wrapper_1 # []
@wrapper_2 # ()
def test():
    print('我是目标函数')
test()
"""
执行结果：
    wrapper_1 前
    wrapper_2 前
    我是目标函数
    wrapper_2 后
    wrapper_1 后
遵循原则：
    [(目标)] 从左向右依次执行
"""
#迭代器 - 将索引和元素一起迭代出来
lst = ['周杰伦','周星驰','吴彦祖','刘德华']
for index,ele in enumerate(lst):
    print(index,ele)
"""
0 周杰伦
1 周星驰
2 吴彦祖
3 刘德华
"""

#编码和解码
s1 = "目标"
UTF_bytes = s1.encode('utf-8') #编码 将汉字编码成字节 一个汉字三个字节
print(UTF_bytes)
s = UTF_bytes.decode('utf-8') #解码 将字节解码成汉字
print(s)

GBK_bytes = s.encode('GBK') #一个汉字两个字节
print(GBK_bytes)