Làm cách nào bạn có thể đặt thuộc tính lớp từ các đối số biến (kwargs) trong python

Giả sử tôi có một lớp với một phương thức khởi tạo (hoặc một hàm khác) nhận một số lượng biến đối số và sau đó đặt chúng làm thuộc tính lớp theo điều kiện.

Tôi có thể đặt chúng theo cách thủ công, nhưng có vẻ như các tham số biến đủ phổ biến trong python nên cần có một thành ngữ chung để thực hiện việc này. Nhưng tôi không chắc làm thế nào để thực hiện điều này một cách linh hoạt.

Tôi có một ví dụ sử dụng eval, nhưng điều đó hầu như không an toàn. Tôi muốn biết cách thích hợp để làm điều này - có thể với lambda?

class Foo:
    def setAllManually(self, a=None, b=None, c=None):
        if a!=None: 
            self.a = a
        if b!=None:
            self.b = b
        if c!=None:
            self.c = c
    def setAllWithEval(self, **kwargs):
        for key in **kwargs:
            if kwargs[param] != None
                eval("self." + key + "=" + kwargs[param])

Bạn có thể cập nhật __dict__thuộc tính (đại diện cho các thuộc tính của lớp ở dạng từ điển) với các đối số từ khóa:

class Bar(object):
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)

sau đó bạn có thể:

>>> bar = Bar(a=1, b=2)
>>> bar.a
1

và với những thứ như:

allowed_keys = {'a', 'b', 'c'}
self.__dict__.update((k, v) for k, v in kwargs.items() if k in allowed_keys)

bạn có thể lọc các khóa trước (sử dụng iteritemsthay vì itemsnếu bạn vẫn đang sử dụng Python 2.x).

Bạn có thể sử dụng setattr()phương pháp:

class Foo:
  def setAllWithKwArgs(self, **kwargs):
    for key, value in kwargs.items():
      setattr(self, key, value)

Có một getattr()phương pháp tương tự để truy xuất các thuộc tính.

Hầu hết các câu trả lời ở đây không đề cập đến một cách tốt để khởi tạo tất cả các thuộc tính được phép thành chỉ một giá trị mặc định. Vì vậy, để thêm vào các câu trả lời do @fqxp và @mmj đưa ra :

class Myclass:

    def __init__(self, **kwargs):
        # all those keys will be initialized as class attributes
        allowed_keys = set(['attr1','attr2','attr3'])
        # initialize all allowed keys to false
        self.__dict__.update((key, False) for key in allowed_keys)
        # and update the given keys by their given values
        self.__dict__.update((key, value) for key, value in kwargs.items() if key in allowed_keys)

Tôi đề xuất một biến thể của câu trả lời fqxp , ngoài các thuộc tính được phép , cho phép bạn đặt các giá trị mặc định cho các thuộc tính:

class Foo():
    def __init__(self, **kwargs):
        # define default attributes
        default_attr = dict(a=0, b=None, c=True)
        # define (additional) allowed attributes with no default value
        more_allowed_attr = ['d','e','f']
        allowed_attr = list(default_attr.keys()) + more_allowed_attr
        default_attr.update(kwargs)
        self.__dict__.update((k,v) for k,v in default_attr.items() if k in allowed_attr)

Đây là mã Python 3.x, đối với Python 2.x, bạn cần ít nhất một điều chỉnh, iteritems()thay cho items().

Tuy nhiên, một biến thể khác dựa trên các câu trả lời xuất sắc của mmj và fqxp . Nếu chúng ta muốn thì sao

1. Tránh mã hóa cứng danh sách các thuộc tính được phép
2. Đặt trực tiếp và rõ ràng các giá trị mặc định cho từng thuộc tính trong hàm tạo
3. Hạn chế kwargs đối với các thuộc tính được xác định trước bởi một trong hai
   • âm thầm từ chối các đối số không hợp lệ hoặc cách khác,
   • nêu ra một lỗi.

Bằng cách "trực tiếp", tôi có nghĩa là tránh một default_attributestừ điển không liên quan .

class Bar(object):
    def __init__(self, **kwargs):

        # Predefine attributes with default values
        self.a = 0
        self.b = 0
        self.A = True
        self.B = True

        # get a list of all predefined values directly from __dict__
        allowed_keys = list(self.__dict__.keys())

        # Update __dict__ but only for keys that have been predefined 
        # (silently ignore others)
        self.__dict__.update((key, value) for key, value in kwargs.items() 
                             if key in allowed_keys)

        # To NOT silently ignore rejected keys
        rejected_keys = set(kwargs.keys()) - set(allowed_keys)
        if rejected_keys:
            raise ValueError("Invalid arguments in constructor:{}".format(rejected_keys))

