İki sınıf yöntemleri (classmethod () işlevini kullanarak) alma ve temelde statik bir değişken ne ayarlamak için bir sınıf var. Bunlarla property () işlevini kullanmaya çalıştım, ancak bir hataya neden oluyor. Hatayı yorumlayıcıda aşağıdakilerle yeniden oluşturabildim:

class Foo(object):
    _var = 5
    @classmethod
    def getvar(cls):
        return cls._var
    @classmethod
    def setvar(cls, value):
        cls._var = value
    var = property(getvar, setvar)

Sınıf yöntemlerini gösterebilirim, ancak özellik olarak çalışmazlar:

>>> f = Foo()
>>> f.getvar()
5
>>> f.setvar(4)
>>> f.getvar()
4
>>> f.var
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: 'classmethod' object is not callable
>>> f.var=5
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: 'classmethod' object is not callable

Özellik () işlevini, sınıf yöntemiyle dekore edilmiş işlevlerle kullanmak mümkün müdür?

Sınıfta bir özellik oluşturulur, ancak bir örneği etkiler. Bir classmethod özelliği istiyorsanız, özelliği metaclass üzerinde oluşturun.

>>> class foo(object):
...     _var = 5
...     class __metaclass__(type):  # Python 2 syntax for metaclasses
...         pass
...     @classmethod
...     def getvar(cls):
...         return cls._var
...     @classmethod
...     def setvar(cls, value):
...         cls._var = value
...     
>>> foo.__metaclass__.var = property(foo.getvar.im_func, foo.setvar.im_func)
>>> foo.var
5
>>> foo.var = 3
>>> foo.var
3

Ama yine de bir metasınıf kullandığınız için, sınıf yöntemlerini oraya taşırsanız daha iyi okunur.

>>> class foo(object):
...     _var = 5
...     class __metaclass__(type):  # Python 2 syntax for metaclasses
...         @property
...         def var(cls):
...             return cls._var
...         @var.setter
...         def var(cls, value):
...             cls._var = value
... 
>>> foo.var
5
>>> foo.var = 3
>>> foo.var
3

veya Python 3'ün metaclass=...sözdizimini ve foosınıf gövdesi dışında tanımlanan metasınıfı ve başlangıç ​​değerini ayarlamaktan sorumlu metasınıfı kullanarak _var:

>>> class foo_meta(type):
...     def __init__(cls, *args, **kwargs):
...         cls._var = 5
...     @property
...     def var(cls):
...         return cls._var
...     @var.setter
...     def var(cls, value):
...         cls._var = value
...
>>> class foo(metaclass=foo_meta):
...     pass
...
>>> foo.var
5
>>> foo.var = 3
>>> foo.var
3

Python 2.2 sürüm notlarını okurken aşağıdakileri buldum.

Özelliğe örnek özelliği (C () .x) yerine sınıf özniteliği (Cx) olarak erişildiğinde get özelliğinin [bir özelliğin] yöntemi çağrılmaz. Bir sınıf özniteliği olarak kullanıldığında özellikler için __get__ işlemini geçersiz kılmak istiyorsanız, __get__ yöntemini genişletmek için özelliği alt sınıf özelliğinin alt sınıfına getirebilirsiniz veya yeni bir oluşturarak sıfırdan bir tanımlayıcı türü tanımlayabilirsiniz __get__, __set__ ve __delete__ yöntemlerini tanımlayan bir stil sınıfı.

NOT: Aşağıdaki yöntem ayarlayıcılar için geçerli değildir, yalnızca alıcılar için geçerlidir.

Bu nedenle, belirtilen çözümün bir mülkiyet alt sınıfı olarak bir ClassProperty oluşturmak olduğuna inanıyorum.

class ClassProperty(property):
    def __get__(self, cls, owner):
        return self.fget.__get__(None, owner)()

class foo(object):
    _var=5
    def getvar(cls):
        return cls._var
    getvar=classmethod(getvar)
    def setvar(cls,value):
        cls._var=value
    setvar=classmethod(setvar)
    var=ClassProperty(getvar,setvar)

assert foo.getvar() == 5
foo.setvar(4)
assert foo.getvar() == 4
assert foo.var == 4
foo.var = 3
assert foo.var == 3

Ancak ayarlayıcılar aslında çalışmaz:

foo.var = 4
assert foo.var == foo._var # raises AssertionError

foo._var değişmezse, mülkün üzerine yeni bir değer yazmanız yeterlidir.

ClassPropertyDekoratör olarak da kullanabilirsiniz :

class foo(object):
    _var = 5

    @ClassProperty
    @classmethod
    def var(cls):
        return cls._var

    @var.setter
    @classmethod
    def var(cls, value):
        cls._var = value

