遍历构造函数的参数

Question

我经常发现自己编写这样的类构造函数：

class foo:
    def __init__(self, arg1, arg2, arg3):
        self.arg1 = arg1
        self.arg2 = arg2
        self.arg3 = arg3

如果参数（和类属性）的数量变多，这显然会变得很痛苦。我正在寻找最 Pythonic 的方式来遍历构造函数的参数列表并相应地分配属性。我正在使用 Python 2.7，所以理想情况下我正在寻求该版本的帮助。

Answer 1

最 Pythonic 的方式是您已经编写的。如果您愿意要求命名参数，您可以这样做：

class foo:
    def __init__(self, **kwargs):
        vars(self).update(kwargs)

Answer 2

提供的答案依赖于 *vargs 和 **kargs 参数，如果您想限制为具有特定名称的特定参数集，这可能根本不方便：您必须手动进行所有检查。

这是一个装饰器，它将方法提供的参数存储在其绑定实例中，作为具有各自名称的属性。

import inspect
import functools

def store_args(method):
    """Stores provided method args as instance attributes."""
    argspec = inspect.getargspec(method)
    defaults = dict(zip( argspec.args[-len(argspec.defaults):], argspec.defaults ))
    arg_names = argspec.args[1:]
    @functools.wraps(method)
    def wrapper(*positional_args, **keyword_args):
        self = positional_args[0]
        # Get default arg values
        args = defaults.copy()
        # Add provided arg values
        list(map( args.update, ( zip(arg_names, positional_args[1:]), keyword_args.items() ) ))
        # Store values in instance as attributes
        self.__dict__.update(args)
        return method(*positional_args, **keyword_args)

    return wrapper

然后你可以像这样使用它：

class A:
    @store_args
    def __init__(self, a, b, c=3, d=4, e=5):
        pass

a = A(1,2)
print(a.a, a.b, a.c, a.d, a.e)

结果将是 Python3.x 上的 1 2 3 4 5 或 Python2.x 上的 (1, 2, 3, 4, 5)

Answer 3

对于位置参数和关键字参数，您都可以这样做：

class Foo(object):
    def __init__(self, *args, **kwargs):
        for arg in args:
            print arg
        for kwarg in kwargs:
            print kwarg

* 将位置参数打包到一个元组中，** 关键字参数打包到一个字典中：

foo = Foo(1, 2, 3, a=4, b=5, c=6) // args = (1, 2, 3), kwargs = {'a' : 4, ...}

Answer 4

class foo:
    def __init__(self, **kwargs):
        for arg_name, arg_value in kwargs.items():
            setattr(self, arg_name, arg_value)

这需要命名参数：

obj = foo(arg1 = 1, arg2 = 2)

Answer 5

这个怎么样？

class foo:
    def __init__(self, arg1, arg2, arg3):
        for _prop in dir():
            setattr(self, _prop, locals()[_prop])

这使用内置的 python dir 函数来迭代 all 局部变量。 它具有创建无关的自我引用的轻微副作用，但如果你真的想要，你可以过滤它。 此外，如果您要在 dir() 调用之前声明任何其他本地变量，它们也会被添加为构造对象的属性。

Answer 6

对显式变量名进行迭代怎么样？

即

class foo:
    def __init__(self, arg1, arg2, arg3):
        for arg_name in 'arg1,arg2,arg3'.split(','):
            setattr(self, arg_name, locals()[arg_name])

f = foo(5,'six', 7)

结果

print vars(f)

{'arg1': 5, 'arg2': 'six', 'arg3': 7}

我的建议类似于@peepsalot，除了它更明确并且不使用dir()，根据documentation

它的详细行为可能会因版本而异

Answer 7

正如其他人所指出的，在大多数情况下，您可能应该坚持原来的“pythonic”方法。

但是，如果你真的想走完整个九码，这里有一些代码可以巧妙地处理 args，如果需要，可以使用关键字 args，并避免样板重复：

def convert_all_args_to_attribs(self, class_locals):
    class_locals.pop('self')
    if 'kwargs' in class_locals:
        vars(self).update(class_locals.pop('kwargs'))
    vars(self).update(class_locals)

class FooCls:
    def __init__(self, foo, bar):
        convert_all_args_to_attribs(self, locals())

class FooClsWithKeywords:
    def __init__(self, foo, bar, **kwargs):
        convert_all_args_to_attribs(self, locals())

f1 = FooCls(1,2)
f2 = FooClsWithKeywords(3,4, cheese='stilton')


print vars(f1) #{'foo': 1, 'bar': 2}
print vars(f2) #{'cheese': 'stilton', 'foo': 3, 'bar': 4}

Answer 8

对于 python >= 3.7，请查看 @dataclass 类装饰器。 除此之外，它还可以处理您的__init__ 样板编码问题。

来自doc：

@dataclass
class InventoryItem:
    name: str
    unit_price: float
    quantity_on_hand: int = 0

会像这样自动添加__init__：

def __init__(self, name: str, unit_price: float, quantity_on_hand: int=0):
    self.name = name
    self.unit_price = unit_price
    self.quantity_on_hand = quantity_on_hand

Answer 9

*args 是一个序列，因此您可以使用索引访问项目：

def __init__(self, *args):
        if args:       
            self.arg1 = args[0]    
            self.arg2 = args[1]    
            self.arg3 = args[2]    
            ...  

或者你可以遍历所有这些

for arg in args:
   #do assignments