Tôi có một lớp với hai phương thức lớp (sử dụng hàm classmethod ()) để nhận và thiết lập những gì thực chất là một biến tĩnh. Tôi đã cố gắng sử dụng hàm property () với những cái này, nhưng nó dẫn đến một lỗi. Tôi đã có thể tái tạo lỗi với phần sau trong trình thông dịch:

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

Tôi có thể chứng minh các phương thức lớp, nhưng chúng không hoạt động như các thuộc tính:

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

Có thể sử dụng hàm property () với các hàm trang trí classmethod không?

Một thuộc tính được tạo trên một lớp nhưng ảnh hưởng đến một thể hiện. Vì vậy, nếu bạn muốn một thuộc tính classmethod, hãy tạo thuộc tính trên metaclass.

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

Nhưng vì dù sao bạn cũng đang sử dụng siêu dữ liệu, nó sẽ đọc tốt hơn nếu bạn chỉ di chuyển các lớp đối xứng trong đó.

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

hoặc, sử dụng metaclass=...cú pháp của Python 3 và siêu dữ liệu được xác định bên ngoài foothân lớp và siêu dữ liệu chịu trách nhiệm đặt giá trị ban đầu là _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

Đọc ghi chú phát hành Python 2.2 , tôi thấy như sau.

Phương thức get [của một thuộc tính] sẽ không được gọi khi thuộc tính được truy cập dưới dạng một thuộc tính lớp (Cx) thay vì như một thuộc tính thể hiện (C (). X). Nếu bạn muốn ghi đè hoạt động __get__ cho các thuộc tính khi được sử dụng làm thuộc tính lớp, bạn có thể phân lớp thuộc tính - đó là kiểu kiểu mới - để mở rộng phương thức __get__ của nó hoặc bạn có thể xác định loại mô tả từ đầu bằng cách tạo mới lớp kiểu định nghĩa các phương thức __get__, __set__ và __delete__.

LƯU Ý: Phương pháp dưới đây không thực sự hoạt động đối với setters, chỉ getters.

Do đó, tôi tin rằng giải pháp được quy định là tạo ClassProperty dưới dạng một lớp con của thuộc tính.

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

Tuy nhiên, các setters không thực sự hoạt động:

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

foo._var là không thay đổi, bạn chỉ đơn giản ghi đè lên tài sản với một giá trị mới.

Bạn cũng có thể sử dụng ClassPropertynhư một trang trí:

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

Tôi hy vọng người @classpropertytrang trí chỉ đọc đơn giản đã chết này sẽ giúp ai đó tìm kiếm các sản phẩm đẳng cấp.

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

Có thể sử dụng hàm property () với các hàm trang trí classmethod không?

Không.

Tuy nhiên, một classmethod chỉ đơn giản là một phương thức ràng buộc (một hàm một phần) trên một lớp có thể truy cập được từ các thể hiện của lớp đó.

Vì cá thể là một chức năng của lớp và bạn có thể lấy được lớp từ cá thể đó, nên bạn có thể nhận bất kỳ hành vi mong muốn nào bạn có thể muốn từ một thuộc tính lớp với 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

Mã này có thể được sử dụng để kiểm tra - nó sẽ vượt qua mà không gây ra bất kỳ lỗi nào:

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

Và lưu ý rằng chúng tôi hoàn toàn không cần siêu dữ liệu - và bạn không truy cập trực tiếp vào siêu dữ liệu thông qua các trường hợp của lớp.

viết một @classpropertytrang trí

Bạn thực sự có thể tạo một trình classpropertytrang trí chỉ trong một vài dòng mã bằng cách phân lớp property(nó được triển khai trong C, nhưng bạn có thể thấy Python tương đương ở đây ):

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

Sau đó đối xử với trình trang trí như thể nó là một phân loại kết hợp với thuộc tính:

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

Và mã này sẽ hoạt động mà không có lỗi:

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

Nhưng tôi không chắc điều này sẽ được khuyên như thế nào. Một bài viết danh sách gửi thư cũ cho thấy nó không nên làm việc.

Bắt tài sản để làm việc trên lớp:

Nhược điểm ở trên là "thuộc tính lớp" không thể truy cập được từ lớp, bởi vì nó chỉ đơn giản sẽ ghi đè lên bộ mô tả dữ liệu từ lớp __dict__.

Tuy nhiên, chúng ta có thể ghi đè lên điều này bằng một thuộc tính được xác định trong siêu dữ liệu __dict__. Ví dụ:

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

Và sau đó, một thể hiện của lớp siêu dữ liệu có thể có một thuộc tính truy cập vào thuộc tính của lớp bằng cách sử dụng nguyên tắc đã được trình bày trong các phần trước:

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

Và bây giờ chúng ta thấy cả hai ví dụ

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

và lớp học

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

có quyền truy cập vào tài sản lớp.

Con trăn 3!

