装饰器,函数的有用信息

一, 装饰器回顾         二, 函数的有用信息(doc,name)         三, 装饰器传参       四, 多个装饰器装饰同一个函数       五, 补充小知识(enumerate 可以直接获取到索引和元素)(encode  编码 ,decode解码)(获取当时时间)

 

一. 通用装饰器的回顾
开闭原则: 对增加功能开放. 对修改代码封闭
装饰器的作用: 在不改变原有代码的基础上给一个函数增加功能
通用装饰器的写法:

def wrapper(fu):
    def inner(*args,**kwargs):
        #在执行目标函数之前要执行的内容
        ret=fu(*args,**kwargs)
        #在执行目标函数之后要执行的内容
        return ret
    return inner
@wrapper
def fu():
    print ()
fu()

#执⾏行行过程:
#1. 程序从上向下, 当执行到@wrapper的时候. 把函数作为参数传递给wrapper函数. 得到
#inner函数. 重新赋值给fu
#2. 当执行到fu的时候. 我们实际上执行的是inner函数. inner函数会先执行目标
#函数之前的代码. 然后再执行你的⽬目标函数. 执行完⽬目标函数最后执行的是目标函数
#之后的代码

 

 

 

二 , 函数的有用信息

被装饰器装饰之后的函数名    __doc__  查看函数的注释文档           __name__   查看函数名

def wrapper(func):
    def inner(*args, **kwargs):
#在执⾏行行⽬目标函数之前要执⾏行行的内容
        ret = func(*args, **kwargs)
#在执⾏行行⽬目标函数之后要执⾏行行的内容
        return ret
    return inner
# @wrapper 相当于 target_func = wrapper(target_func) 语法糖
@wrapper
def target_func():
    print("我是目标函数")
# 调⽤用⽬目标函数
target_func()
print (target_func.__name__)     #函数名.__name__    可以查看函数的名字
print (target_func.__doc__)      #函数名.__doc__     可以查看函数的的文档注释
#结果:我是目标函数   #程序自身运行结果
      inner        #函数名
      None         #以上代码没有文档注释

 

三,装饰器传参

 

def wrapper_out(flag):
    def wrapper(fu):        #fu被装饰的函数
        def inner (*args,**kwargs):     #inner是最终执行的
            if flag==True:
                print ("今天")
                ret=fu(*args,**kwargs)         #fu是被装饰的函数
                print ("咋样")
                return ret
            else:
                ret=fu(*args,**kwargs)      #上面的条件如果为真,就没这里的事了
                return ret
        return inner
    return wrapper

@wrapper_out(True)     # 带参数的装饰器的执行流程: 先执行@后面的函数. 然后再@加上组装成语法糖
def fu():
    print ("晚上")
fu()

@wrapper_out(False)
def fu():

四,多个装饰器装饰同一个函数

def wrapper1(fu):
    def inner(*args,**kwargs):
        print ("今年")
        ret=fu(*args,**kwargs)
        print ("过年")
        return ret
    return inner

def wrapper2(fu):
    def inner(*wargs,**kwargs):
        print("年底")
        ret=fu(*wargs,**kwargs)
        print ("回家")
        return ret
    return inner
@wrapper1
@wrapper2
def xu():
    print ("十二月份")
xu()

"""
结果:今年
      年底
      十二月份
      回家
      过年
      """

"""
执行顺序: 首先@wrapper1装饰起来. 然后获取到一个新函数是wrapper1中的inner. 然后执
行@wrapper2.这个时候. wrapper2装饰的就是wrapper1中的inner了. 所以. 执行顺序就像:
第二层装饰器前(第一层装饰器前(目标)第一层装饰器后)第二层装饰器后. 程序从左到右执行
起来. 就是我们看到的结果        
{[|]}    顺序就像这几层括号一样最外层为第二个装饰器,中括号为第一个装饰器,"|"为目标函数
"""



五,补充小知识
1,ennmerate 可以直接获取到索引和元素

# enumerate 可以直接获取到索引和元素

lst=["大雄","胖虎","静香","多啦a梦"]
for index, element in enumerate(lst): # enumerate 可以直接获取到索引和元素
    print(index, element)
"""
结果:0 大雄
     0 大雄
     1 胖虎
     2 静香
     3 多啦a梦
"""

lst=["大雄","胖虎","静香","多啦a梦"]
for e in enumerate(lst):
    print(e)           #直接打印e,打印出来的则是元组
"""
结果:(0, '大雄')
     (1, '胖虎')
     (2, '静香')
     (3, '多啦a梦')
"""

 

2,encode  编码                 decode解码

#   encode   可以编码和解码
s = "端午放假啦"
bys = s.encode("UTF-8") # 编码
print(bys)
s1 = bys.decode("UTF-8")    # 解码
print(s1)
"""
结果:b'\xe7\xab\xaf\xe5\x8d\x88\xe6\x94\xbe\xe5\x81\x87\xe5\x95\xa6'
     端午放假啦
"""

#转成gbk
s = "端午放假啦"
bys = s.encode("UTF-8") # 编码
gbk_bys = s.encode("gbk")
print (gbk_bys)
#结果:b'\xb6\xcb\xce\xe7\xb7\xc5\xbc\xd9\xc0\xb2'

 

3,获取当时时间

import time
struct_time = time.localtime()
print(time.strftime("%Y-%m-%d %H:%M:%S",struct_time))