Python入门-面向对象-装饰器

1.变量作用域

全局变量和局部变量

#变量是有作用域的，分为全局变量和局部变量
num = 100 #这是全局变量
def change():
    """
    查看变量作用域
    """
    num = 30 #这是局部变量
    print("change函数内部的，局部变量：",num)
change()
print("全局变量：",num)
"""
change内部的变量： 30
全局变量： 100
"""

全局变量和局部变量互相转换

#global：局部变量转换为全局变量
num = 100
def change():
    """
    修改全局变量内容
    """
    global num
    num = 30
    print("change内部的变量：",num)
change()
print("全局变量：",num)
"""
change内部的变量： 30
全局变量： 30
"""
 
#nonlocal：全局变量转换为局部变量 【只能使用在闭包中】
#全局作用域
x = 0
 
def outter():
 #函数作用域
    x = 1
    def inner():
     #局部作用域
        nonlocal x
        x = 2
        print("inner:",x)
    inner()
    print("outter:", x)
 
f = outter()
print("global:",x)
"""
inner: 2
outter: 1  ---- >2
global: 0
"""
 
#总结：当变量重名的前提下，修改内部函数的局部作用域为函数作用域，nonlocal扩大作用域

2.闭包

def p(count):
    def out(data):
        nonlocal count
        count += 1
        return "第{}次输出数据:{}".format(count,data)
    return out
oa = p(0)
print(oa("tom"))
print(oa("hello"))
print(oa("ok"))
"""
第1次输出数据:tom
第2次输出数据:hello
第3次输出数据:ok
"""

lambda与闭包

#lambda实现闭包
def add(n1):
    return lambda n2: n1 + n2
hello = add(100)
print(hello(200))

3.装饰器

# 方法四：定义一个装饰器接收操作函数，是由python传递
def log_logging(func):
    def wrapper(*args, **kwargs):
        #获取包装函数的名称
        print("方法四：这是装饰器的日志方法，当前函数为：{}".format(func.__name__))
        return func(*args, **kwargs)
    return wrapper # 返回装饰器函数，就是闭包
class Message:
    @log_logging #方法四
    def print_title(self):
        print("方法一：这是print方法直接输出的日志")
        logging()
        log()
 
#方法二：定义一个日志函数
def logging():
    print("方法二：这是使用logging函数，输出的日志！！")
 
#方法三：使用inspet模块方法，获取方法名称
def log():
    import inspect
    res = inspect.stack()[1][3]
    print("方法三：这是使用inspect模块，输出的日志！当前方法为：{}".format(res))
 
if __name__ == '__main__':
    m = Message()
    m.print_title()

完整的日志装饰器

def log_logging(level="info"):
    def wrapper(func):
        def inner(*args, **kwargs):
            #获取包装函数的名称
            print("【logging-{}】的日志，当前函数为：{}".format(level,func.__name__))
            return func(*args, **kwargs)
        return inner # 返回装饰器函数，就是闭包
    return wrapper
class Message:
    @log_logging(level="DEBUG")  # 设置参数
    def print_title(self):
        print("正在使用print——title方法！")
 
if __name__ == '__main__':
    m = Message()
    m.print_title()

基于类定义实现的装饰器

# 使用call方法
 
class logging:
    def __init__(self, level = "INFO"):
        self.__level = level
    def __call__(self, func):
        def inner(*args, **kwargs):
            # 获取包装函数的名称
            print("【logging-{}】的日志，当前函数为：{}".format(self.__level, func.__name__))
            return func(*args, **kwargs)
 
        return inner  # 返回装饰器函数，就是闭包
class Message:
    @logging(level="DEBUG")
    def print_info(self):
        print("正在使用print_info的方法。")
 
if __name__ == '__main__':
    m = Message()
    m.print_info()
"""

【logging-DEBUG】的日志，当前函数为：print_info
正在使用print_info的方法。

"""

wrapt模块

#wrapt减少嵌套层数
#先安装：pip install wrapt
 
