如何制作一个类属性？

在python中，我可以使用
@classmethod
装饰器向类添加方法。是否有类似的装饰器向类中添加属性？我可以更好地展示我在说什么。 
class Example(object):
   the_I = 10
   def __init__( self ):
      self.an_i = 20

   @property
   def i( self ):
      return self.an_i

   def inc_i( self ):
      self.an_i += 1

   # is this even possible?
   @classproperty
   def I( cls ):
      return cls.the_I

   @classmethod
   def inc_I( cls ):
      cls.the_I += 1

e = Example()
assert e.i == 20
e.inc_i()
assert e.i == 21

assert Example.I == 10
Example.inc_I()
assert Example.I == 11
我上面使用的语法是可能的还是需要更多的东西？ 我想要类属性的原因是我可以延迟加载类属性，这似乎足够合理。     
2019-10-10 8 条评论
分享

没有找到相关结果

    已邀请:

    遣莫捅炭

    这是我将如何做到这一点： 
    class ClassPropertyDescriptor(object):

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

    def __get__(self, obj, klass=None):
        if klass is None:
            klass = type(obj)
        return self.fget.__get__(obj, klass)()

    def __set__(self, obj, value):
        if not self.fset:
            raise AttributeError("can't set attribute")
        type_ = type(obj)
        return self.fset.__get__(obj, type_)(value)

    def setter(self, func):
        if not isinstance(func, (classmethod, staticmethod)):
            func = classmethod(func)
        self.fset = func
        return self

def classproperty(func):
    if not isinstance(func, (classmethod, staticmethod)):
        func = classmethod(func)

    return ClassPropertyDescriptor(func)


class Bar(object):

    _bar = 1

    @classproperty
    def bar(cls):
        return cls._bar

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


# test instance instantiation
foo = Bar()
assert foo.bar == 1

baz = Bar()
assert baz.bar == 1

# test static variable
baz.bar = 5
assert foo.bar == 5

# test setting variable on the class
Bar.bar = 50
assert baz.bar == 50
assert foo.bar == 50
    当我们打电话给
    Bar.bar
    时，二传手没有工作，因为我们正在打电话 
    TypeOfBar.bar.__set__
    ，不是
    Bar.bar.__set__
    。 添加元类定义解决了这个问题： 
    class ClassPropertyMetaClass(type):
    def __setattr__(self, key, value):
        if key in self.__dict__:
            obj = self.__dict__.get(key)
        if obj and type(obj) is ClassPropertyDescriptor:
            return obj.__set__(self, value)

        return super(ClassPropertyMetaClass, self).__setattr__(key, value)

# and update class define:
#     class Bar(object):
#        __metaclass__ = ClassPropertyMetaClass
#        _bar = 1

# and update ClassPropertyDescriptor.__set__
#    def __set__(self, obj, value):
#       if not self.fset:
#           raise AttributeError("can't set attribute")
#       if inspect.isclass(obj):
#           type_ = obj
#           obj = None
#       else:
#           type_ = type(obj)
#       return self.fset.__get__(obj, type_)(value)
    现在一切都会好的。     
    2019-10-10 0 0
    分享

    肺鬼耙扮群

    如果您按如下方式定义
    classproperty
    ，那么您的示例将完全按照您的要求工作。 
    class classproperty(object):
    def __init__(self, f):
        self.f = f
    def __get__(self, obj, owner):
        return self.f(owner)
    需要注意的是，您不能将其用于可写属性。当
    e.I = 20
    将提高
    AttributeError
    ，
    Example.I = 20
    将覆盖属性对象本身。     
    2019-10-10 0 0
    分享

    响摔衅幸

    我想你可以用元类做到这一点。因为元类可以像类的类（如果有意义的话）。我知道你可以为元类指定一个
    __call__()
    方法来覆盖调用类，
    MyClass()
    。我想知道在元类上使用
    property
    装饰器的操作是否类似。 （我之前没试过，但现在我好奇......） [更新：] 哇，确实有效： 
    class MetaClass(type):    
    def getfoo(self):
        return self._foo
    foo = property(getfoo)

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

class MyClass(object):
    __metaclass__ = MetaClass
    _foo = 'abc'
    _bar = 'def'

print MyClass.foo
print MyClass.bar
    注意：这是在Python 2.7中。 Python 3+使用不同的技术来声明元类。使用：
    class MyClass(metaclass=MetaClass):
    ，删除
    __metaclass__
    ，其余部分相同。     
    2019-10-10 0 0
    分享

    壤欠攻混

    [基于python 3.4编写的答案;元类语法在2中有所不同，但我认为该技术仍然有效] 你可以用元类来做这件事......大多数情况下。 Dappawit几乎可以工作，但我认为它有一个缺陷： 
    class MetaFoo(type):
    @property
    def thingy(cls):
        return cls._thingy

class Foo(object, metaclass=MetaFoo):
    _thingy = 23
    这会让你获得Foo的一个类属性，但是有一个问题...... 
    print("Foo.thingy is {}".format(Foo.thingy))
