精华内容
下载资源
问答
  • 装饰器函数接收参数
    千次阅读
    2021-03-23 16:59:30

     

    Python 装饰器 获取时间装饰器返回 获取函数参数和函数返回值

    1、获取定时装饰器的总时间值

    2、获取函数参数

    3、获取函数返回值

    4、同时获取前三者数据

     

    示例脚本:

    # -*- coding: utf-8 -*-
    # @Software: PyCharm
    # @File : threadIngTest.py 
    # @Author : Benjamin
    # @Time : 2021/3/22 10:53
    
    import time
    
    def run_time_decorator(func):
        """时间计算装饰器"""
        def warpper(*args, **kwargs):
            start_time = time.time()
            # func(*args, **kwargs)
            end_time = time.time()
            totalTime = end_time - start_time
            print("运行总耗时:", totalTime)
            return totalTime,*args,func(*args, **kwargs)
        return warpper
    
    
    @run_time_decorator
    def test(num,teststr="teststr"):
        print("test",num,teststr)
        return "1111"
    
    
    if __name__ == "__main__":
    
        num = 1
        print(test(num))
    
    

     

    执行过程:

    >HighPerformance/threadIngTest.py
    运行总耗时: 0.0
    test 1 teststr
    (0.0, 1, '1111')

     

    更多相关内容
  • 主要介绍了python通过装饰器检查函数参数数据类型的方法,涉及Python装饰器的使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • 在调用函数的过程中参数是如何被解析先看第一个问题,在python中函数参数的定义主要有四种方式: 1.F(arg1,arg2,…) 这 是最常见的定义方式,一个函数可以定义任意个参数,每个参数间用逗号分割,用这种方式定义的...
  • 本文主要介绍的是Python高阶函数与装饰器函数的相关内容,分享给大家,下面话不多说了,来一起看看详细的介绍吧 高阶函数 1、可以使用函数对象作为参数的函数 2、或可以将函数作为返回值的函数 3、函数对象:定义...
  • 1.题目: 2.代码: 3.结果:

    1.题目:
    在这里插入图片描述
    2.代码:
    在这里插入图片描述
    3.结果:
    在这里插入图片描述

    展开全文
  • 其实,python 中的装饰器本质上就是一个函数,这个函数接收其他的函数作为参数,并将其以一个全新的修改后的函数替换它 关于装饰器的知识是python面试中比较常见的,对于装饰器的理解可以看这篇文章:理解Python中的...

    其实,python 中的装饰器本质上就是一个函数,这个函数接收其他的函数作为参数,并将其以一个全新的修改后的函数替换它
    关于装饰器的知识是python面试中比较常见的,对于装饰器的理解可以看这篇文章:理解Python中的装饰器,理解之后,再手写一遍下面的8种装饰器加深理解以后使用就更轻松多了!

    1.最简单的函数

    def myfunc()
    	print "i am a function"
    
    myfunc()
    

    2.初步了解装饰函数的调用结构

    在函数执行前和执行后分别计时,打印函数运行消耗的时间

    import datetime
    import time
    def out(fun):
    	start = datetime.datetime.now()
    	fun()
    	end = datetime.datetime.now()
    	print (end-start)
    	return fun
    def inner():
        time.sleep(1)
        print ("i am inner func")
    
    myfunc = out
    
    myfunc(inner)
    

    3.尝试引用@语法糖来调用装饰函数

    import datetime,time
    def out(func):
        start =datetime.datetime.now()
        func()
        end = datetime.datetime.now()
        print(end-start)
        return func
    
    @out
    def myfunc():
        time.sleep(1)
        print("zhangkun inner")
    

    4.使用内嵌的包装函数

    使用内嵌包装函数来确保每次新函数都被调用,内嵌包装函数的形参和返回值与原函数相同,装饰函数返回内嵌包装函数对象

    import datetime,time
    
    def out(func):
        def inner():
            start = datetime.datetime.now()
            func()
            end = datetime.datetime.now()
            print(end-start)
            print("out and inner")
        return inner
    
    @out
    def myfunc():
        time.sleep(1)
        print("zhangkun")
    
    myfunc()
    

    5.对带参数的函数使用装饰器

    内嵌包装函数的形参和返回值与原函数相同,装饰函数返回内嵌包装函数对象

    import datetime,time
    
    def out(func):
        def inner(*args):
            start = datetime.datetime.now()
            func(*args)
            end = datetime.datetime.now()
            print(end-start)
            print("out and inner")
        return inner
    
    @out
    def myfunc(*args):
        time.sleep(1)
        print("args is{}".format(args))
    
    myfunc("lalalal")
    

    6.给装饰器参数

    和上一示例相比在外层多了一层包装

    #coding:utf-8
    def outermost(*args):
    	def out(func):
    		print ("装饰器参数{}".format(args))
    		def inner(*args):
    			print("innet start")
    			func(*args)
    			print ("inner end")
    		return inner
    	return out
    
    @outermost(666)
    def myfun(*args):
    	print ("试试装饰器和函数都带参数的情况,被装饰的函数参数{}".format(args))
    
    myfun("zhangkun")
    

    7.带类参数的装饰器

    class locker:
        def __init__(self):
            print("locker.__init__() should be not called")
    
        @staticmethod
        def acquire():
            print("locker.acquire() static method be called")
    
        @staticmethod
        def release():
            print("locker.release() static method be called")
    
    def outermost(cls):
        def out(func):
            def inner():
                cls.acquire()
                func()
                cls.release()
            return inner
        return out
    
    @outermost(locker)
    def myfunc():
        print("myfunc called")
    
    myfunc()
    

    8.对一个函数应用多个装饰器

    class mylocker:
        def __init__(self):
            print("mylocker.__init__() called.")
    
        @staticmethod
        def acquire():
            print("mylocker.acquire() called.")
    
        @staticmethod
        def unlock():
            print("  mylocker.unlock() called.")
    
    class lockerex(mylocker):
        @staticmethod
        def acquire():
            print("lockerex.acquire() called.")
    
        @staticmethod
        def unlock():
            print("  lockerex.unlock() called.")
    
    def lockhelper(cls):
        def _deco(func):
            def __deco2(*args, **kwargs):
                print("before %s called." % func.__name__)
                cls.acquire()
                try:
                    return func(*args, **kwargs)
                finally:
                    cls.unlock()
            return __deco2
        return _deco
    
    class example:
        @lockhelper(mylocker)
        @lockhelper(lockerex)
        def myfunc2(self, a, b):
            print(" myfunc2() called.")
            print(a+b)
    
    a = example()
    a.myfunc2(1,2)
    

    9.作为一个类

    虽然装饰器几乎总是可以用函数实现,但是在某些情况下,使用用户自定义的类可能会更好,如果装饰器需要复杂的参数化或者依赖特定状态,那么这种说法往往是对的
    非参数化装饰器用作类的通用模式如下

    class DerocatorAsClass:
        def __init__(self,funcation):
            self.funcation = funcation
    
        def __call__(self, *args, **kwargs):
            # 调用函数之前,做点什么
            result = self.funcation(*args,**kwargs)
            # 在调用之后做点什么并且返回结果
            return result
    
    展开全文
  • python装饰器函数传参

    2021-09-15 15:31:11
    python装饰器函数传参 装饰器 装饰器是一个返回函数的高阶函数。 装饰器常见用法: 打印日志 def logger(func): def wrapper(*args, **kw): print 'do {}'.format(func.__name__) func(*args, **kw) ...

    python装饰器函数传参 

    装饰器

    装饰器是一个返回函数的高阶函数。

    • 装饰器常见用法:
      打印日志
    def logger(func):
    	def wrapper(*args, **kw):
    		print 'do {}'.format(func.__name__)
    
    		func(*args, **kw)
    
    		print 'finish'
    	return wrapper
    
    @logger
    def add(x,y):
    	print '{} + {} = {}'.format(x,y,x+y)
    
    add(3,5)
    

    在函数执行前,打印一行日志do...;函数执行结束,打印一行日志finish。执行结果如下:

    do add
    3 + 5 = 8
    finish
    

    计算时间

    import time
    
    def timer(func):
    	def wrapper(*args, **kw):
    		t1 = time.time()
    		func(*args,**kw)
    		t2 = time.time()
    
    		cost_time = t2 - t1
    		print 'cost time: {} s'.format(cost_time)
    
    	return wrapper
    
    @timer
    def cost_time(sleep_time):
    	time.sleep(sleep_time)
    
    cost_time(10)
    
    • 带参数的函数装饰器
    def say_hello(country):
    	def wrapper(func):
    		def decorate(*args,**kw):
    			if country == 'en':
    				print 'hello'
    			elif country == 'usa':
    				print 'hi'
    			else:
    				return
    			func(*args,**kw)
    		return decorate
    	return wrapper
    
    @say_hello("usa")
    def usa():
    	print 'i am from usa'
    
    @say_hello("en")
    def en():
    	print 'i am from england'
    
    usa()
    print '----------------------'
    en()
    

    装饰器本身是一个函数,使用两层嵌套传参,执行结果如下:

    hi
    i am from usa
    ----------------------
    hello
    i am from england
    
    • 不带参数的类装饰器
      基于类装饰器的实现,必须实现__call____init__两个内置函数。
      __init__ :接收被装饰函数
      __call__ :实现装饰逻辑
    class logger(object):
    	def __init__(self,func):
    		self.func = func
    
    	def __call__(self,*args,**kwargs):
    		print 'the function {}() is running...'\
    			.format(self.func.__name__)
    		return self.func(*args,**kwargs)
    
    @logger
    def say(something):
    	print 'say {}!'.format(something)
    
    say('hello')
    

    运行结果如下:

    the function say() is running...
    say hello!
    
    • 带参数的类装饰器
      带参数和不带参数的类装饰器有很大的不同。
      __init__ :不再接收被装饰函数,而是接收传入参数
      __call__ :接收被装饰函数,实现装饰逻辑
    class logger(object):
    	def __init__(self,level='INFO'):
    		self.level = level
    
    	def __call__(self,func):
    		def wrapper(*args,**kwargs):
    			print '{level}: the function {func} () is running...'\
    				.format(level=self.level, func=func.__name__)
    
    			func(*args,**kwargs)
    		return wrapper
    
    @logger(level='WARNING')
    def say(something):
    	print 'say {}!'.format(something)
    
    say('hello')
    

    运行结果如下:

    WARNING: the function say () is running...
    say hello!
    

    函数的参数

    • 位置参数
    def power(x, n):
        s = 1
        while n > 0:
            n = n - 1
            s = s * x
        return s
    

    power(x, n)函数有两个参数:xn,这两个参数都是位置参数,调用函数时,传入的两个值按照位置顺序依次赋值给参数xn

    • 默认参数
    def power(x, n=2):
        s = 1
        while n > 0:
            n = n - 1
            s = s * x
        return s
    

    power(x, n)函数有两个参数:xn,如果想在不传入n值时,默认计算x的平方,此时可以将n设为默认值2。

    • 可变参数(*args)
    def function(f_arg, *args):
    	print f_arg, type(f_arg)
    	print args, type(args)
    nums = ['a','b','c']
    function(1,2,*nums)
    

    定义可变参数时,需要在参数前面加一个*号,可变参数的个数是可变的。在函数内部,参数*args接收到的是一个tuple。输出结果如下:

    1 <type 'int'>
    (2, 'a', 'b', 'c') <type 'tuple'>
    
    • 关键字参数(**kwargs)
    def person(name,age,**kwargs):
    	print 'name:',name,'age:',age,'other:',kwargs,type(kwargs)
    
    person('mark',30,city='shanghai')
    

    **kwargs允许将不定长度的键值对,作为参数传递给一个函数,关键字参数在函数内部自动组装为一个dict。输出结果如下:

    name: mark age: 30 other: {'city': 'shanghai'} <type 'dict'>
    
    • 将函数作为参数传递给另一个函数
    def hi():
    	return 'hi friends'
    
    def function(func):
    	print 'just test'
    	print func()
    
    function(hi)
    

    function()函数将hi函数作为参数接收,输出结果如下:

    just test
    hi friends
    

    time模块

    • 获取当前时间
    >>> time.localtime()
    time.struct_time(tm_year=2019, tm_mon=8, tm_mday=21, tm_hour=14, tm_min=31, tm_sec=18, tm_wday=2, tm_yday=233, tm_isdst=0)
    
    • 获取格式化的时间
    >>> time.ctime()
    'Wed Aug 21 14:51:28 2019'
    >>> time.asctime()
    'Wed Aug 21 14:51:34 2019'
    
    • 格式化日期
    >>> time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())
    '2019-08-21 14:35:02'
    >>> time.strftime('%a %b %d %H:%M:%S %Y',time.localtime())
    'Wed Aug 21 14:36:09 2019'
    
    • 计算运行时间
    import time
    start = time.time()
    time.sleep(2)
    end = time.time()
    print end-start
    

    任何程序错误,以及技术疑问或需要解答的,请扫码添加作者VX : 18565453898

    img

    展开全文
  • 最近项目需要增加日志客观性,就在想看能不能通过装饰器方式来获取函数参数和返回值,这样也方便将其写入日志文件,代码如下: import functools import time def get_func_params(func, *args, **kwargs): dict...
  • 北京今天天儿不错,在家写点... 使用系统内置的warps装饰器能够使被装饰的函数保留他原始的信息, 直观一点就是在你print(func.__name__)的时候这个函数的名字仍然是func而不是new_func. """ @warps def new...
  • 装饰器接收被装饰的函数 def wrapper(*args, **kwargs): # 2. wrapper 接收被装饰函数参数,然后将参数传给被装饰的函数: print(f'wrapper() 接收到位置参数{args}, 关键字参数{kwargs}') start_ti = time....
  • 装饰器接收函数作为参数,添加功能后返回一个新函数函数(类),装饰器既可以通过函数去实现,也可以通过类去实现。 Python中通过 @ 使用装饰器 装饰器模式就是通过实现一个装饰器,在不修改原来函数的情况下就...
  • 笔者之前写过一篇简单介绍python函数...本文将介绍装饰器的原理、被装饰函数是如何以参数的形式传入到装饰器函数内部的,以及实现给装饰器函数设定参数参数传递原理。 def decorator(func): def wrapper(*ar...
  • 6 多个装饰器的使用 def make_div(func): """对被装饰的函数的返回值 div标签""" def inner(*args, **kwargs): return "<div>" + func() + "</div>" return inner def make_p(func): """对被装饰...
  • python 类装饰器如何接收request参数

    千次阅读 2018-07-30 10:09:43
    我们在django中想要给类加上装饰器, 又想要用到被装饰函数的request参数 怎么办 ~   我这是用来做权限校验的一个装饰器, 以此为例: class UserAuthentication(object):  def __init__(self, func):  self....
  • (面试笔试题)请设计一个装饰器接收一个int类型的参数number,可以用来装饰任何的函数, 如果函数运行的时间大于number,则打印出函数名和函数的运行时间 import time def get_time(number): # 判断参数类型是否...
  • 1.题目: 2.代码: 补充: isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。 举例:
  • 文章目录1 装饰器的定义2 装饰器的调用方式3 处理的原函数中有参数4 处理的原函数中有关键字参数5 处理的原函数中有返回值6.保留被装饰函数函数名和信息文档7.装饰器的练习练习:创建装饰器,打印被装饰的函数日志...
  • 装饰器只不过是一种函数接收被装饰的可调用对象作为它的唯一参数,然后返回一个可调用对象(就像前面的简单例子) 注意重要的一点,当装饰器被应用到被装饰函数上时,装饰器代码本身就会运行,而不是当被装饰函数...
  • 因为装饰器必须接收一个函数当做参数,所以不可以直接把被装饰函数参数传递给装饰器.装饰器就是一个普通的函数,回顾def my_decorator(func): print("I am an ordinary function") def wrapper(): ...
  • python中的装饰器详解

    2020-12-23 12:26:00
    因为在python里面,函数也是对象,也可以作为参数进行传递.python装饰器本质也是一种特殊函数,它接收参数函数对象,然后动态地函数参数添加额外的功能,而不用修改原有的函数对象.python装饰器传入的参数函数,返回...
  • 题目要求: 代码: 运行结果:
  • python装饰器设置参数

    2021-08-13 16:45:11
    然后就想到既然装饰器本身也是函数,为啥不可以给装饰器也设置上参数,来进一步提高装饰器的复用性呢?于是把思路整理了一下,就有了本文。 装饰器原理回顾 ​ 在我的另一篇关于装饰器的文章中有跟大家提到过,装饰...
  • 题目要求: 代码: 运行结果:
  • 好的,今日博主在设计一个django权限控制器的时候,陷入到了一个问题中,就是如何多角度的给一个函数装饰器传参。问题并不难,也完美解决。所以这里要给大家用 土话 来讲一下装饰器和不同方式传参的方法。一:先...
  • 1.题目: 2.代码:
  • 在不改变原函数函数调用方式的情况下添加函数功能,我们引入了装饰器装饰器是对函数进行修饰...一、装饰器接收参数 import time import functools def log_kind(kind): #传参数的装饰器 def add_log(fun): ...
  • 这段时间一直搞前端模块...注意到在类上添加`@`符号,甚是不解,后来问其它人,才知道这是ES6新增装饰器函数。 它是一种特殊类型的声明,它可以附加到类声明、方法、参数或者属性上。装饰器由`@`符号紧接一个函数名称。
  • 1.题目: 2.代码: 3.输出: 补充: isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。 举例:
  • 20211118155922983.png)] 将调用的函数,绑定到装饰器函数参数里面,比如上面的案例中,outer(fun) ,实际上fun = func1() [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CjcWTXgs-...
  • 装饰器为@required_types(int,float)确保函数接收到的 每一个参数都是int或者float类型; # 2). 当装饰器为@required_types(list)确保函数接收到的每一个 参数都是list类型; # 3). 当装饰器为@required_...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,777
精华内容 13,910
热门标签
关键字:

装饰器函数接收参数