二十四种场景全方位解读Python装饰器的用法

已于 2022-08-18 12:20:49 修改
阅读量559 收藏 11
点赞数
分类专栏： Python 文章标签： python 开发语言
于 2022-07-19 16:54:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/redrose2100/article/details/125875810
版权

文章目录

一、 装饰器是函数

1.1 被装饰对象也是函数

装饰器是函数，被装饰对象是函数时，此时装饰器的作用是给被装饰对象的函数做功能增强功能，思想是面向切面编程思想，即在被装饰对象的函数的之前和之后做一些额外处理，而不破坏被装饰函数原有的功能实现，主要有以下几种情况：

1.1.1 装饰器无参数，被装饰对象无参数

def decorator(func):
    def _decorator():
        print("before func......")
        func()
        print("after func......")
    return _decorator

@decorator
def func():
    print("in func()......")

if __name__=="__main__":
    func()

执行结果为：

before func......
in func()......
after func......

1.1.2 装饰器无参数，被装饰对象有参数

def decorator(func):
    def _decorator(*args,**kwargs):
        print("before {name}......".format(name=func.__name__))
        func(*args,**kwargs)
        print("after {name}......".format(name=func.__name__))
    return _decorator

@decorator
def func1():
    print("in func1()......")

@decorator
def func2(a,b):
    print("in func2()......")
    print("a={a},b={b}".format(a=a,b=b))

@decorator
def func3(a,b,c=10):
    print("in func3()......")
    print("a={a},b={b}".format(a=a, b=b))
    print("c={c}".format(c=c))

if __name__=="__main__":
    func1()
    func2(1,2)
    func3(1,2,c=100)

运行结果为：

before func1......
in func1()......
after func1......
before func2......
in func2()......
a=1,b=2
after func2......
before func3......
in func3()......
a=1,b=2
c=100
after func3......

1.1.3 装饰器有参数，被装饰对象无参数

def wrapper(name):
    def decorator(func):
        def _decorator():
            print("before {name} ,decorator param is {param}".format(name=func.__name__,param=name))
            print("before {name}......".format(name=func.__name__))
            func()
            print("after {name}......".format(name=func.__name__))
        return _decorator
    return decorator

@wrapper(name="hello world")
def func1():
    print("in func1()......")

if __name__=="__main__":
    func1()

运行结果为：

before func1 ,decorator param is hello world
before func1......
in func1()......
after func1......

1.1.4 装饰器有参数，被装饰器对象有参数

def wrapper(name):
    def decorator(func):
        def _decorator(*args,**kwargs):
            print("before {name} ,decorator param is {param}".format(name=func.__name__,param=name))
            print("before {name}......".format(name=func.__name__))
            func(*args,**kwargs)
            print("after {name}......".format(name=func.__name__))
        return _decorator
    return decorator

@wrapper(name="hello world")
def func1():
    print("in func1()......")

@wrapper(name="hello world")
def func2(a, b):
    print("in func2()......")
    print("a={a},b={b}".format(a=a, b=b))

@wrapper(name="hello world")
def func3(a, b, c=10):
    print("in func3()......")
    print("a={a},b={b}".format(a=a, b=b))
    print("c={c}".format(c=c))


if __name__=="__main__":
    func1()
    func2(1,2)
    func3(1,2,c=100)

运行结果如下：

before func1 ,decorator param is hello world
before func1......
in func1()......
after func1......
before func2 ,decorator param is hello world
before func2......
in func2()......
a=1,b=2
after func2......
before func3 ,decorator param is hello world
before func3......
in func3()......
a=1,b=2
c=100
after func3......

1.2 被装饰器对象是类

被装饰器对象为类时，装饰器的作用是类在初始化的时候做功能增强，即可以在类初始化之前或者之后做一些功能增强，所以下面所说的被装饰对象有无参数是针对类的初始化函数__init__有无参数而言的，主要有以下几种情况：