assert foo.var == 5

Umarım bu ölü-basit salt okunur @classpropertydekoratör, sınıf özellikleri arayan birine yardımcı olur.

class classproperty(object):

    def __init__(self, fget):
        self.fget = fget

    def __get__(self, owner_self, owner_cls):
        return self.fget(owner_cls)

class C(object):

    @classproperty
    def x(cls):
        return 1

assert C.x == 1
assert C().x == 1

Özellik () işlevini, sınıf yöntemiyle dekore edilmiş işlevlerle kullanmak mümkün müdür?

Hayır.

Ancak, bir sınıf yöntemi, o sınıfın örneklerinden erişilebilen bir sınıfa bağlı bir yöntemdir (kısmi bir işlev).

Örnek sınıfın bir işlevi olduğundan ve sınıfı örnekten türetebildiğinizden, bir sınıf özelliğinden istediğiniz her türlü davranışı aşağıdakilerle elde edebilirsiniz property:

class Example(object):
    _class_property = None
    @property
    def class_property(self):
        return self._class_property
    @class_property.setter
    def class_property(self, value):
        type(self)._class_property = value
    @class_property.deleter
    def class_property(self):
        del type(self)._class_property

Bu kod test etmek için kullanılabilir - herhangi bir hata oluşturmadan geçmelidir:

ex1 = Example()
ex2 = Example()
ex1.class_property = None
ex2.class_property = 'Example'
assert ex1.class_property is ex2.class_property
del ex2.class_property
assert not hasattr(ex1, 'class_property')

Ve hiçbir zaman metasınıflara ihtiyacımız olmadığını unutmayın - ve yine de sınıflarının örnekleri aracılığıyla bir metastata doğrudan erişemezsiniz.

@classpropertydekoratör yazmak

Aslında classpropertyalt sınıflama ile sadece birkaç kod satırında bir dekoratör oluşturabilirsiniz property(C'de uygulanır, ancak burada eşdeğer Python'u görebilirsiniz ):

class classproperty(property):
    def __get__(self, obj, objtype=None):
        return super(classproperty, self).__get__(objtype)
    def __set__(self, obj, value):
        super(classproperty, self).__set__(type(obj), value)
    def __delete__(self, obj):
        super(classproperty, self).__delete__(type(obj))

Sonra dekoratöre, özellikle birleştirilmiş bir sınıf yöntemi gibi davranın:

class Foo(object):
    _bar = 5
    @classproperty
    def bar(cls):
        """this is the bar attribute - each subclass of Foo gets its own.
        Lookups should follow the method resolution order.
        """
        return cls._bar
    @bar.setter
    def bar(cls, value):
        cls._bar = value
    @bar.deleter
    def bar(cls):
        del cls._bar

Ve bu kod hatasız çalışmalıdır:

def main():
    f = Foo()
    print(f.bar)
    f.bar = 4
    print(f.bar)
    del f.bar
    try:
        f.bar
    except AttributeError:
        pass
    else:
        raise RuntimeError('f.bar must have worked - inconceivable!')
    help(f)  # includes the Foo.bar help.
    f.bar = 5

    class Bar(Foo):
        "a subclass of Foo, nothing more"
    help(Bar) # includes the Foo.bar help!
    b = Bar()
    b.bar = 'baz'
    print(b.bar) # prints baz
    del b.bar
    print(b.bar) # prints 5 - looked up from Foo!

    
if __name__ == '__main__':
    main()

Ama bunun ne kadar iyi tavsiye edileceğinden emin değilim. Eski bir posta listesi makalesi , çalışmaması gerektiğini gösteriyor.

Özelliğin sınıf üzerinde çalışmasını sağlama:

Yukarıdakilerin dezavantajı, "sınıf özelliğine" sınıftan erişilememesidir, çünkü sınıftan veri tanımlayıcısının üzerine yazacaktır __dict__.

Ancak, bunu metasınıfta tanımlanan bir özellik ile geçersiz kılabiliriz __dict__. Örneğin:

class MetaWithFooClassProperty(type):
    @property
    def foo(cls):
        """The foo property is a function of the class -
        in this case, the trivial case of the identity function.
        """
        return cls

Ve sonra metasınıfın bir sınıf örneği, önceki bölümlerde zaten gösterilen prensibi kullanarak sınıfın özelliğine erişen bir özelliğe sahip olabilir:

class FooClassProperty(metaclass=MetaWithFooClassProperty):
    @property
    def foo(self):
        """access the class's property"""
        return type(self).foo

Ve şimdi ikisini de görüyoruz

>>> FooClassProperty().foo
<class '__main__.FooClassProperty'>

ve sınıf

>>> FooClassProperty.foo
<class '__main__.FooClassProperty'>

