Python'da değişken bağımsız değişkenlerden (kwargs) sınıf niteliklerini nasıl ayarlayabilirsiniz?

Bir yapıcıya (veya başka bir işleve) sahip, değişken sayıda bağımsız değişken alan ve ardından bunları koşullu olarak sınıf öznitelikleri olarak ayarlayan bir sınıfım olduğunu varsayalım.

Bunları manuel olarak ayarlayabilirim, ancak değişken parametrelerin python'da yeterince yaygın olduğu ve bunu yapmak için ortak bir deyim olması gerektiği görülüyor. Ancak bunu dinamik olarak nasıl yapacağımdan emin değilim.

Eval kullanan bir örneğim var ama bu pek güvenli değil. Bunu yapmanın doğru yolunu bilmek istiyorum - belki lambda ile?

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])

Sen güncelleme olabilir __dict__anahtar kelime argümanlarla (bir sözlüğe şeklinde sınıfı özelliklerini gösterir) niteliğini:

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

o zaman yapabilirsin:

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

ve şunun gibi bir şeyle:

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

anahtarları önceden filtreleyebilirsiniz ( hala Python 2.x kullanıyorsanız iteritemsbunun yerine kullanın items).

setattr()Yöntemi kullanabilirsiniz :

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

getattr()Öznitelikleri almak için benzer bir yöntem vardır .

Buradaki yanıtların çoğu, izin verilen tüm öznitelikleri tek bir varsayılan değerle başlatmanın iyi bir yolunu kapsamaz. Öyleyse, @fqxp ve @mmj tarafından verilen cevaplara eklemek için :

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)

İzin verilen özniteliklere ek olarak öznitelikler için varsayılan değerleri ayarlamanıza izin veren fqxp yanıtının bir varyasyonunu öneriyorum :

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)

Bu Python Eğer, en az bir düzenleme gereken 2.x için, Python 3.x kodu iteritems()yerine items().

Yine, mmj ve fqxp'nin mükemmel yanıtlarına dayanan başka bir varyant . Ya istersek

1. İzin verilen özniteliklerin listesini kodlamaktan kaçının
2. Yapıcıdaki her öznitelik için doğrudan ve açıkça varsayılan değerleri ayarlayın
3. Kwarg'ları önceden tanımlanmış özniteliklerle sınırlayın.
   • geçersiz argümanları sessizce reddetmek veya alternatif olarak,
   • bir hata ortaya çıkarmak.

"Doğrudan" derken, gereksiz bir default_attributessözlükten kaçınmayı kastediyorum .

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))

Büyük bir ilerleme değil, ama belki biri için yararlıdır ...

DÜZENLEME: Sınıfımız @propertyalıcılar ve ayarlayıcılarla "korumalı" öznitelikleri kapsüllemek için dekoratörler kullanıyorsa ve bu özellikleri kurucumuzla ayarlayabilmek istiyorsak, allowed_keyslisteyi dir(self)aşağıdaki gibi değerlerle genişletmek isteyebiliriz :

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

Yukarıdaki kod hariçtir

• dan herhangi bir gizli değişken dir()("__" varlığına bağlı olarak hariç tutma) ve
• den dir()bir öznitelik adının sonunda (korumalı veya başka bir şekilde) adı bulunmayan herhangi bir yöntem __dict__.keys(), bu nedenle muhtemelen yalnızca @ özellik dekore edilmiş yöntemler tutulur.

Bu düzenleme muhtemelen sadece Python 3 ve üstü için geçerlidir.

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

Sınıfı aradım SymbolDictçünkü esasen dizeler yerine semboller kullanarak çalışan bir sözlük. Başka bir deyişle, x.fooyerine yaparsınız x['foo']ama örtülerin altında gerçekten aynı şey oluyor.

Aşağıdaki çözümler vars(self).update(kwargs)veya self.__dict__.update(**kwargs)sağlam değildir, çünkü kullanıcı herhangi bir sözlüğe hata mesajı vermeden girebilir. Kullanıcının aşağıdaki imzayı ('a1', 'a2', 'a3', 'a4', 'a5') ekleyip eklemediğini kontrol etmem gerekirse, çözüm çalışmıyor. Ayrıca kullanıcı, "konumsal parametreler" veya "kay-değer çiftleri parametreleri" ni geçerek nesneyi kullanabilmelidir.

Bu yüzden bir metasınıf kullanarak aşağıdaki çözümü öneriyorum.

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))

Daha iyi bir çözüm olabilir ama benim için aklıma gelen şudur:

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}

bu, larsks aracılığıyla en kolay olanıdır

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

benim örneğim:

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

Çoğu durumda adlandırılmış bağımsız değişkenleri kullanmanın (kendi kendini daha iyi belgeleyen kod için) daha iyi olabileceğinden şüpheleniyorum, bu nedenle şuna benzer bir şey olabilir:

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