1.2.1 装饰器无参数，被装饰类无参数

def decorator(cls):
    def _decorator():
        print("before class {name} init......".format(name=cls.__name__))
        obj=cls()
        print("after class {name} init......".format(name=cls.__name__))
        return obj
    return _decorator

@decorator
class Test(object):
    def __init__(self):
        print("in class {name} init function......".format(name=Test.__name__))

    def func(self):
        print("in class {name} func()".format(name=Test.__name__))


if __name__=="__main__":
    test=Test()
    
    test.func()

运行结果如下：

before class Test init......
in class _decorator init function......
after class Test init......
in class _decorator func()

1.2.2 装饰器无参数，被装饰类有参数

def decorator(cls):
    def _decorator(*args,**kwargs):
        print("before class {name} init......".format(name=cls.__name__))
        obj=cls(*args,**kwargs)
        print("after class {name} init......".format(name=cls.__name__))
        return obj
    return _decorator

@decorator
class Test(object):
    def __init__(self,a,b=10):
        print("in class {name} init function......".format(name=Test.__name__))
        print("a={a},b={b}".format(a=a,b=b))

    def func(self):
        print("in class {name} func()".format(name=Test.__name__))


if __name__=="__main__":
    test=Test(2,20)
    
    test.func()

执行结果如下：

before class Test init......
in class _decorator init function......
a=2,b=20
after class Test init......
in class _decorator func()

1.2.3 装饰器有参数，被装饰类无参数

def wrapper(name="hello world"):
    def decorator(cls):
        def _decorator():
            print("before class {name} init......".format(name=cls.__name__))
            obj=cls()
            print("after class {name} init......".format(name=cls.__name__))
            return obj
        return _decorator
    return decorator

@wrapper("hello world")
class Test(object):
    def __init__(self):
        print("in class {name} init function......".format(name=Test.__name__))

    def func(self):
        print("in class {name} func()".format(name=Test.__name__))


if __name__=="__main__":
    test=Test()
    
    test.func()

执行结果如下：

before class Test init......
in class _decorator init function......
after class Test init......
in class _decorator func()

1.2.4 装饰器有参数，被装饰类有参数

def wrapper(name="hello world"):
    def decorator(cls):
        def _decorator(*args,**kwargs):
            print("before class {name} init......".format(name=cls.__name__))
            obj=cls(*args,**kwargs)
            print("after class {name} init......".format(name=cls.__name__))
            return obj
        return _decorator
    return decorator

@wrapper("hello world")
class Test(object):
    def __init__(self,a,b=10):
        print("in class {name} init function......".format(name=Test.__name__))
        print("a= {a} b={b}".format(a=a,b=b))

    def func(self):
        print("in class {name} func()".format(name=Test.__name__))


if __name__=="__main__":
    test=Test(2,b=20)
    
    test.func()

运行结果如下：

before class Test init......
in class _decorator init function......
a= 2 b=20
after class Test init......
in class _decorator func()

1.3 被装饰对象是类中的方法

当被装饰对象是类中的方法时，装饰器的作用是对类中的方法进行功能加强，此时需要注意的是装饰器的内层函数需要增加一个self形参

1.3.1 装饰器无参数，被装饰类中的方法无参数

def decorator(func):
    def _decorator(self):
        print("before method {name}......".format(name=func.__name__))
        obj = func(self)
        print("after method {name} ......".format(name=func.__name__))
        return obj

    return _decorator


class Test(object):
    def __init__(self, a=1, b=10):
        self.a = a
        self.b = b

    @decorator
    def func(self):
        print("in class {name} func()".format(name=Test.__name__))
        print("a={a} b={b}".format(a=self.a, b=self.b))


if __name__ == "__main__":
    test = Test()

    test.func()

执行结果如下：

before method func......
in class Test func()
a=1 b=10
after method func ......

1.3.2 装饰器无参数，被装饰类中的方法有参数