class özelliğine erişebilir.

Python 3!

Eski bir soru, çok sayıda görüş, tek bir gerçek Python 3 yoluna muhtaç.

Neyse ki, metaclasskwarg ile kolay :

class FooProperties(type):

    @property
    def var(cls):
        return cls._var

class Foo(object, metaclass=FooProperties):
    _var = 'FOO!'

Sonra, >>> Foo.var

'FOO!'

Bu "sınıf özellik" sisteminin Python'da çalışmasının makul bir yolu yoktur.

İşte onu çalıştırmanın mantıksız bir yolu. Artan miktarda metaclass büyüsü ile kesinlikle daha sorunsuz hale getirebilirsiniz.

class ClassProperty(object):
    def __init__(self, getter, setter):
        self.getter = getter
        self.setter = setter
    def __get__(self, cls, owner):
        return getattr(cls, self.getter)()
    def __set__(self, cls, value):
        getattr(cls, self.setter)(value)

class MetaFoo(type):
    var = ClassProperty('getvar', 'setvar')

class Foo(object):
    __metaclass__ = MetaFoo
    _var = 5
    @classmethod
    def getvar(cls):
        print "Getting var =", cls._var
        return cls._var
    @classmethod
    def setvar(cls, value):
        print "Setting var =", value
        cls._var = value

x = Foo.var
print "Foo.var = ", x
Foo.var = 42
x = Foo.var
print "Foo.var = ", x

Sorunun düğümü Python'un "tanımlayıcılar" olarak adlandırdığı özelliklerdir. Bu tür bir meta programlamanın nasıl çalıştığını açıklamanın kısa ve kolay bir yolu yoktur, bu yüzden sizi tanımlayıcı nasıl göstereceğim .

Bu tür şeyleri ancak oldukça gelişmiş bir çerçeve uyguluyorsanız anlamanız gerekir. Saydam bir nesne kalıcılığı veya RPC sistemi veya bir tür etki alanına özgü dil gibi.

Ancak, önceki bir cevaba yapılan bir yorumda,

bir sınıfın tüm örnekleri tarafından görülen ve bu sınıf yöntemlerinin çağrıldığı kapsamda sınıfın tüm örnekleri için başvuru bulunmayan bir niteliği değiştirmesi gerekir.

Bana öyle geliyor ki, gerçekten istediğiniz bir Observer tasarım modeli.

Sınıf özelliğine örnek bir nesne aracılığıyla erişmek istiyorsanız, yalnızca meta sınıfta ayarlamak yardımcı olmaz, bu durumda nesneye de normal bir özellik yüklemeniz gerekir (class özelliğine gönderilir). Aşağıdakilerin biraz daha açık olduğunu düşünüyorum:

#!/usr/bin/python

class classproperty(property):
    def __get__(self, obj, type_):
        return self.fget.__get__(None, type_)()

    def __set__(self, obj, value):
        cls = type(obj)
        return self.fset.__get__(None, cls)(value)

class A (object):

    _foo = 1

    @classproperty
    @classmethod
    def foo(cls):
        return cls._foo

    @foo.setter
    @classmethod
    def foo(cls, value):
        cls.foo = value

a = A()

print a.foo

b = A()

print b.foo

b.foo = 5

print a.foo

A.foo = 10

print b.foo

print A.foo

Yarım bir çözüm, __set__ sınıfta hala çalışmıyor. Çözüm, hem özelliği hem de statik yöntemi uygulayan özel özellik sınıfıdır

class ClassProperty(object):
    def __init__(self, fget, fset):
        self.fget = fget
        self.fset = fset

    def __get__(self, instance, owner):
        return self.fget()

    def __set__(self, instance, value):
        self.fset(value)

class Foo(object):
    _bar = 1
    def get_bar():
        print 'getting'
        return Foo._bar

    def set_bar(value):
        print 'setting'
        Foo._bar = value

    bar = ClassProperty(get_bar, set_bar)

f = Foo()
#__get__ works
f.bar
Foo.bar

f.bar = 2
Foo.bar = 3 #__set__ does not

Çünkü bir sınıfın tüm örnekleri tarafından görülen ve bu sınıf yöntemlerinin çağrıldığı kapsamda sınıfın tüm örneklerine başvuru olmayan bir özniteliği değiştirmem gerekiyor.

Sınıfın en az bir örneğine erişiminiz var mı? Bunu yapmanın bir yolunu düşünebilirim:

class MyClass (object):
    __var = None

    def _set_var (self, value):
        type (self).__var = value

    def _get_var (self):
        return self.__var

    var = property (_get_var, _set_var)

a = MyClass ()
b = MyClass ()
a.var = "foo"
print b.var

