一 python的参数传递
函数形参
*args 和 **kwargs 传递位置参数和字典参数。
你可以将不定数量的参数传递给一个函数。不定的意思是:预先并不知道, 函数使用者会传递多少个参数给你, 所以在这个场景下使用这两个关键字。其实并不是必须写成 *args 和 **kwargs。 *(星号) 才是必须的. 你也可以写成 *ar 和 k 。而写成 *args 和kwargs 只是一个通俗的命名约定。
python函数传递参数的方式有两种:
位置参数(positional argument)
关键词参数(keyword argument)
*args 与 **kwargs 的区别,两者都是 python 中的可变参数:
*args 表示任何多个无名参数,它本质是一个 tuple
**kwargs 表示关键字参数,它本质上是一个 dict
>>> def fun(*args, **kwargs):
... print('args=', args)
... print('kwargs=', kwargs)
...
>>> fun(1, 2, 3, 4, A='a', B='b', C='c', D='d')
args= (1, 2, 3, 4)
kwargs= {'A': 'a', 'B': 'b', 'C': 'c', 'D': 'd'}
使用*args
>>> def fun(name, *args):
... print('你好:', name)
... for i in args:
... print("你的宠物有:", i)
...
>>> fun("Geek", "dog", "cat")
你好: Geek
你的宠物有: dog
你的宠物有: cat
使用**kwargs
>>> def fun(**kwargs):
... for key, value in kwargs.items():
... print("{0} 喜欢 {1}".format(key, value))
...
>>> fun(Geek="cat", cat="box")
Geek 喜欢 cat
cat 喜欢 box
序列解包
```python
>>> a, b, *c = 0, 1, 2, 3
>>> a
0
>>> b
1
>>> c
[2, 3]
**函数中传递参数:**
```python
>>> def fun(data1, data2, data3):
... print("data1: ", data1)
... print("data2: ", data2)
... print("data3: ", data3)
...
>>> args = ("one", 2, 3)
>>> fun(*args)
data1: one
data2: 2
data3: 3
>>> kwargs = {"data3": "one", "data2": 2, "data1": 3}
>>> fun(**kwargs)
data1: 3
data2: 2
data3: one
参考文章https://blog.csdn.net/yilovexing/article/details/80577510
二装饰器
带参数的装饰器
#被装饰的函数带参数
def get_time3(func):
def wrapper(*args, **kwargs):
startTime = time.time()
func(*args, **kwargs)
endTime = time.time()
processTime = (endTime - startTime) * 1000
print "The function timing is %f ms" %processTime
return wrapper
@ get_time3
def myfunc2(a):
print "start func"
print a
time.sleep(0.8)
print "end func"
将类中私有属性,变成可读取或者set的属性。
-
类装饰器
(1).只要有被类装饰器装饰的对象,类装饰器的 init 函数就会执行(不需要调用)(2).被类装饰器装饰的函数不论被调用几次,init 函数只会执行一次,并且它的执行是被装饰函数声明装饰时就自动执行,不需要手动调用
(3).当被装饰函数存在参数时,从 call 函数传进参数(不必须 *args,但这是一种规范 def call(self,*args,**kwargs))
*args是指字符串,**kwargs是指字典
import os
import inspect
class Registry(object):
def __init__(self, name):
self._name = name
self._module_dict = dict()
def __repr__(self):
format_str = self.__class__.__name__ + '(name={}, items={})'.format(
self._name, list(self._module_dict.keys()))
return format_str
@property
def name(self):
return self._name
@property
def module_dict(self):
return self._module_dict
def get(self, key):
return self._module_dict.get(key, None)
def _register_module(self, module_class):
"""Register a module.
Args:
module (:obj:`nn.Module`): Module to be registered.
"""
if not inspect.isclass(module_class):
raise TypeError('module must be a class, but got {}'.format(
type(module_class)))
module_name = module_class.__name__
if module_name in self._module_dict:
raise KeyError('{} is already registered in {}'.format(
module_name, self.name))
self._module_dict[module_name] = module_class
def register_module(self, cls):
self._register_module(cls)
return cls
DETECTORS = Registry('detector')
#@Registry()包装类需要
@DETECTORS.register_module#包装函数必须执行DETECTORS = Registry('detector')
class TwoStageDetector():
def __init__(self,
backbone,
):
self.backbone=backbone
if __name__ == '__main__':
meth_=TwoStageDetector('ras')
print(meth_)