def decorator(func):
    def _decorator(self,*args,**kwargs):
        print("before method {name} ......".format(name=func.__name__))
        obj=func(self,*args,**kwargs)
        print("after method {name} ......".format(name=func.__name__))
        return obj
    return _decorator

class Test(object):
    def __init__(self,a=1,b=10):
        self.a=a
        self.b=b
    @decorator
    def func(self,c,d=20):
        print("in class {name} func()".format(name=Test.__name__))
        print("a={a} b={b}".format(a=self.a,b=self.b))
        print("c={c} d={d}".format(c=c,d=d))

if __name__=="__main__":
    test=Test()

    test.func(2,d=20)

执行结果如下：

before method func ......
in class Test func()
a=1 b=10
c=2 d=20
after method func ......

1.3.3 装饰器有参数，被装饰类中的方法无参数

def wrapper(name="hello world"):
    def decorator(func):
        def _decorator(self):
            print("before method {name} ......".format(name=func.__name__))
            print("name = {name}".format(name=name))
            obj=func(self)
            print("after method {name} ......".format(name=func.__name__))
            return obj
        return _decorator
    return decorator

class Test(object):
    def __init__(self,a=1,b=10):
        self.a=a
        self.b=b
    @wrapper(name="Test.func")
    def func(self):
        print("in class {name} func()".format(name=Test.__name__))
        print("a={a} b={b}".format(a=self.a,b=self.b))

if __name__=="__main__":
    test=Test()

    test.func()

执行结果如下：

before method func ......
name = Test.func
in class Test func()
a=1 b=10
after method func ......

1.2.4 装饰器有参数，被装饰类中的方法有参数

def wrapper(name="hello world"):
    def decorator(func):
        def _decorator(self,*args,**kwargs):
            print("before metthod {name} ......".format(name=func.__name__))
            print("name = {name}".format(name=name))
            obj=func(self,*args,**kwargs)
            print("after method {name} ......".format(name=func.__name__))
            return obj
        return _decorator
    return decorator

class Test(object):
    def __init__(self,a=1,b=10):
        self.a=a
        self.b=b
    @wrapper(name="Test.func")
    def func(self,c,d=20):
        print("in class {name} func()".format(name=Test.__name__))
        print("a={a} b={b}".format(a=self.a,b=self.b))
        print("c={c} d={d}".format(c=c,d=d))

if __name__=="__main__":
    test=Test()

    test.func(2,d=20)

执行结果如下：

before metthod func ......
name = Test.func
in class Test func()
a=1 b=10
c=2 d=20
after method func ......

二、 装饰器是类

2.1 被装饰对象是函数

装饰器是类，被装饰对象是函数的时候，是通过装饰器类初始化的时候将被装饰对象函数传递给装饰器类，然后通过自动调用装饰器类中的__call__函数实现对被装饰对象的前后处理，即在这种情况下，只需要在__call__函数中编写在调用被装饰对象前后进行操作的代码即可

2.1.1 装饰器无参数，被装饰对象无参数

class decorator(object):
    def __init__(self,func):
        self.func=func

    def __call__(self):
        print("before func {func}()...".format(func=self.func.__name__))
        result=self.func()
        print("after func {func}()...".format(func=self.func.__name__))
        return result

@decorator
def func():
    print("in func func()...")

if __name__=="__main__":
    func()

执行结果如下：

before func func()...
in func func()...
after func func()...

2.1.2 装饰器无参数，被装饰对象有参数

class decorator(object):
    def __init__(self,func):
        self.func=func

    def __call__(self,*args,**kwargs):
        print("before func {func}()...".format(func=self.func.__name__))
        result=self.func(*args,**kwargs)
        print("after func {func}()...".format(func=self.func.__name__))
        return result

@decorator
def func(a,b=10):
    print("in func func()...")
    print("a= {a} b={b}".format(a=a,b=b))


if __name__=="__main__":
    func(2,b=20)

执行结果如下：

