python装饰器函数传参

淩亂°似流年 2022-09-11 10:14 226阅读 0赞

#  #

# [python装饰器函数传参 ][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)`函数有两个参数：`x`和`n`，这两个参数都是位置参数，调用函数时，传入的两个值按照位置顺序依次赋值给参数`x`和`n`。

*  默认参数

def power(x, n=2):
        s = 1
        while n > 0:
            n = n - 1
            s = s * x
        return s

`power(x, n)`函数有两个参数：`x`和`n`，如果想在不传入`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

#  #

[python_]: https://www.cnblogs.com/mark-zh/p/11384546.html