Câu hỏi cũ, rất nhiều lượt xem, rất cần một cách 3 Python đúng.

May mắn thay, thật dễ dàng với metaclasskwarg:

class FooProperties(type):

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

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

Sau đó, >>> Foo.var

'THỰC SỰ!'

Không có cách hợp lý để làm cho hệ thống "thuộc tính lớp" này hoạt động trong Python.

Đây là một cách không hợp lý để làm cho nó hoạt động. Bạn chắc chắn có thể làm cho nó liền mạch hơn với số lượng ma thuật siêu dữ liệu ngày càng tăng.

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

Nút thắt của vấn đề là các thuộc tính là cái mà Python gọi là "mô tả". Không có cách nào ngắn gọn và dễ dàng để giải thích cách thức hoạt động của siêu lập trình này, vì vậy tôi phải chỉ cho bạn cách mô tả .

Bạn chỉ cần hiểu những thứ này nếu bạn đang thực hiện một khung khá tiên tiến. Giống như một hệ thống RPC hoặc hệ thống RPC trong suốt, hoặc một loại ngôn ngữ dành riêng cho miền.

Tuy nhiên, trong một bình luận cho câu trả lời trước đó, bạn nói rằng bạn

cần sửa đổi một thuộc tính theo cách mà tất cả các thể hiện của một lớp nhìn thấy và trong phạm vi mà các phương thức lớp này được gọi không có tham chiếu đến tất cả các thể hiện của lớp.

Dường như với tôi, những gì bạn thực sự muốn là một mẫu thiết kế Observer .

Chỉ thiết lập nó trên lớp meta không giúp ích gì nếu bạn muốn truy cập thuộc tính lớp thông qua một đối tượng được khởi tạo, trong trường hợp này bạn cũng cần cài đặt một thuộc tính bình thường trên đối tượng (gửi đến thuộc tính lớp). Tôi nghĩ sau đây là một chút rõ ràng hơn:

#!/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

Một nửa giải pháp, __set__ trên lớp không hoạt động, vẫn còn. Giải pháp là một lớp thuộc tính tùy chỉnh thực hiện cả thuộc tính và tĩnh.

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

Bởi vì tôi cần sửa đổi một thuộc tính theo cách mà tất cả các thể hiện của một lớp nhìn thấy và trong phạm vi mà các phương thức lớp này được gọi không có tham chiếu đến tất cả các thể hiện của lớp.

Bạn có quyền truy cập vào ít nhất một thể hiện của lớp không? Tôi có thể nghĩ ra một cách để làm điều đó sau đó:

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

Hãy thử xem, nó hoàn thành công việc mà không phải thay đổi / thêm nhiều mã hiện có.

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

Các propertychức năng cần hai callableđối số. cung cấp cho họ các hàm bao lambda (mà nó vượt qua thể hiện như là đối số đầu tiên của nó) và tất cả đều tốt.

Đây là một giải pháp nên hoạt động cho cả truy cập thông qua lớp và truy cập thông qua một cá thể sử dụng siêu dữ liệu.

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

Điều này cũng hoạt động với một setter được xác định trong siêu dữ liệu.

Sau khi tìm kiếm các địa điểm khác nhau, tôi đã tìm thấy một phương thức để xác định một classproperty hợp lệ với Python 2 và 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)

Hy vọng điều này có thể giúp ai đó :)

Đây là gợi ý của tôi. Đừng sử dụng các phương thức lớp.

Nghiêm túc.

Lý do của việc sử dụng các phương thức lớp trong trường hợp này là gì? Tại sao không có một đối tượng bình thường của một lớp bình thường?

Nếu bạn chỉ đơn giản muốn thay đổi giá trị, một tài sản không thực sự rất hữu ích phải không? Chỉ cần đặt giá trị thuộc tính và được thực hiện với nó.

Một tài sản chỉ nên được sử dụng nếu có thứ gì đó để che giấu - thứ gì đó có thể thay đổi trong quá trình thực hiện trong tương lai.

Có thể ví dụ của bạn bị tước bỏ, và có một số tính toán quái quỷ mà bạn đã bỏ qua. Nhưng nó không giống như tài sản thêm giá trị đáng kể.

Các kỹ thuật "quyền riêng tư" chịu ảnh hưởng của Java (trong Python, tên thuộc tính bắt đầu bằng _) thực sự không hữu ích lắm. Riêng tư từ ai? Điểm riêng tư là hơi mơ hồ khi bạn có nguồn (như bạn làm trong Python.)

Các getters và setters kiểu EJB chịu ảnh hưởng của Java (thường được thực hiện như các thuộc tính trong Python) có mặt để tạo điều kiện cho sự hướng nội nguyên thủy của Java cũng như để vượt qua trình biên dịch với trình biên dịch ngôn ngữ tĩnh. Tất cả các getters và setters không hữu ích trong Python.