before func func()...
in func func()...
a= 2 b=20
after func func()...

2.1.3 装饰器有参数，被装饰对象无参数


class decorator(object):
    def __init__(self,name="hello world"):
        self.name=name

    def __call__(self,func):
        def wrapper():
            print("before func {func}()...".format(func=func.__name__))
            print("name= {name}".format(name=self.name))
            result=func()
            print("after func {func}()...".format(func=func.__name__))
            return result
        return wrapper

@decorator()
def func1():
    print("in func func2()...")

@decorator("func2_decorator")
def func2():
    print("in func func2()...")

@decorator(name="func3_decorator")
def func3():
    print("in func func3()...")


if __name__=="__main__":
    func1()
    
    func2()
    
    func3()

执行结果如下：

before func func1()...
name= hello world
in func func2()...
after func func1()...
before func func2()...
name= func2_decorator
in func func2()...
after func func2()...
before func func3()...
name= func3_decorator
in func func3()...
after func func3()...

2.1.4 装饰器有参数，被装饰器对象有参数


class decorator(object):
    def __init__(self,name="hello world"):
        self.name=name

    def __call__(self,func):
        def wrapper(*args,**kwargs):
            print("before func {func}()...".format(func=func.__name__))
            print("name= {name}".format(name=self.name))
            result=func(*args,**kwargs)
            print("after func {func}()...".format(func=func.__name__))
            return result
        return wrapper

@decorator()
def func1():
    print("in func func2()...")

@decorator("func2_decorator")
def func2(a):
    print("in func func2()...")
    print("a={a}".format(a=a))

@decorator(name="func3_decorator")
def func3(a,b=10):
    print("in func func3()...")
    print("a={a}, b= {b}".format(a=a,b=b))


if __name__=="__main__":
    func1()
    
    func2(10)
    
    func3(2,b=20)

执行结果如下：

before func func1()...
name= hello world
in func func2()...
after func func1()...
before func func2()...
name= func2_decorator
in func func2()...
a=10
after func func2()...
before func func3()...
name= func3_decorator
in func func3()...
a=2, b= 20
after func func3()...

2.2 被装饰器对象是类

同样，当被装饰对象是类是，装饰器的作用是对被装饰类的初始化方法进行功能加强，而装饰器则是以类的形式定义的

2.2.1 装饰器无参数，被装饰类无参数

class decorator(object):
    def __init__(self,cls):
        self.cls=cls

    def __call__(self):
        print("before init clsss {cls}...".format(cls=self.cls.__name__))
        obj=self.cls()
        print("after init class {cls}...".format(cls=self.cls.__name__))
        return obj

@decorator
class Test():
    def __init__(self):
        print("in Test class __init__ func...")

    def test(self):
        print("in Test class test func...")


if __name__=="__main__":
    t=Test()
    t.test()

执行结果如下：

before init clsss Test...
in Test class __init__ func...
after init class Test...
in Test class test func...

2.2.2 装饰器无参数，被装饰类有参数

class decorator(object):
    def __init__(self,cls):
        self.cls=cls

    def __call__(self,*args,**kwargs):
        print("before init clsss {cls}...".format(cls=self.cls.__name__))
        obj=self.cls(*args,**kwargs)
        print("after init class {cls}...".format(cls=self.cls.__name__))
        return obj

@decorator
class Test():
    def __init__(self,a,b=10):
        print("in Test class __init__ func...")
        print("a={a} b={b}".format(a=a,b=b))

    def test(self):
        print("in Test class test func...")


if __name__=="__main__":
    t=Test(2,b=20)
    t.test()

执行结果如下：

before init clsss Test...
in Test class __init__ func...
a=2 b=20
after init class Test...
in Test class test func...

2.2.3 装饰器有参数，被装饰类无参数