# Foo.thingy is 23
# Yay, the classmethod-property is working as intended!
foo = Foo()
if hasattr(foo, "thingy"):
    print("Foo().thingy is {}".format(foo.thingy))
else:
    print("Foo instance has no attribute 'thingy'")
# Foo instance has no attribute 'thingy'
# Wha....?
    这到底是怎么回事？为什么我不能从实例到达类属性？ 在找到我认为的答案之前，我在这方面打了很长时间。 Python @properties是描述符的子集，并且从描述符文档（强调我的）：   属性访问的默认行为是获取，设置或删除   来自对象字典的属性。例如，
    a.x
    有一个查找链   从
    a.__dict__['x']
    开始，然后
    type(a).__dict__['x']
    ，继续   通过
    type(a)
    的基类除了元类。 因此，方法解析顺序不包括我们的类属性（或元类中定义的任何其他内容）。可以使内置属性装饰器的子类具有不同的行为，但是（引用需要）我已经得到了开发人员有一个很好的理由（我不明白）这样做的印象。 这并不意味着我们运气不好;我们可以很好地访问类本身的属性......我们可以在实例中从
    type(self)
    获取类，我们可以使用它来创建@property调度程序： 
    class Foo(object, metaclass=MetaFoo):
    _thingy = 23

    @property
    def thingy(self):
        return type(self).thingy
    现在
    Foo().thingy
    适用于班级和实例！如果派生类替换了它的底层
    _thingy
    （这是最初让我参与此搜索的用例），它也将继续做正确的事情。 这对我来说并不是100％满足 - 不得不在元类和对象类中进行设置，感觉它违反了DRY原则。但后者只是一个单线调度员;我现在对它很好，如果你真的想要的话，你可以将它压缩成lambda或者其他东西。     
    2019-10-10 0 0
    分享

    犁攀富

    据我所知，没有创建新的元类，就没有办法为类属性编写setter。 我发现以下方法有效。使用所需的所有类属性和设置器定义元类。 IE，我想要一个带有set28ѭ属性的类和一个setter。这是我写的： 
    class TitleMeta(type):
    @property
    def title(self):
        return getattr(self, '_title', 'Default Title')

    @title.setter
    def title(self, title):
        self._title = title
        # Do whatever else you want when the title is set...
    现在正常创建您想要的实际类，除非它使用您在上面创建的元类。 
    # Python 2 style:
class ClassWithTitle(object):
    __metaclass__ = TitleMeta
    # The rest of your class definition...

# Python 3 style:
class ClassWithTitle(object, metaclass = TitleMeta):
    # Your class definition...
    如上所述，如果我们只在单个类上使用它，那么定义这个元类有点奇怪。在这种情况下，如果您使用的是Python 2样式，则可以在类主体中实际定义元类。这样它就没有在模块范围内定义。     
    2019-10-10 0 0
    分享

    补蹲农界维

    如果您只需要延迟加载，那么您可以使用类初始化方法。 
    EXAMPLE_SET = False
class Example(object):
   @classmethod 
   def initclass(cls):
       global EXAMPLE_SET 
       if EXAMPLE_SET: return
       cls.the_I = 'ok'
       EXAMPLE_SET = True

   def __init__( self ):
      Example.initclass()
      self.an_i = 20

try:
    print Example.the_I
except AttributeError:
    print 'ok class not "loaded"'
foo = Example()
print foo.the_I
print Example.the_I
    但是元类方法看起来更清晰，并且具有更可预测的行为。 也许您正在寻找的是Singleton设计模式。关于在Python中实现共享状态有一个很好的SO QA。     
    2019-10-10 0 0
    分享

    呕蹿尉

    我碰巧提出了一个非常类似于@Andrew的解决方案，只有DRY 
    class MetaFoo(type):

    def __new__(mc1, name, bases, nmspc):
        nmspc.update({'thingy': MetaFoo.thingy})
        return super(MetaFoo, mc1).__new__(mc1, name, bases, nmspc)

    @property
    def thingy(cls):
        if not inspect.isclass(cls):
            cls = type(cls)
        return cls._thingy

    @thingy.setter
    def thingy(cls, value):
        if not inspect.isclass(cls):
            cls = type(cls)
        cls._thingy = value

class Foo(metaclass=MetaFoo):
    _thingy = 23

class Bar(Foo)
    _thingy = 12
    这是所有答案中最好的： “metaproperty”被添加到类中，因此它仍然是实例的属性 不需要在任何类中重新定义thingy 该属性作为实例和类的“类属性” 您可以灵活地自定义_thingy的继承方式 在我的情况下，我实际上为每个孩子定制了
    _thingy
    ，而不是在每个类中定义它（并且没有默认值）： 
       def __new__(mc1, name, bases, nmspc):
       nmspc.update({'thingy': MetaFoo.services, '_thingy': None})
       return super(MetaFoo, mc1).__new__(mc1, name, bases, nmspc)
        
    2019-10-10 0 0
    分享
    为什么被折叠? 0 个回复被折叠

    要回复问题请先登录或注册

    或代码 OrCode.com 备案号：粤ICP备15020848号-1
    Escape time: 0.034984827041626