Tujuannya adalah untuk membuat kelas tiruan yang berperilaku seperti resultset db.

Jadi misalnya, jika kueri basis data kembali, menggunakan ekspresi dict {'ab':100, 'cd':200},, maka saya ingin melihat:

>>> dummy.ab
100

Pada awalnya saya pikir mungkin saya bisa melakukannya dengan cara ini:

ks = ['ab', 'cd']
vs = [12, 34]
class C(dict):
    def __init__(self, ks, vs):
        for i, k in enumerate(ks):
            self[k] = vs[i]
            setattr(self, k, property(lambda x: vs[i], self.fn_readyonly))

    def fn_readonly(self, v)
        raise "It is ready only"

if __name__ == "__main__":
    c = C(ks, vs)
    print c.ab

tetapi c.abmengembalikan objek properti sebagai gantinya.

Mengganti setattrsaluran dengan k = property(lambda x: vs[i])tidak ada gunanya sama sekali.

Jadi apa cara yang tepat untuk membuat properti instance saat runtime?

PS Saya mengetahui adanya alternatif yang disajikan dalam Bagaimana __getattribute__metode yang digunakan?

Saya kira saya harus memperluas jawaban ini, sekarang saya lebih tua dan lebih bijaksana dan tahu apa yang terjadi. Lebih baik terlambat daripada tidak sama sekali.

Anda bisa menambahkan properti ke kelas secara dinamis. Tapi itulah intinya: Anda harus menambahkannya ke kelas .

>>> class Foo(object):
...     pass
... 
>>> foo = Foo()
>>> foo.a = 3
>>> Foo.b = property(lambda self: self.a + 1)
>>> foo.b
4

A propertysebenarnya adalah implementasi sederhana dari hal yang disebut deskriptor . Ini adalah objek yang menyediakan penanganan kustom untuk atribut yang diberikan, pada kelas tertentu . Agak seperti cara untuk faktor ifpohon besar keluar __getattribute__.

Ketika saya meminta foo.bdalam contoh di atas, Python melihat bahwa bdidefinisikan pada alat kelas protokol deskriptor -yang hanya berarti itu sebuah objek dengan __get__, __set__atau __delete__metode. Deskriptor mengklaim bertanggung jawab untuk menangani atribut itu, sehingga Python memanggil Foo.b.__get__(foo, Foo), dan nilai pengembalian dikirimkan kembali kepada Anda sebagai nilai atribut. Dalam kasus property, masing-masing metode ini hanya menyebut fget, fsetatau fdelAnda lulus ke propertykonstruktor.

Deskriptor adalah cara Python untuk mengekspos plumbing dari seluruh implementasi OO-nya. Bahkan, ada jenis deskriptor lain yang bahkan lebih umum daripada property.

>>> class Foo(object):
...     def bar(self):
...         pass
... 
>>> Foo().bar
<bound method Foo.bar of <__main__.Foo object at 0x7f2a439d5dd0>>
>>> Foo().bar.__get__
<method-wrapper '__get__' of instancemethod object at 0x7f2a43a8a5a0>

Metode sederhana hanyalah jenis deskriptor lainnya. Itu __get__paku pada instance panggilan sebagai argumen pertama; pada dasarnya, ia melakukan ini:

def __get__(self, instance, owner):
    return functools.partial(self.function, instance)

Ngomong-ngomong, saya menduga inilah sebabnya deskriptor hanya bekerja di kelas: mereka adalah formalisasi dari hal-hal yang memberdayakan kelas di tempat pertama. Mereka bahkan merupakan perkecualian dari aturan: Anda jelas dapat menetapkan deskriptor untuk suatu kelas, dan kelas itu sendiri adalah contoh dari type! Bahkan, mencoba membaca Foo.bpanggilan diam property.__get__; itu hanya idiomatik untuk deskriptor untuk mengembalikan diri ketika diakses sebagai atribut kelas.

Saya pikir itu sangat keren bahwa hampir semua sistem OO Python dapat diekspresikan dalam Python. :)

Oh, dan saya menulis posting blog bertele - tele tentang deskriptor beberapa waktu lalu jika Anda tertarik.

Tujuannya adalah untuk membuat kelas tiruan yang berperilaku seperti resultset db.

Jadi yang Anda inginkan adalah kamus tempat Anda dapat mengeja ['b'] sebagai ab?

Itu mudah:

class atdict(dict):
    __getattr__= dict.__getitem__
    __setattr__= dict.__setitem__
    __delattr__= dict.__delitem__

Tampaknya Anda bisa menyelesaikan masalah ini lebih mudah dengan namedtuple, karena Anda tahu seluruh daftar bidang sebelumnya.

from collections import namedtuple

Foo = namedtuple('Foo', ['bar', 'quux'])

foo = Foo(bar=13, quux=74)
print foo.bar, foo.quux

foo2 = Foo()  # error

Jika Anda benar-benar perlu menulis setter Anda sendiri, Anda harus melakukan metaprogramming di tingkat kelas; property()tidak berfungsi pada instance.

Anda tidak perlu menggunakan properti untuk itu. Timpa saja __setattr__untuk membuatnya hanya baca.

class C(object):
    def __init__(self, keys, values):
        for (key, value) in zip(keys, values):
            self.__dict__[key] = value

    def __setattr__(self, name, value):
        raise Exception("It is read only!")

Tada.

>>> c = C('abc', [1,2,3])
>>> c.a
1
>>> c.b
2
>>> c.c
3
>>> c.d
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'C' object has no attribute 'd'
>>> c.d = 42
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 6, in __setattr__
Exception: It is read only!
>>> c.a = 'blah'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 6, in __setattr__
Exception: It is read only!

Bagaimana cara menambahkan properti ke kelas python secara dinamis?

Katakanlah Anda memiliki objek yang ingin Anda tambahkan properti. Biasanya, saya ingin menggunakan properti ketika saya harus mulai mengelola akses ke atribut dalam kode yang memiliki penggunaan hilir, sehingga saya dapat mempertahankan API yang konsisten. Sekarang saya biasanya akan menambahkannya ke kode sumber di mana objek didefinisikan, tetapi mari kita asumsikan Anda tidak memiliki akses itu, atau Anda harus benar-benar secara dinamis memilih fungsi Anda secara terprogram.