class decorator(object):
    def __init__(self,name="hello world"):
        self.name=name

    def __call__(self,cls):
        def wrapper():
            print("before init class {cls}....".format(cls=cls.__name__))
            obj=cls()
            print("after init class {cls}...".format(cls=cls.__name__))
            return obj
        return wrapper

@decorator(name="Test Class")
class Test():
    def __init__(self):
        print("in Test class __init__ func...")

    def test(self):
        print("in Test class test func...")


if __name__=="__main__":
    t=Test()
    t.test()

执行结果如下：

before init class Test....
in Test class __init__ func...
after init class Test...
in Test class test func...

2.2.4 装饰器有参数，被装饰类有参数

class decorator(object):
    def __init__(self,name="hello world"):
        self.name=name

    def __call__(self,cls):
        def wrapper(*args,**kwargs):
            print("before init class {cls}....".format(cls=cls.__name__))
            obj=cls(*args,**kwargs)
            print("after init class {cls}...".format(cls=cls.__name__))
            return obj
        return wrapper

@decorator(name="Test Class")
class Test():
    def __init__(self,a,b=10):
        print("in Test class __init__ func...")
        print("a={a}, b={b}".format(a=a,b=b))

    def test(self):
        print("in Test class test func...")


if __name__=="__main__":
    t=Test(2,b=20)
    t.test()

执行结果如下：

before init class Test....
in Test class __init__ func...
a=2, b=20
after init class Test...
in Test class test func...

2.3 被装饰对象是类中的方法

2.3.1 装饰器无参数，被装饰类中的方法无参数

class decorator(object):
    def __init__(self,func):
        self.func=func

    def __call__(self):
        print("before func {func}...".format(func=self.func.__name__))
        results=self.func(self)
        print("after func {func}...".format(func=self.func.__name__))
        return results

class Test():
    def __init__(self):
        print("in Test class __init__ func...")

    @decorator
    def test(self):
        print("in Test class test func...")


if __name__=="__main__":
    t=Test()
    t.test()

执行结果如下：

in Test class __init__ func...
before func test...
in Test class test func...
after func test...

2.3.2 装饰器无参数，被装饰类中的方法有参数

class decorator(object):
    def __init__(self,func):
        self.func=func

    def __call__(self,*args,**kwargs):
        print("before func {func}...".format(func=self.func.__name__))
        results=self.func(self,*args,**kwargs)
        print("after func {func}...".format(func=self.func.__name__))
        return results

class Test():
    def __init__(self):
        print("in Test class __init__ func...")

    @decorator
    def test(self,a,b=10):
        print("in Test class test func...")
        print("a={a}  b={b}".format(a=a,b=b))


if __name__=="__main__":
    t=Test()
    t.test(2,b=20)

执行结果如下：

in Test class __init__ func...
before func test...
in Test class test func...
a=2  b=20
after func test...

2.3.3 装饰器有参数，被装饰类中的方法无参数

class decorator(object):
    def __init__(self,name="hello world"):
        self.name=name

    def __call__(self,func):
        def wrapper(self):
            print("before func {func}...".format(func=func.__name__))
            results=func(self)
            print("after func {func}...".format(func=func.__name__))
            return results
        return wrapper

class Test():
    def __init__(self):
        print("in Test class __init__ func...")

    @decorator(name="Test_test")
    def test(self):
        print("in Test class test func...")

if __name__=="__main__":
    t=Test()
    t.test()

执行结果如下：

in Test class __init__ func...
before func test...
in Test class test func...
after func test...

2.3.4 装饰器有参数，被装饰类中的方法有参数

class decorator(object):
    def __init__(self,name="hello world"):
        self.name=name

    def __call__(self,func):
        def wrapper(self,*args,**kwargs):
            print("before func {func}...".format(func=func.__name__))
            results=func(self,*args,**kwargs)
            print("after func {func}...".format(func=func.__name__))
            return results
        return wrapper

class Test():
    def __init__(self):
        print("in Test class __init__ func...")

    @decorator(name="Test_test")
    def test(self,a,b=10):
        print("in Test class test func...")
        print("a={a}, b={b}".format(a=a,b=b))