import  wrapt
@wrapt.decorator()
def logging(wrapped, insrance, args, kwargs):
    print("【方法一：logging】的日志，当前函数为：{}".format(wrapped.__name__))
 
def log_log(level="INFO"):
    @wrapt.decorator()
    def log_wrapper(wrapped, insrance, args, kwargs):
        print("【方法二：logging-{}】的日志，当前函数为：{}".format(level,wrapped.__name__))
        return wrapped(*args, **kwargs)
    return log_wrapper
 
class Message:
    # @logging                #这是方法一,两个装饰器，不能同时使用
    @log_log(level="DEBUG")   #这是方法二
    def print_info(self):
        print("正在使用print_info的方法")
 
if __name__ == '__main__':
    m = Message()
    print(m.print_info())

【方法二：logging-DEBUG】的日志，当前函数为：print_info
 正在使用print_info的方法
 None

内置装饰器

静态方法

# 静态方法：类中没有提供任何实例属性，python没有提供静态方法，由装饰器实现
# 类中的静态方法，不需要产生实例化对象可以在没有实例化对象的前提下调用，
# 但是类中的普通方法，必须在实例化对象后才可以调用
# 实际开发中，首选还是普通方法，需要实例化，不需要实例化对象的才使用静态方法。
class Message:
    title = "百度一下"
    # def get_info(self):  #普通方法
    @staticmethod   # 使用内部装饰器
    def get_info():  #类中不带self的，静态方法
        Message().hello()  # 类中的普通方法，必须在实例化对象后才可以调用
        return "www.baidu.com"
 
    #普通方法，装饰器无法调用，运行直接报错
    def hello(self):   #类中的,带self的普通方法
        print("【hello方法】这是错误调用！")
 
if __name__ == '__main__':
    print("静态装饰方法：",Message.title, Message.get_info())

类方法classticmethod

# 类方法，是为了弥补，init构造方法的缺陷问题
# 假如init构造方法，定义了俩参数，但是临时需要接收一个复核参数，
class Message:
    @classmethod
    def get_info(info):
        info().hello() #本类对象，调用本类方法
    def hello(self):  #类中的普通方法
        print("这是方法：hello")
 
class Me:
    def __init__(self, title, url):
        self.__title = title
        self.__url = url
    def __str__(self):
        return  "{},{}".format(self.__title, self.__url)
    @classmethod
    def get_instance(cls, info):
        res = info.split("-")
        return cls(res[0], res[1])
 
if __name__ == '__main__':
    print("=======classticmethod静态方法演示：=======")
    Message.get_info()
    print("===========init构造方法使用后演示：=========")
    m = Me("百度", "www.baidu.com")
    print(m)
    print("类方法演示")
    m2 = Me.get_instance("谷歌-www.google.com")
    print(m2)

=======classticmethod静态方法演示：=======
这是方法：hello
===========init构造方法使用后演示：=========
百度,www.baidu.com
类方法演示
谷歌,www.google.com

property装饰器

#优化属性访问
 
class Message:
    def __init__(self, info):
        self.__info = info
    def set_info(self, info):
        self.__info = info
    def get_info(self):
        return self.__info
    def del_info(self):
        del self.__info
 
class Me:
    #属性装饰器，简化操作
    def __init__(self,info):
        self.__info = info
    @property
    def info(self):
        return self.__info
    @info.setter  #修改属性，下面方法名，必须和上面保持一致
    def info(self,info):
        self.__info = info
    @info.deleter
    def info(self):
        del self.__info
 
if __name__ == '__main__':
    m = Message("百度一下")
    print(m.get_info())
    m.set_info("还是谷歌去吧")
    print(m.get_info())
    m.del_info()      #删除info属性
    print("===========property装饰器演示==========")
    me = Me("www.baidu.com")
    print(me.info)  # 直接访问属性
    me.info = "百度一下：www.baidul.com"  #直接修改属性
    print((me.info))
    del me.info     #删除属性

百度一下
还是谷歌去吧
===========property装饰器演示==========
www.baidu.com
百度一下：www.baidul.com