Buat kelas

Menggunakan contoh yang didasarkan pada dokumentasi untukproperty , mari kita buat kelas objek dengan atribut "tersembunyi" dan buat instance darinya:

class C(object):
    '''basic class'''
    _x = None

o = C()

Dengan Python, kami berharap ada satu cara yang jelas dalam melakukan sesuatu. Namun, dalam hal ini, saya akan menunjukkan dua cara: dengan notasi dekorator, dan tanpa. Pertama, tanpa notasi dekorator. Ini mungkin lebih berguna untuk penugasan dinamis dari getter, setter, atau deleter.

Dynamic (alias Monkey Patching)

Mari kita buat beberapa untuk kelas kita:

def getx(self):
    return self._x

def setx(self, value):
    self._x = value

def delx(self):
    del self._x

Dan sekarang kami menetapkan ini ke properti. Perhatikan bahwa kita dapat memilih fungsi kita secara terprogram di sini, menjawab pertanyaan dinamis:

C.x = property(getx, setx, delx, "I'm the 'x' property.")

Dan penggunaan:

>>> o.x = 'foo'
>>> o.x
'foo'
>>> del o.x
>>> print(o.x)
None
>>> help(C.x)
Help on property:

    I'm the 'x' property.

Dekorator

Kita dapat melakukan hal yang sama seperti yang kita lakukan di atas dengan notasi dekorator, tetapi dalam kasus ini, kita harus memberi nama metode semua nama yang sama (dan saya akan merekomendasikan menjaganya tetap sama dengan atribut), sehingga tugas terprogram tidak sepele seperti itu menggunakan metode di atas:

@property
def x(self):
    '''I'm the 'x' property.'''
    return self._x

@x.setter
def x(self, value):
    self._x = value

@x.deleter
def x(self):
    del self._x

Dan tetapkan objek properti dengan setter dan delta yang disediakan untuk kelas:

C.x = x

Dan penggunaan:

>>> help(C.x)
Help on property:

    I'm the 'x' property.

>>> o.x
>>> o.x = 'foo'
>>> o.x
'foo'
>>> del o.x
>>> print(o.x)
None

Saya mengajukan pertanyaan serupa pada posting Stack Overflow ini untuk membuat pabrik kelas yang membuat tipe sederhana. Hasilnya adalah jawaban ini yang memiliki versi pabrik kelas yang berfungsi. Berikut cuplikan jawabannya:

def Struct(*args, **kwargs):
    def init(self, *iargs, **ikwargs):
        for k,v in kwargs.items():
            setattr(self, k, v)
        for i in range(len(iargs)):
            setattr(self, args[i], iargs[i])
        for k,v in ikwargs.items():
            setattr(self, k, v)

    name = kwargs.pop("name", "MyStruct")
    kwargs.update(dict((k, None) for k in args))
    return type(name, (object,), {'__init__': init, '__slots__': kwargs.keys()})

>>> Person = Struct('fname', 'age')
>>> person1 = Person('Kevin', 25)
>>> person2 = Person(age=42, fname='Terry')
>>> person1.age += 10
>>> person2.age -= 10
>>> person1.fname, person1.age, person2.fname, person2.age
('Kevin', 35, 'Terry', 32)
>>>

Anda dapat menggunakan beberapa variasi ini untuk membuat nilai default yang merupakan tujuan Anda (ada juga jawaban dalam pertanyaan yang berhubungan dengan ini).

Tidak yakin apakah saya benar-benar memahami pertanyaan, tetapi Anda dapat mengubah properti instance saat runtime dengan bawaan __dict__kelas Anda:

class C(object):
    def __init__(self, ks, vs):
        self.__dict__ = dict(zip(ks, vs))


if __name__ == "__main__":
    ks = ['ab', 'cd']
    vs = [12, 34]
    c = C(ks, vs)
    print(c.ab) # 12

Bagi mereka yang datang dari mesin pencari, berikut adalah dua hal yang saya cari ketika berbicara tentang properti dinamis :

class Foo:
    def __init__(self):
        # we can dynamically have access to the properties dict using __dict__
        self.__dict__['foo'] = 'bar'

assert Foo().foo == 'bar'


# or we can use __getattr__ and __setattr__ to execute code on set/get
class Bar:
    def __init__(self):
        self._data = {}
    def __getattr__(self, key):
        return self._data[key]
    def __setattr__(self, key, value):
        self._data[key] = value

bar = Bar()
bar.foo = 'bar'
assert bar.foo == 'bar'

__dict__ bagus jika Anda ingin menempatkan properti yang dibuat secara dinamis. __getattr__Adalah baik untuk hanya melakukan sesuatu ketika nilai dibutuhkan, seperti permintaan basis data. Combo set / get bagus untuk menyederhanakan akses ke data yang disimpan di kelas (seperti pada contoh di atas).

Jika Anda hanya menginginkan satu properti dinamis, lihat fungsi properti () bawaan.

Anda tidak dapat menambahkan yang baru property()ke instance saat runtime, karena properti adalah deskriptor data. Sebaliknya, Anda harus secara dinamis membuat kelas baru, atau kelebihan __getattribute__untuk memproses deskriptor data pada instance.

Cara terbaik untuk mencapai adalah dengan mendefinisikan __slots__. Dengan begitu instance Anda tidak dapat memiliki atribut baru.

ks = ['ab', 'cd']
vs = [12, 34]

class C(dict):
    __slots__ = []
    def __init__(self, ks, vs): self.update(zip(ks, vs))
    def __getattr__(self, key): return self[key]

if __name__ == "__main__":
    c = C(ks, vs)
    print c.ab

Cetakan itu 12

    c.ab = 33

Itu memberi: AttributeError: 'C' object has no attribute 'ab'

Contoh lain cara mencapai efek yang diinginkan

class Foo(object):

    _bar = None

    @property
    def bar(self):
        return self._bar

    @bar.setter
    def bar(self, value):
        self._bar = value

    def __init__(self, dyn_property_name):
        setattr(Foo, dyn_property_name, Foo.bar)

Jadi sekarang kita bisa melakukan hal-hal seperti:

