En utilisant la propriété() sur classmethods

La lecture de la Python version 2.2 notes, je trouve le suivre.

La méthode get [de propriété] ne sera pas appelé quand
la propriété est accessible en tant que classe
attribut (C. x) au lieu d'une
exemple d'attribut (C().x). Si vous
souhaitez remplacer l' __get__ fonctionnement
pour les propriétés lorsqu'il est utilisé comme une classe
attribut, vous pouvez sous-classe de la propriété -
il s'agit d'un nouveau type de style en lui-même à
étendre son __get__ méthode, ou vous pouvez
définir un type du descripteur à partir de zéro
par la création d'un nouveau type de classe qui
définit __get__, __set__ et
__delete__ méthodes.

REMARQUE: La méthode ci-dessous ne fait pas travailler pour les setters, seulement des getters.

Par conséquent, je crois que le prescrit la solution est de créer un ClassProperty comme une sous-classe de la propriété.

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

Toutefois, les opérateurs n'ont pas réellement de travail:

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

foo._var est inchangé, vous avez tout simplement écrasé à la propriété avec une nouvelle valeur.

Vous pouvez également utiliser ClassProperty un décorateur:

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

Est-il possible d'utiliser la propriété() fonction avec classmethod décorées fonctions?

Pas.

Cependant, un classmethod est tout simplement une méthode liée (une fonction partielle) sur une classe accessible à partir d'instances de cette classe.

Depuis l'instance est une fonction de la classe et vous pouvez dériver de la classe de l'instance, vous pouvez obtenir ce comportement souhaité que vous pourriez voulez à partir d'une classe-propriété avec 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

Ce code peut être utilisé à des fins de test, il devrait passer sans déclencher d'erreur:

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

Et notez que nous n'avons pas besoin de metaclasses à tous - et vous n'avez pas directement accès à une métaclasse par le biais de ses classes, instances, de toute façon.

l'écriture d'un @classproperty décorateur

Vous pouvez en fait créer un classproperty décorateur en seulement quelques lignes de code par sous-classement property (il est implémenté en C, mais vous pouvez voir l'équivalent Python ici):

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

Ensuite traiter le décorateur comme si c'était un classmethod combiné avec la propriété:

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

Et ce code devrait fonctionner sans erreurs:

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

Mais je ne suis pas sûr de savoir comment bien informé de ce serait. Une vieille liste de diffusion l'article suggère qu'il ne devrait pas fonctionner.

Obtenir la propriété de travailler sur la classe:

L'inconvénient est que la "propriété de classe" n'est pas accessible à partir de la classe, car il serait tout simplement de remplacer le descripteur de données à partir de la classe __dict__.

Cependant, on peut la surcharger avec une propriété définie dans la métaclasse __dict__. Par exemple:

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

Puis à une classe de l'instance de la métaclasse pourrait avoir une propriété qui accède à la classe de la propriété en utilisant le principe déjà démontré dans les sections avant:

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

Et maintenant nous voir à la fois l'instance

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

et la classe

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

avoir accès à la propriété de classe.

Il n'y a aucun moyen raisonnable de faire de cette "propriété de la classe" système de travail en Python.

Ici est une façon déraisonnable pour le faire fonctionner. Vous pouvez certainement le rendre plus transparent avec des quantités croissantes de métaclasse magie.

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

Le nœud de la question est que les propriétés sont ce que Python appelle "descripteurs". Il n'y a aucun moyen court et facile à expliquer comment ce genre de métaprogrammation, je doit point vous à la descripteur howto.

Vous n'avez besoin de comprendre ce genre de choses, si vous êtes à la mise en œuvre d'une assez avancé cadre. Comme un objet transparent persistance ou de la RPC système, ou une sorte de langue propres au domaine.

Cependant, dans un commentaire à une précédente réponse, vous dites que vous

besoin de modifier un attribut dans une façon qui est considérée par toutes les instances d'une classe, et dans le champ d'application de ces méthodes de la classe sont appelés n'ont pas de références à toutes les instances de la classe.

Il me semble, ce que vous voulez vraiment est un Observateur motif de conception.

Une demi-solution, __set__ de la classe ne fonctionne pas, encore. La solution est une propriété personnalisée de la classe de mise en œuvre à la fois un bien et un staticmethod

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

Donner à ceci un essai, il fait le travail, sans avoir à modifier/ajouter beaucoup de code existant.

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

La property fonction des besoins de deux callable arguments. leur donner lambda wrappers (qui passe de l'instance en tant que premier argument) et tout est bien.

Après la recherche d'endroits différents, j'ai trouvé une méthode pour définir un classproperty
valide avec Python 2 et 3.

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)

J'espère que cela peut aider quelqu'un 🙂