if __name__=="__main__":
    t=Test()
    t.test(2,b=20)

执行结果如下：

in Test class __init__ func...
before func test...
in Test class test func...
a=2, b=20
after func test...

我正在参与掘金技术社区创作者签约计划招募活动，点击链接报名投稿。

redrose2100
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python装饰器的应用场景代码总结
09-17
主要介绍了Python装饰器的应用场景,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
python装饰器的使用方法
Crazy博客
10-25 4976
装饰器在 python 中使用的频率非常高，它可以在不改动原有函数的基础上对其进行增强功能。下面主要是介绍装饰器的各种用法，并理解其运行过程。装饰器的用法很多，封装成库，给其他人使用也非常的方便，我们需要理解它的运行过程，才能更好的使用它。
Python装饰器的10个应用场景
最新发布
CSDN_224022的博客
04-11 946
装饰器本质上是一个函数，它接受一个函数作为参数并返回一个新函数。通过使用`@`符号，我们可以将装饰器应用于任何函数。
Python常见装饰器使用(实用向)
hanhan的博客
04-09 2098
Python 中有很多好用的装饰器,这里简单介绍8个实用的装饰器辅助代码更加pythonic
python中装饰器的介绍以及使用
weixin_44883789的博客
06-30 2759
装饰器是一种在不改变被装饰对象源代码的情况下，通过扩展或修改其功能或行为的方法。它是 Python 中的一项强大功能，基于函数或类实现。
Python装饰器使用方法详解
Hello Word
01-25 3943
当涉及到处理有返回值的函数时，对于内部函数我们应该使用一个变量将函数的运行结果保存起来，并放在内层函数的return中。装饰器可以改变被装饰函数的行为，或者在调用被装饰函数之前和之后增加额外的操作。装饰器的语法是使用 @ 语法符，在函数定义之前增加装饰器函数的名称。函数中，我们增加了形参的输入，因此，在装饰器中，也要为之做出更改。权限控制：装饰器可以用来实现函数级别的权限控制，只允许特定的用户访问特定的函数。装饰器可以让你在函数或类的定义中添加额外的逻辑，而不更改它们的实现。在代码中，我们建立了一个名为。
python使用装饰器作日志处理的方法
12-31
第一个是不带参数的装饰器用法示例，功能相当于给函数包了层异常处理，第二个是带参数的装饰器用法示例，将日志输出到文件。 ``` #coding=utf8 import traceback import logging from logging.handlers import ...
Python装饰器实现方法及应用场景详解
12-20
装饰器能有助于检查某个人是否被授权去使用一个web应用的端点(endpoint)。它们被大量使用于Flask和Django web框架中。这里是一个例子来使用基于装饰器的授权： from functools import wraps # 最新版python引用是 ...
简单了解python装饰器原理及使用方法
12-23
这篇文章主要介绍了简单了解python装饰器原理及使用方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 如果你接触 Python 有一段时间了的话，想必你对 @ 符号...
Python装饰器使用你可能不知道的几种姿势
01-03
在Python中，装饰器是一种十分强大并且好用的语法，一些重复的代码使用装饰器语法的话能够使代码更容易理解及阅读。 因此在这里简单总结了一下Python中装饰器的几种用法以及需要注意的事情。 一、在装饰器中获取被...
Python装饰器的使用详解
lIujunXHU的博客
02-29 1468
在函数嵌套的前提下，内部函数使用外部函数的变量，并且外部函数返回内部函数我们把这个使用外部函数变量的内部函数称为闭包。
Python 装饰器的用法 一篇细讲（初学角度入手）
DreamingBetter的博客
10-15 1198
2021.10.15 1.前话 因为我也是初学装饰器，所以可以较白话地讲它。 为什么突然学python装饰器？ 发现代码可以更简洁，减少重复代码和重复工作，便于维护。 具体场景： 在写网站的时候，许多视图函数需要做是否登录判断或者是否允许操作判断，这样每个视图函数前面都要重复一遍代码，到后期，维护是个大问题：需要找到所有函数，一个个修改。 2.Python 装饰器 一个类似的场景，比如：我希望在下面这个函数的前面输出before，后面输出after。 def func(): print(
Python之装饰器的使用
fruitless的博客
09-20 146
本节文章讲解了什么是闭包、装饰器的函数和类实现以及几个实用的装饰器例子——包括权限控制、计时和添加日志、系统识别以及redis优先读取，希望能帮助大家快速理解并上手
Python 装饰器用法详解
这家伙很懒，什么都没有留下
11-22 231
Python装饰器是一种非常灵活和强大的工具，可以用于各种场景，如日志记录、性能测试、事务处理、缓存结果和权限验证等。通过使用装饰器，我们可以轻松地将一些通用的逻辑或行为附加到函数或类上，而无需在每个函数或类中重复编写相同的代码。
python: 装饰器的理解
东南飘雪
03-15 284
一、什么是装饰器 python的装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。简单的说装饰器就是一个用来返回函数的函数。 它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、统计、权限校验、参数、结果检查、重试等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关...
Python中的装饰器详解及实际应用
一键难忘的博客
03-09 3274
在Python编程中，装饰器（Decorator）是一种强大而灵活的工具，用于修改函数或方法的行为。它们广泛应用于许多Python框架和库，如Flask、Django等。本文将深入探讨装饰器的概念、使用方法，并提供实际应用的代码示例和详细解析。
六、Python高级——装饰器及使用场景
weixin_46190208的博客
08-08 308
Python高级内容 闭包 1.闭包的基本的定义 ​ 使用外部函数变量的内部函数叫做闭包 2.闭包外部函数 闭包可以保存外部函数内的变量，不会随着外部函数的调用完而销毁，故也会导致外部函数的变量没有及时释放，存在消耗内存的现象发生 3.修改闭包内使用的外部变量 #闭包实例： def set_fun(func): def call_fun(): print("参数值：", func) return call_fun #外层函数的执行返回一个内层函数的引用 fun = set_f
【python教程入门学习】Python装饰器的应用场景
每日分享程序员技巧
01-14 565
本节将结合实际工作中的几个例子，带读者加深对它的理解。 装饰器用于身份认证 首先是最常见的身份认证的应用。这个很容易理解，举个最常见的例子，大家登录微信，需要输入用户名密码，然后点击确认，这样服务器端便会查询你的用户名是否存在、是否和密码匹配等等。如果认证通过，就可以顺利登录；反之，则提示你登录失败。 再比如一些网站，你不登录也可以浏览内容，但如果你想要发布文章或留言，在点击发布时，服务器端便会查询你是否登录。如果没有登录，就不允许这项操作等等。 如下是一个实现身份认证的简单示例： 1. import
Python装饰器的用法
泉小朵的博客
04-17 232
01. 装饰器语法糖 如果你接触 Python 有一段时间了的话，想必你对 @ 符号一定不陌生了，没错 @ 符号就是装饰器的语法糖。 它放在一个函数开始定义的地方，它就像一顶帽子一样戴在这个函数的头上。和这个函数绑定在一起。在我们调用这个函数的时候，第一件事并不是执行这个函数，而是将这个函数做为参数传入它头顶上这顶帽子，这顶帽子我们称之为装饰函数 或 装饰器。 你要问我装饰器可以实现什么功能...
完整详细版Python全套教学课件 第05节 02装饰器.pptx
10-02
Python装饰器是一种用于增强函数或方法功能的技术。在编程中，我们经常会遇到这样的需求：想要在一个函数或方法被调用时，添加一些额外的功能或信息输出。比如，我们有一个简单的加法函数def add(x, y): return x + ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

redrose2100

您的鼓励是我最大的创作动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值