>>> foo = Foo('baz')
>>> foo.baz = 5
>>> foo.bar
5
>>> foo.baz
5

Berikut ini solusinya:

• Mengizinkan menentukan nama properti sebagai string , sehingga mereka dapat berasal dari beberapa sumber data luar dan bukan semua yang terdaftar dalam program Anda.
• Menambahkan properti ketika kelas didefinisikan , bukan setiap kali sebuah objek dibuat.

Setelah kelas telah ditentukan, Anda cukup melakukan ini untuk menambahkan properti ke dalamnya secara dinamis:

setattr(SomeClass, 'propertyName', property(getter, setter))

Berikut ini adalah contoh lengkap, diuji dengan Python 3:

#!/usr/bin/env python3

class Foo():
  pass

def get_x(self):
  return 3

def set_x(self, value):
  print("set x on %s to %d" % (self, value))

setattr(Foo, 'x', property(get_x, set_x))

foo1 = Foo()
foo1.x = 12
print(foo1.x)

Anda dapat menggunakan kode berikut untuk memperbarui atribut kelas menggunakan objek kamus:

class ExampleClass():
    def __init__(self, argv):
        for key, val in argv.items():
            self.__dict__[key] = val

if __name__ == '__main__':
    argv = {'intro': 'Hello World!'}
    instance = ExampleClass(argv)
    print instance.intro

Ini sedikit berbeda dari yang diinginkan OP, tetapi saya mengguncang otak saya sampai saya mendapatkan solusi yang berfungsi, jadi saya menempatkan di sini untuk orang berikutnya

Saya membutuhkan cara untuk menentukan setter dinamis dan getter.

class X:
    def __init__(self, a=0, b=0, c=0):
        self.a = a
        self.b = b
        self.c = c

    @classmethod
    def _make_properties(cls, field_name, inc):
        _inc = inc

        def _get_properties(self):
            if not hasattr(self, '_%s_inc' % field_name):
                setattr(self, '_%s_inc' % field_name, _inc)
                inc = _inc
            else:
                inc = getattr(self, '_%s_inc' % field_name)

            return getattr(self, field_name) + inc

        def _set_properties(self, value):
            setattr(self, '_%s_inc' % field_name, value)

        return property(_get_properties, _set_properties)

Saya tahu bidang saya sebelumnya jadi saya akan membuat properti saya. CATATAN: Anda tidak dapat melakukan instance PER ini, properti ini akan ada di kelas !!!

for inc, field in enumerate(['a', 'b', 'c']):
    setattr(X, '%s_summed' % field, X._make_properties(field, inc))

Mari kita uji semuanya sekarang ..

x = X()
assert x.a == 0
assert x.b == 0
assert x.c == 0

assert x.a_summed == 0  # enumerate() set inc to 0 + 0 = 0
assert x.b_summed == 1  # enumerate() set inc to 1 + 0 = 1
assert x.c_summed == 2  # enumerate() set inc to 2 + 0 = 2

# we set the variables to something
x.a = 1
x.b = 2
x.c = 3

assert x.a_summed == 1  # enumerate() set inc to 0 + 1 = 1
assert x.b_summed == 3  # enumerate() set inc to 1 + 2 = 3
assert x.c_summed == 5  # enumerate() set inc to 2 + 3 = 5

# we're changing the inc now
x.a_summed = 1 
x.b_summed = 3 
x.c_summed = 5

assert x.a_summed == 2  # we set inc to 1 + the property was 1 = 2
assert x.b_summed == 5  # we set inc to 3 + the property was 2 = 5
assert x.c_summed == 8  # we set inc to 5 + the property was 3 = 8

Apakah ini membingungkan? Ya, maaf saya tidak bisa memberikan contoh dunia nyata yang berarti. Juga, ini bukan untuk yang berhati ringan.

Ini tampaknya berhasil (tetapi lihat di bawah):

class data(dict,object):
    def __init__(self,*args,**argd):
        dict.__init__(self,*args,**argd)
        self.__dict__.update(self)
    def __setattr__(self,name,value):
        raise AttributeError,"Attribute '%s' of '%s' object cannot be set"%(name,self.__class__.__name__)
    def __delattr__(self,name):
        raise AttributeError,"Attribute '%s' of '%s' object cannot be deleted"%(name,self.__class__.__name__)

Jika Anda membutuhkan perilaku yang lebih kompleks, silakan edit jawaban Anda.

sunting

Berikut ini mungkin akan lebih hemat memori untuk kumpulan data besar:

class data(dict,object):
    def __init__(self,*args,**argd):
        dict.__init__(self,*args,**argd)
    def __getattr__(self,name):
        return self[name]
    def __setattr__(self,name,value):
        raise AttributeError,"Attribute '%s' of '%s' object cannot be set"%(name,self.__class__.__name__)
    def __delattr__(self,name):
        raise AttributeError,"Attribute '%s' of '%s' object cannot be deleted"%(name,self.__class__.__name__)

Untuk menjawab dorongan utama pertanyaan Anda, Anda ingin atribut read-only dari dict sebagai sumber data yang tidak dapat diubah:

Tujuannya adalah untuk membuat kelas tiruan yang berperilaku seperti resultset db.

Jadi misalnya, jika kueri basis data kembali, menggunakan ekspresi dict {'ab':100, 'cd':200},, maka saya akan melihatnya

>>> dummy.ab
100

Saya akan menunjukkan cara menggunakan namedtupledari collectionsmodul untuk mencapai ini:

import collections

data = {'ab':100, 'cd':200}

def maketuple(d):
    '''given a dict, return a namedtuple'''
    Tup = collections.namedtuple('TupName', d.keys()) # iterkeys in Python2
    return Tup(**d)

dummy = maketuple(data)
dummy.ab

kembali 100

class atdict(dict):
  def __init__(self, value, **kwargs):
    super().__init__(**kwargs)
    self.__dict = value

  def __getattr__(self, name):
    for key in self.__dict:
      if type(self.__dict[key]) is list:
        for idx, item in enumerate(self.__dict[key]):
          if type(item) is dict:
            self.__dict[key][idx] = atdict(item)
      if type(self.__dict[key]) is dict:
        self.__dict[key] = atdict(self.__dict[key])
    return self.__dict[name]