Bunu bir deneyin, mevcut kodu çok fazla değiştirmek / eklemek zorunda kalmadan işi yapar.

>>> class foo(object):
...     _var = 5
...     def getvar(cls):
...         return cls._var
...     getvar = classmethod(getvar)
...     def setvar(cls, value):
...         cls._var = value
...     setvar = classmethod(setvar)
...     var = property(lambda self: self.getvar(), lambda self, val: self.setvar(val))
...
>>> f = foo()
>>> f.var
5
>>> f.var = 3
>>> f.var
3

propertyİşlevi, iki ihtiyacı callableargümanlar. Onlara lambda sarmalayıcıları verin (ilk argüman olarak örneği geçer) ve her şey yolunda.

İşte hem sınıf üzerinden erişim hem de metasınıf kullanan bir örnek üzerinden erişim için çalışması gereken bir çözüm.

In [1]: class ClassPropertyMeta(type):
   ...:     @property
   ...:     def prop(cls):
   ...:         return cls._prop
   ...:     def __new__(cls, name, parents, dct):
   ...:         # This makes overriding __getattr__ and __setattr__ in the class impossible, but should be fixable
   ...:         dct['__getattr__'] = classmethod(lambda cls, attr: getattr(cls, attr))
   ...:         dct['__setattr__'] = classmethod(lambda cls, attr, val: setattr(cls, attr, val))
   ...:         return super(ClassPropertyMeta, cls).__new__(cls, name, parents, dct)
   ...:

In [2]: class ClassProperty(object):
   ...:     __metaclass__ = ClassPropertyMeta
   ...:     _prop = 42
   ...:     def __getattr__(self, attr):
   ...:         raise Exception('Never gets called')
   ...:

In [3]: ClassProperty.prop
Out[3]: 42

In [4]: ClassProperty.prop = 1
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-4-e2e8b423818a> in <module>()
----> 1 ClassProperty.prop = 1

AttributeError: can't set attribute

In [5]: cp = ClassProperty()

In [6]: cp.prop
Out[6]: 42

In [7]: cp.prop = 1
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-7-e8284a3ee950> in <module>()
----> 1 cp.prop = 1

<ipython-input-1-16b7c320d521> in <lambda>(cls, attr, val)
      6         # This makes overriding __getattr__ and __setattr__ in the class impossible, but should be fixable
      7         dct['__getattr__'] = classmethod(lambda cls, attr: getattr(cls, attr))
----> 8         dct['__setattr__'] = classmethod(lambda cls, attr, val: setattr(cls, attr, val))
      9         return super(ClassPropertyMeta, cls).__new__(cls, name, parents, dct)

AttributeError: can't set attribute

Bu aynı zamanda metasınıfta tanımlanan bir ayarlayıcı ile de çalışır.

Farklı yerlerde arama yaptıktan sonra, Python 2 ve 3 ile geçerli bir sınıf özelliği tanımlamak için bir yöntem buldum.

from future.utils import with_metaclass

class BuilderMetaClass(type):
    @property
    def load_namespaces(self):
        return (self.__sourcepath__)

class BuilderMixin(with_metaclass(BuilderMetaClass, object)):
    __sourcepath__ = 'sp'        

print(BuilderMixin.load_namespaces)

Umarım bu birine yardımcı olabilir :)

İşte benim önerim. Sınıf yöntemleri kullanmayın.

Ciddi anlamda.

Bu durumda sınıf yöntemlerini kullanmanın nedeni nedir? Neden sıradan bir sınıfın sıradan bir nesnesine sahip değilsiniz?

Sadece değeri değiştirmek istiyorsanız, bir özellik gerçekten çok yararlı değil mi? Sadece öznitelik değerini ayarlayın ve onunla yapın.

Bir özellik yalnızca gizlenecek bir şey varsa kullanılmalıdır - gelecekteki bir uygulamada değişebilecek bir şey.

Belki örneğiniz yoldan kaldırılmıştır ve bıraktığınız bazı cehennem hesaplamaları vardır. Ama özellik önemli bir değer katıyor gibi görünmüyor.

Java'dan etkilenen "gizlilik" teknikleri (Python'da _ ile başlayan özellik adları) gerçekten çok yararlı değildir. Kimden özel? Kaynağa sahip olduğunuzda özel nokta biraz belirsiz (Python'da olduğu gibi).

Java'dan etkilenen EJB tarzı alıcılar ve ayarlayıcılar (genellikle Python'da özellikler olarak yapılır), Java'nın ilkel içgözlemini kolaylaştırmanın yanı sıra statik dil derleyicisiyle toplanmak için vardır. Tüm bu alıcılar ve ayarlayıcılar Python'da o kadar yardımcı değil.