Không phải là một bước đột phá lớn, nhưng có thể hữu ích cho ai đó ...

CHỈNH SỬA: Nếu lớp của chúng ta sử dụng trình @propertytrang trí để đóng gói các thuộc tính "được bảo vệ" bằng getters và setters và nếu chúng ta muốn có thể đặt các thuộc tính này bằng hàm tạo của mình, chúng ta có thể muốn mở rộng allowed_keysdanh sách với các giá trị từ dir(self), như sau:

allowed_keys = [i for i in dir(self) if "__" not in i and any([j.endswith(i) for j in self.__dict__.keys()])]

Mã trên không bao gồm

• bất kỳ biến ẩn nào từ dir()(loại trừ dựa trên sự hiện diện của "__") và
• bất kỳ phương thức nào dir()mà tên của nó không được tìm thấy ở cuối tên thuộc tính (được bảo vệ hoặc cách khác) từ __dict__.keys()đó, do đó có khả năng chỉ giữ các phương thức được trang trí @property.

Chỉnh sửa này có thể chỉ hợp lệ cho Python 3 trở lên.

class SymbolDict(object):
  def __init__(self, **kwargs):
    for key in kwargs:
      setattr(self, key, kwargs[key])

x = SymbolDict(foo=1, bar='3')
assert x.foo == 1

Tôi gọi là lớp SymbolDictvì về cơ bản nó là một từ điển hoạt động bằng cách sử dụng các ký hiệu thay vì chuỗi. Nói cách khác, bạn làm x.foothay vì x['foo']nhưng dưới vỏ bọc, điều đó thực sự diễn ra tương tự.

Các giải pháp sau vars(self).update(kwargs)hoặcself.__dict__.update(**kwargs) không mạnh mẽ, vì người dùng có thể nhập bất kỳ từ điển nào mà không có thông báo lỗi. Nếu tôi cần kiểm tra xem người dùng chèn chữ ký sau ('a1', 'a2', 'a3', 'a4', 'a5') thì giải pháp không hoạt động. Hơn nữa, người dùng sẽ có thể sử dụng đối tượng bằng cách truyền "tham số vị trí" hoặc "tham số cặp giá trị kay".

Vì vậy, tôi đề xuất giải pháp sau đây bằng cách sử dụng một chiếc đồng hồ đeo tay.

from inspect import Parameter, Signature

class StructMeta(type):
    def __new__(cls, name, bases, dict):
        clsobj = super().__new__(cls, name, bases, dict)
        sig = cls.make_signature(clsobj._fields)
        setattr(clsobj, '__signature__', sig)
        return clsobj

def make_signature(names):
    return Signature(
        Parameter(v, Parameter.POSITIONAL_OR_KEYWORD) for v in names
    )

class Structure(metaclass = StructMeta):
    _fields = []
    def __init__(self, *args, **kwargs):
        bond = self.__signature__.bind(*args, **kwargs)
        for name, val in bond.arguments.items():
            setattr(self, name, val)

if __name__ == 'main':

   class A(Structure):
      _fields = ['a1', 'a2']

   if __name__ == '__main__':
      a = A(a1 = 1, a2 = 2)
      print(vars(a))

      a = A(**{a1: 1, a2: 2})
      print(vars(a))

Họ có thể là một giải pháp tốt hơn nhưng điều tôi nghĩ đến là:

class Test:
    def __init__(self, *args, **kwargs):
        self.args=dict(**kwargs)

    def getkwargs(self):
        print(self.args)

t=Test(a=1, b=2, c="cats")
t.getkwargs()


python Test.py 
{'a': 1, 'c': 'cats', 'b': 2}

cái này dễ nhất qua larsks

class Foo:
    def setAllWithKwArgs(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

ví dụ của tôi:

class Foo:
    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

door = Foo(size='180x70', color='red chestnut', material='oak')
print(door.size) #180x70

Tôi nghi ngờ rằng nó có thể tốt hơn trong hầu hết các trường hợp sử dụng args có tên (để mã tự lập tài liệu tốt hơn) vì vậy nó có thể trông giống như sau:

class Foo:
    def setAll(a=None, b=None, c=None):
        for key, value in (a, b, c):
            if (value != None):
                settattr(self, key, value)