d1 = atdict({'a' : {'b': [{'c': 1}, 2]}})

print(d1.a.b[0].c)

Dan hasilnya adalah:

>> 1

Memperluas ide dari kjfletch

# This is my humble contribution, extending the idea to serialize
# data from and to tuples, comparison operations and allowing functions
# as default values.

def Struct(*args, **kwargs):
    FUNCTIONS = (types.BuiltinFunctionType, types.BuiltinMethodType, \
                 types.FunctionType, types.MethodType)
    def init(self, *iargs, **ikwargs):
        """Asume that unamed args are placed in the same order than
        astuple() yields (currently alphabetic order)
        """
        kw = list(self.__slots__)

        # set the unnamed args
        for i in range(len(iargs)):
            k = kw.pop(0)
            setattr(self, k, iargs[i])

        # set the named args
        for k, v in ikwargs.items():
            setattr(self, k, v)
            kw.remove(k)

        # set default values
        for k in kw:
            v = kwargs[k]
            if isinstance(v, FUNCTIONS):
                v = v()
            setattr(self, k, v)

    def astuple(self):
        return tuple([getattr(self, k) for k in self.__slots__])

    def __str__(self):
        data = ['{}={}'.format(k, getattr(self, k)) for k in self.__slots__]
        return '<{}: {}>'.format(self.__class__.__name__, ', '.join(data))

    def __repr__(self):
        return str(self)

    def __eq__(self, other):
        return self.astuple() == other.astuple()

    name = kwargs.pop("__name__", "MyStruct")
    slots = list(args)
    slots.extend(kwargs.keys())
    # set non-specific default values to None
    kwargs.update(dict((k, None) for k in args))

    return type(name, (object,), {
        '__init__': init,
        '__slots__': tuple(slots),
        'astuple': astuple,
        '__str__': __str__,
        '__repr__': __repr__,
        '__eq__': __eq__,
    })


Event = Struct('user', 'cmd', \
               'arg1', 'arg2',  \
               date=time.time, \
               __name__='Event')

aa = Event('pepe', 77)
print(aa)
raw = aa.astuple()

bb = Event(*raw)
print(bb)

if aa == bb:
    print('Are equals')

cc = Event(cmd='foo')
print(cc)

Keluaran:

<Event: user=pepe, cmd=77, arg1=None, arg2=None, date=1550051398.3651814>
<Event: user=pepe, cmd=77, arg1=None, arg2=None, date=1550051398.3651814>
Are equals
<Event: user=None, cmd=foo, arg1=None, arg2=None, date=1550051403.7938335>

Meskipun banyak jawaban diberikan, saya tidak dapat menemukan jawaban yang saya sukai. Saya menemukan solusi saya sendiri yang membuat propertybekerja untuk kasus yang dinamis. Sumber untuk menjawab pertanyaan awal:

#!/usr/local/bin/python3

INITS = { 'ab': 100, 'cd': 200 }

class DP(dict):
  def __init__(self):
    super().__init__()
    for k,v in INITS.items():
        self[k] = v 

def _dict_set(dp, key, value):
  dp[key] = value

for item in INITS.keys():
  setattr(
    DP,
    item,
    lambda key: property(
      lambda self: self[key], lambda self, value: _dict_set(self, key, value)
    )(item)
  )

a = DP()
print(a)  # {'ab': 100, 'cd': 200}
a.ab = 'ab100'
a.cd = False
print(a.ab, a.cd) # ab100 False

Sesuatu yang bekerja untuk saya adalah ini:

class C:
    def __init__(self):
        self._x=None

    def g(self):
        return self._x

    def s(self, x):
        self._x = x

    def d(self):
        del self._x

    def s2(self,x):
        self._x=x+x

    x=property(g,s,d)


c = C()
c.x="a"
print(c.x)

C.x=property(C.g, C.s2)
C.x=C.x.deleter(C.d)
c2 = C()
c2.x="a"
print(c2.x)

Keluaran

a
aa

Saya baru-baru ini mengalami masalah yang sama, solusi yang saya gunakan __getattr__dan __setattr__untuk properti yang ingin saya tangani, semua yang lain diteruskan ke aslinya.

class C(object):
    def __init__(self, properties):
        self.existing = "Still Here"
        self.properties = properties

    def __getattr__(self, name):
        if "properties" in self.__dict__ and name in self.properties:
            return self.properties[name] # Or call a function, etc
        return self.__dict__[name]

    def __setattr__(self, name, value):
        if "properties" in self.__dict__ and name in self.properties:
            self.properties[name] = value
        else:
            self.__dict__[name] = value

if __name__ == "__main__":
    my_properties = {'a':1, 'b':2, 'c':3}
    c = C(my_properties)
    assert c.a == 1
    assert c.existing == "Still Here"
    c.b = 10
    assert c.properties['b'] == 10

Berikut adalah contoh sederhana untuk membuat objek properti secara terprogram.

#!/usr/bin/python3

class Counter:
    def __init__(self):
        cls = self.__class__
        self._count = 0
        cls.count = self.count_ref()

    def count_get(self):
        print(f'count_get: {self._count}')
        return self._count

    def count_set(self, value):
        self._count = value
        print(f'count_set: {self._count}')

    def count_del(self):
        print(f'count_del: {self._count}')

    def count_ref(self):
        cls = self.__class__
        return property(fget=cls.count_get, fset=cls.count_set, fdel=cls.count_del)

counter = Counter()

counter.count
for i in range(5):
    counter.count = i
del counter.count

'''
output
======
count_get: 0
count_set: 0
count_set: 1
count_set: 2
count_set: 3
count_set: 4
count_del: 4
'''

Satu-satunya cara untuk melampirkan properti secara dinamis adalah dengan membuat kelas baru dan instansnya dengan properti baru Anda.

class Holder: p = property(lambda x: vs[i], self.fn_readonly)
setattr(self, k, Holder().p)

Banyak jawaban yang disediakan membutuhkan begitu banyak baris per properti, yaitu / dan / atau - apa yang saya anggap implementasi yang jelek atau membosankan karena diperlukan pengulangan untuk banyak properti, dll. Saya lebih suka terus merebus / menyederhanakannya sampai mereka tidak dapat disederhanakan lagi atau sampai tidak ada gunanya untuk melakukannya.

Singkatnya: dalam pekerjaan yang diselesaikan, jika saya mengulangi 2 baris kode, saya biasanya mengubahnya menjadi fungsi pembantu baris tunggal, dan seterusnya ... Saya menyederhanakan matematika atau argumen aneh seperti (start_x, start_y, end_x, end_y) ke (x, y, w, h) yaitu x, y, x + w, y + h (kadang-kadang membutuhkan min / max atau jika w / h negatif dan implementasinya tidak menyukainya, saya akan kurangi dari x / y dan abs w / h dll.).

Mengesampingkan pengambil / penetapan internal adalah cara yang baik untuk pergi, tetapi masalahnya adalah Anda harus melakukan itu untuk setiap kelas, atau induk kelas ke basis itu ... Ini tidak bekerja untuk saya karena saya lebih suka menjadi bebas memilih anak / orang tua untuk warisan, simpul anak, dll.

Saya telah menciptakan solusi yang menjawab pertanyaan tanpa menggunakan tipe data Dict untuk memasok data karena saya menemukan bahwa menjadi membosankan untuk memasukkan data, dll ...

Solusi saya mengharuskan Anda untuk menambahkan 2 baris tambahan di atas kelas Anda untuk membuat kelas dasar untuk kelas yang ingin Anda tambahkan properti, kemudian 1 baris per dan Anda memiliki opsi untuk menambahkan panggilan balik untuk mengontrol data, memberi tahu Anda ketika data berubah , batasi data yang dapat diatur berdasarkan nilai dan / atau tipe data, dan banyak lagi.

Anda juga memiliki opsi untuk menggunakan _object.x, _object.x = value, _object.GetX (), _object.SetX (value) dan mereka ditangani secara setara.

Selain itu, nilai adalah satu-satunya data non-statis yang ditugaskan ke instance kelas, tetapi properti aktual ditugaskan ke kelas yang berarti hal-hal yang tidak ingin Anda ulangi, tidak perlu diulang ... Anda dapat menetapkan nilai default sehingga pengambil tidak perlu setiap kali, meskipun ada opsi untuk mengganti nilai default default, dan ada opsi lain sehingga pengambil mengembalikan nilai yang disimpan mentah dengan menimpa pengembalian default (catatan: metode ini berarti nilai mentah hanya diberikan ketika nilai diberikan, jika tidak, tidak ada - ketika nilai diatur ulang, maka itu menetapkan Tidak ada, dll.)

Ada banyak fungsi pembantu juga - properti pertama yang ditambahkan menambahkan 2 atau lebih pembantu ke kelas untuk mereferensikan nilai instance ... Mereka adalah ResetAccessors (_key, ..) vararg diulangi (semua dapat diulang menggunakan arg yang disebut pertama) ) dan SetAccessors (_key, _value) dengan opsi lebih banyak ditambahkan ke kelas utama untuk membantu dalam efisiensi - yang direncanakan adalah: cara untuk mengelompokkan pengakses bersama, jadi jika Anda cenderung mengatur ulang beberapa waktu, setiap kali , Anda dapat menetapkannya ke grup dan mengatur ulang grup alih-alih mengulangi tombol yang disebutkan setiap kali, dan lainnya.

Instance / nilai tersimpan mentah disimpan di kelas., kelas. referensi Kelas Accessor yang memegang vars / nilai / fungsi statis untuk properti. _kelas. adalah properti itu sendiri yang dipanggil saat diakses melalui kelas instan selama pengaturan / mendapatkan, dll.

Accessor _class .__ menunjuk ke kelas, tetapi karena itu internal maka perlu ditugaskan di kelas yang mengapa saya memilih untuk menggunakan __Name = AccessorFunc (...) untuk menetapkannya, satu baris per properti dengan banyak opsional argumen untuk digunakan (menggunakan vararg yang dikunci karena lebih mudah dan lebih efisien untuk mengidentifikasi dan memelihara) ...

Saya juga membuat banyak fungsi, seperti yang disebutkan, beberapa di antaranya menggunakan informasi fungsi accessor sehingga tidak perlu dipanggil (karena sedikit merepotkan saat ini - saat ini Anda perlu menggunakan _class. .FunctionName (_class_instance , args) - Saya sempat menggunakan stack / trace untuk mengambil referensi instance untuk mengambil nilai dengan menambahkan fungsi-fungsi yang menjalankan bit maraton ini, atau dengan menambahkan accessors ke objek dan menggunakan self (dinamai ini untuk menunjukkan mereka Sedang untuk instance dan untuk mempertahankan akses ke diri, referensi kelas AccessorFunc, dan informasi lainnya dari dalam definisi fungsi).

Ini tidak cukup dilakukan, tetapi ini adalah pegangan kaki yang fantastis. Catatan: Jika Anda tidak menggunakan __Name = AccessorFunc (...) untuk membuat properti, Anda tidak akan memiliki akses ke kunci __ meskipun saya mendefinisikannya dalam fungsi init. Jika Anda melakukannya, maka tidak ada masalah.

Juga: Perhatikan bahwa Nama dan Kunci berbeda ... Nama itu 'formal', digunakan dalam Pembuatan Nama Fungsi, dan kuncinya adalah untuk penyimpanan data dan akses. yaitu _class.x di mana huruf kecil x adalah kunci, namanya akan menjadi huruf besar X sehingga GetX () adalah fungsi alih-alih Getx () yang terlihat sedikit aneh. ini memungkinkan self.x bekerja dan terlihat sesuai, tetapi juga memungkinkan GetX () dan terlihat sesuai.

Saya memiliki contoh kelas yang diatur dengan kunci / nama yang identik, dan berbeda untuk ditampilkan. banyak fungsi pembantu dibuat untuk menampilkan data (Catatan: Tidak semua ini selesai) sehingga Anda dapat melihat apa yang sedang terjadi.

Daftar fungsi saat ini menggunakan kunci: x, nama: X output sebagai:

Ini bukan daftar lengkap - ada beberapa yang belum membuatnya pada saat posting ...

_instance.SetAccessors( _key, _value [ , _key, _value ] .. )                   Instance Class Helper Function: Allows assigning many keys / values on a single line - useful for initial setup, or to minimize lines.    In short: Calls this.Set<Name>( _value ) for each _key / _value pairing.
_instance.ResetAccessors( _key [ , _key ] .. )                                 Instance Class Helper Function: Allows resetting many key stored values to None on a single line.                                           In short: Calls this.Reset<Name>() for each name provided.


Note: Functions below may list self.Get / Set / Name( _args ) - self is meant as the class instance reference in the cases below - coded as this in AccessorFuncBase Class.

this.GetX( _default_override = None, _ignore_defaults = False )                 GET:            Returns    IF ISSET: STORED_VALUE .. IF IGNORE_DEFAULTS: None  .. IF PROVIDED: DEFAULT_OVERRIDE ELSE: DEFAULT_VALUE       100
this.GetXRaw( )                                                                 RAW:            Returns    STORED_VALUE                                                                                                     100
this.IsXSet( )                                                                  ISSET:          Returns    ( STORED_VALUE != None )                                                                                         True

this.GetXToString( )                                                            GETSTR:         Returns    str( GET )                                                                                                       100
this.GetXLen( _default_override = None, _ignore_defaults = False )              LEN:            Returns    len( GET )                                                                                                       3
this.GetXLenToString( _default_override = None, _ignore_defaults = False )      LENSTR:         Returns    str( len( GET ) )                                                                                                3
this.GetXDefaultValue( )                                                        DEFAULT:        Returns    DEFAULT_VALUE                                                                                                    1111

this.GetXAccessor( )                                                            ACCESSOR:       Returns    ACCESSOR_REF ( self.__<key> )                                                                                    [ AccessorFuncBase ] Key: x : Class ID: 2231452344344 : self ID: 2231448283848        Default: 1111       Allowed Types: {"<class 'int'>": "<class 'type'>", "<class 'float'>": "<class 'type'>"}     Allowed Values: None
this.GetXAllowedTypes( )                                                        ALLOWED_TYPES:  Returns    Allowed Data-Types                                                                                               {"<class 'int'>": "<class 'type'>", "<class 'float'>": "<class 'type'>"}
this.GetXAllowedValues( )                                                       ALLOWED_VALUES: Returns    Allowed Values                                                                                                   None

this.GetXHelpers( )                                                             HELPERS:        Returns    Helper Functions String List - ie what you're reading now...                                                     THESE ROWS OF TEXT
this.GetXKeyOutput( )                                                           Returns information about this Name / Key                                                                                                   ROWS OF TEXT
this.GetXGetterOutput( )                                                        Returns information about this Name / Key                                                                                                   ROWS OF TEXT

this.SetX( _value )                                                             SET:            STORED_VALUE Setter - ie Redirect to __<Key>.Set                                                                            N / A
this.ResetX( )                                                                  RESET:          Resets STORED_VALUE to None                                                                                                 N / A

this.HasXGetterPrefix( )                                                        Returns Whether or Not this key has a Getter Prefix...                                                                                      True
this.GetXGetterPrefix( )                                                        Returns Getter Prefix...                                                                                                                    Get

this.GetXName( )                                                                Returns Accessor Name - Typically Formal / Title-Case                                                                                       X
this.GetXKey( )                                                                 Returns Accessor Property Key - Typically Lower-Case                                                                                        x
this.GetXAccessorKey( )                                                         Returns Accessor Key - This is to access internal functions, and static data...                                                             __x
this.GetXDataKey( )                                                             Returns Accessor Data-Storage Key - This is the location where the class instance value is stored..                                         _x

Beberapa data yang dihasilkan adalah:

Ini untuk kelas baru yang dibuat menggunakan kelas Demo tanpa data yang diberikan selain nama (sehingga bisa menjadi output) yaitu _foo, nama variabel yang saya gunakan ...

_foo         --- MyClass: ---- id( this.__class__ ): 2231452349064 :::: id( this ): 2231448475016

    Key       Getter Value        | Raw Key   Raw / Stored Value       | Get Default Value             Default Value            | Get Allowed Types             Allowed Types                                                              | Get Allowed Values            Allowed Values                                                                                                                                                                                                                   |

    Name:     _foo                | _Name:    _foo                     | __Name.DefaultValue( ):       AccessorFuncDemoClass    | __Name.GetAllowedTypes( )     <class 'str'>                                                              | __Name.GetAllowedValues( )    Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                     |
    x:        1111                | _x:       None                     | __x.DefaultValue( ):          1111                     | __x.GetAllowedTypes( )        (<class 'int'>, <class 'float'>)                                           | __x.GetAllowedValues( )       Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                     |
    y:        2222                | _y:       None                     | __y.DefaultValue( ):          2222                     | __y.GetAllowedTypes( )        (<class 'int'>, <class 'float'>)                                           | __y.GetAllowedValues( )       Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                     |
    z:        3333                | _z:       None                     | __z.DefaultValue( ):          3333                     | __z.GetAllowedTypes( )        (<class 'int'>, <class 'float'>)                                           | __z.GetAllowedValues( )       Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                     |
    Blah:     <class 'int'>       | _Blah:    None                     | __Blah.DefaultValue( ):       <class 'int'>            | __Blah.GetAllowedTypes( )     <class 'str'>                                                              | __Blah.GetAllowedValues( )    Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                     |
    Width:    1                   | _Width:   None                     | __Width.DefaultValue( ):      1                        | __Width.GetAllowedTypes( )    (<class 'int'>, <class 'bool'>)                                            | __Width.GetAllowedValues( )   Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                     |
    Height:   0                   | _Height:  None                     | __Height.DefaultValue( ):     0                        | __Height.GetAllowedTypes( )   <class 'int'>                                                              | __Height.GetAllowedValues( )  (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)                                                                                                                                                                                                   |
    Depth:    2                   | _Depth:   None                     | __Depth.DefaultValue( ):      2                        | __Depth.GetAllowedTypes( )    Saved Value Restricted to Authorized Values ONLY                           | __Depth.GetAllowedValues( )   (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)                                                                                                                                                                                                   |


this.IsNameSet( ):    True      this.GetName( ):     _foo                     this.GetNameRaw( ):    _foo                     this.GetNameDefaultValue( ):    AccessorFuncDemoClass    this.GetNameLen( ):    4    this.HasNameGetterPrefix( ):    <class 'str'>                                this.GetNameGetterPrefix( ):    None
this.IsXSet( ):       False     this.GetX( ):        1111                     this.GetXRaw( ):       None                     this.GetXDefaultValue( ):       1111                     this.GetXLen( ):       4    this.HasXGetterPrefix( ):       (<class 'int'>, <class 'float'>)             this.GetXGetterPrefix( ):       None
this.IsYSet( ):       False     this.GetY( ):        2222                     this.GetYRaw( ):       None                     this.GetYDefaultValue( ):       2222                     this.GetYLen( ):       4    this.HasYGetterPrefix( ):       (<class 'int'>, <class 'float'>)             this.GetYGetterPrefix( ):       None
this.IsZSet( ):       False     this.GetZ( ):        3333                     this.GetZRaw( ):       None                     this.GetZDefaultValue( ):       3333                     this.GetZLen( ):       4    this.HasZGetterPrefix( ):       (<class 'int'>, <class 'float'>)             this.GetZGetterPrefix( ):       None
this.IsBlahSet( ):    False     this.GetBlah( ):     <class 'int'>            this.GetBlahRaw( ):    None                     this.GetBlahDefaultValue( ):    <class 'int'>            this.GetBlahLen( ):    13   this.HasBlahGetterPrefix( ):    <class 'str'>                                this.GetBlahGetterPrefix( ):    None
this.IsWidthSet( ):   False     this.GetWidth( ):    1                        this.GetWidthRaw( ):   None                     this.GetWidthDefaultValue( ):   1                        this.GetWidthLen( ):   1    this.HasWidthGetterPrefix( ):   (<class 'int'>, <class 'bool'>)              this.GetWidthGetterPrefix( ):   None
this.IsDepthSet( ):   False     this.GetDepth( ):    2                        this.GetDepthRaw( ):   None                     this.GetDepthDefaultValue( ):   2                        this.GetDepthLen( ):   1    this.HasDepthGetterPrefix( ):   None                                         this.GetDepthGetterPrefix( ):   (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
this.IsHeightSet( ):  False     this.GetHeight( ):   0                        this.GetHeightRaw( ):  None                     this.GetHeightDefaultValue( ):  0                        this.GetHeightLen( ):  1    this.HasHeightGetterPrefix( ):  <class 'int'>                                this.GetHeightGetterPrefix( ):  (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

Dan ini setelah menetapkan semua properti _foo (kecuali nama) nilai-nilai berikut dalam urutan yang sama: 'string', 1.0, True, 9, 10, False

this.IsNameSet( ):    True      this.GetName( ):     _foo                     this.GetNameRaw( ):    _foo                     this.GetNameDefaultValue( ):    AccessorFuncDemoClass    this.GetNameLen( ):    4    this.HasNameGetterPrefix( ):    <class 'str'>                                this.GetNameGetterPrefix( ):    None
this.IsXSet( ):       True      this.GetX( ):        10                       this.GetXRaw( ):       10                       this.GetXDefaultValue( ):       1111                     this.GetXLen( ):       2    this.HasXGetterPrefix( ):       (<class 'int'>, <class 'float'>)             this.GetXGetterPrefix( ):       None
this.IsYSet( ):       True      this.GetY( ):        10                       this.GetYRaw( ):       10                       this.GetYDefaultValue( ):       2222                     this.GetYLen( ):       2    this.HasYGetterPrefix( ):       (<class 'int'>, <class 'float'>)             this.GetYGetterPrefix( ):       None
this.IsZSet( ):       True      this.GetZ( ):        10                       this.GetZRaw( ):       10                       this.GetZDefaultValue( ):       3333                     this.GetZLen( ):       2    this.HasZGetterPrefix( ):       (<class 'int'>, <class 'float'>)             this.GetZGetterPrefix( ):       None
this.IsBlahSet( ):    True      this.GetBlah( ):     string Blah              this.GetBlahRaw( ):    string Blah              this.GetBlahDefaultValue( ):    <class 'int'>            this.GetBlahLen( ):    11   this.HasBlahGetterPrefix( ):    <class 'str'>                                this.GetBlahGetterPrefix( ):    None
this.IsWidthSet( ):   True      this.GetWidth( ):    False                    this.GetWidthRaw( ):   False                    this.GetWidthDefaultValue( ):   1                        this.GetWidthLen( ):   5    this.HasWidthGetterPrefix( ):   (<class 'int'>, <class 'bool'>)              this.GetWidthGetterPrefix( ):   None
this.IsDepthSet( ):   True      this.GetDepth( ):    9                        this.GetDepthRaw( ):   9                        this.GetDepthDefaultValue( ):   2                        this.GetDepthLen( ):   1    this.HasDepthGetterPrefix( ):   None                                         this.GetDepthGetterPrefix( ):   (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
this.IsHeightSet( ):  True      this.GetHeight( ):   9                        this.GetHeightRaw( ):  9                        this.GetHeightDefaultValue( ):  0                        this.GetHeightLen( ):  1    this.HasHeightGetterPrefix( ):  <class 'int'>                                this.GetHeightGetterPrefix( ):  (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

_foo         --- MyClass: ---- id( this.__class__ ): 2231452349064 :::: id( this ): 2231448475016

    Key       Getter Value        | Raw Key   Raw / Stored Value       | Get Default Value             Default Value            | Get Allowed Types             Allowed Types                                                              | Get Allowed Values            Allowed Values                                                                                                                                                                                                                   |

    Name:     _foo                | _Name:    _foo                     | __Name.DefaultValue( ):       AccessorFuncDemoClass    | __Name.GetAllowedTypes( )     <class 'str'>                                                              | __Name.GetAllowedValues( )    Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                     |
    x:        10                  | _x:       10                       | __x.DefaultValue( ):          1111                     | __x.GetAllowedTypes( )        (<class 'int'>, <class 'float'>)                                           | __x.GetAllowedValues( )       Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                     |
    y:        10                  | _y:       10                       | __y.DefaultValue( ):          2222                     | __y.GetAllowedTypes( )        (<class 'int'>, <class 'float'>)                                           | __y.GetAllowedValues( )       Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                     |
    z:        10                  | _z:       10                       | __z.DefaultValue( ):          3333                     | __z.GetAllowedTypes( )        (<class 'int'>, <class 'float'>)                                           | __z.GetAllowedValues( )       Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                     |
    Blah:     string Blah         | _Blah:    string Blah              | __Blah.DefaultValue( ):       <class 'int'>            | __Blah.GetAllowedTypes( )     <class 'str'>                                                              | __Blah.GetAllowedValues( )    Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                     |
    Width:    False               | _Width:   False                    | __Width.DefaultValue( ):      1                        | __Width.GetAllowedTypes( )    (<class 'int'>, <class 'bool'>)                                            | __Width.GetAllowedValues( )   Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                     |
    Height:   9                   | _Height:  9                        | __Height.DefaultValue( ):     0                        | __Height.GetAllowedTypes( )   <class 'int'>                                                              | __Height.GetAllowedValues( )  (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)                                                                                                                                                                                                   |
    Depth:    9                   | _Depth:   9                        | __Depth.DefaultValue( ):      2                        | __Depth.GetAllowedTypes( )    Saved Value Restricted to Authorized Values ONLY                           | __Depth.GetAllowedValues( )   (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)                                                                                                                                                                                                   |

Perhatikan bahwa karena tipe data atau batasan nilai terbatas, beberapa data tidak ditugaskan - ini adalah desain. Penyetel melarang tipe data atau nilai buruk ditugaskan, bahkan dari ditugaskan sebagai nilai default (kecuali Anda mengabaikan perilaku perlindungan nilai default)

Kode belum diposting di sini karena saya tidak punya ruang setelah contoh dan penjelasan ... Juga karena itu akan berubah.

Harap Catatan: pada saat posting ini, file berantakan - ini akan berubah. Tetapi, jika Anda menjalankannya dalam Sublime Text dan mengkompilasinya, atau menjalankannya dari Python, itu akan mengkompilasi dan mengeluarkan banyak informasi - bagian AccessorDB tidak dilakukan (yang akan digunakan untuk memperbarui Print Getters dan GetKeyOutput helper fungsi bersamaan dengan diubah menjadi fungsi Instance, mungkin dimasukkan ke dalam fungsi tunggal dan diganti namanya - lihat ..)

Berikutnya: Tidak semua yang diperlukan untuk menjalankannya - banyak hal yang dikomentari di bagian bawah adalah untuk informasi lebih lanjut yang digunakan untuk debugging - mungkin tidak ada di sana ketika Anda mengunduhnya. Jika ya, Anda harus dapat menghapus komentar dan mengkompilasi ulang untuk mendapatkan informasi lebih lanjut.

Saya mencari solusi untuk memerlukan MyClassBase: pass, MyClass (MyClassBase): ... - jika Anda tahu solusinya - posting.

Satu-satunya hal yang diperlukan di kelas adalah baris __ - str adalah untuk debugging seperti halnya init - mereka dapat dihapus dari Kelas Demo tetapi Anda perlu mengomentari atau menghapus beberapa baris di bawah ini (_foo / 2/3 ) ..

Kelas String, Dict, dan Util di bagian atas adalah bagian dari perpustakaan Python saya - mereka tidak lengkap. Saya menyalin beberapa hal yang saya butuhkan dari perpustakaan, dan saya membuat beberapa hal baru. Kode lengkap akan ditautkan ke perpustakaan lengkap dan akan memasukkannya bersama dengan memberikan panggilan yang diperbarui dan menghapus kode (sebenarnya, satu-satunya kode yang tersisa adalah Kelas Demo dan pernyataan cetak - sistem AccessorFunc akan dipindahkan ke perpustakaan). ..

Bagian dari file:

##
## MyClass Test AccessorFunc Implementation for Dynamic 1-line Parameters
##
class AccessorFuncDemoClassBase( ):
    pass
class AccessorFuncDemoClass( AccessorFuncDemoClassBase ):
    __Name      = AccessorFuncBase( parent = AccessorFuncDemoClassBase, name = 'Name',      default = 'AccessorFuncDemoClass',  allowed_types = ( TYPE_STRING ),                    allowed_values = VALUE_ANY,                 documentation = 'Name Docs',        getter_prefix = 'Get',  key = 'Name',       allow_erroneous_default = False,    options = { } )
    __x         = AccessorFuncBase( parent = AccessorFuncDemoClassBase, name = 'X',         default = 1111,                     allowed_types = ( TYPE_INTEGER, TYPE_FLOAT ),       allowed_values = VALUE_ANY,                 documentation = 'X Docs',           getter_prefix = 'Get',  key = 'x',          allow_erroneous_default = False,    options = { } )
    __Height    = AccessorFuncBase( parent = AccessorFuncDemoClassBase, name = 'Height',    default = 0,                        allowed_types = TYPE_INTEGER,                       allowed_values = VALUE_SINGLE_DIGITS,       documentation = 'Height Docs',      getter_prefix = 'Get',  key = 'Height',     allow_erroneous_default = False,    options = { } )

Keindahan ini membuatnya sangat mudah untuk membuat kelas baru dengan properti yang ditambahkan secara dinamis dengan AccessorFuncs / callbacks / tipe data / penegakan nilai, dll.

Untuk saat ini, tautannya ada di (Tautan ini harus mencerminkan perubahan pada dokumen.): Https://www.dropbox.com/s/6gzi44i7dh58v61/dynamic_properties_accessorfuncs_and_more.py?dl=0

Juga: Jika Anda tidak menggunakan Teks Sublime, saya merekomendasikannya pada Notepad ++, Atom, Visual Code, dan lainnya karena implementasi threading yang tepat membuatnya jauh, lebih cepat untuk digunakan ... Saya juga bekerja pada kode seperti IDE sistem pemetaan untuk itu - lihat di: https://bitbucket.org/Acecool/acecoolcodemappingsystem/src/master/ (Tambahkan Repo di Package Manager terlebih dahulu, lalu Instal Plugin - ketika versi 1.0.0 siap, saya akan menambahkan ke daftar plugin utama ...)

Saya harap solusi ini membantu ... dan, seperti biasa:

Hanya karena berfungsi, tidak membuatnya benar - Josh 'Acecool' Moser