房地产设计师是如何工作的？

Question

房地产设计师是如何工作的？我想了解内置功能是如何实现的。property起作用了。让我困惑的是property也可以作为装饰器使用，但它只在作为内置函数使用时才会使用参数，而不是作为装饰器使用时才会使用参数。此示例来自文献资料:class C(object):     def __init__(self):         self._x = None     def getx(self):         return self._x    def setx(self, value):         self._x = value    def delx(self):         del self._x     x = property(getx, setx, delx, "I'm the 'x' property.")property其论点是getx, setx, delx还有一根医生线。在下面的代码中property被用作装饰师。它的对象是x函数，但在上面的代码中，参数中没有对象函数的位置。class C(object):     def __init__(self):         self._x = None     @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还有，你觉得x.setter和x.deleter装饰师创造的？我很困惑。

Answer 1

这个property()函数返回一个特殊的描述符对象:

>>> property()<property object at 0x10ff07940>

正是这个对象额外方法：

>>> property().getter<built-in method getter of property object at 0x10ff07998
>>>> property().setter<built-in method setter of property object at 0x10ff07940
>>>> property().deleter<built-in method deleter of property object at 0x10ff07998>

这些人充当装潢工。也是..它们返回一个新的属性对象：

>>> property().getter(None)<property object at 0x10ff079f0>

这是旧对象的副本，但是替换了其中一个函数。

记住，@decorator语法只是语法糖；语法：

@propertydef foo(self): return self._foo

真的意味着同样的事情

def foo(self): return self._foo
foo = property(foo)

所以foo该函数被替换为property(foo)我们在上面看到的是一个特殊的物体。然后当你用@foo.setter()，你要做的就是叫它property().setter方法，它返回属性的一个新副本，但这次用setter函数替换为修饰方法。

下面的序列还通过使用这些装饰器方法创建了一个完整的属性。

首先，我们创建一些函数和一个property对象，只需一个getter：

>>> def getter(self): print 'Get!'... >>> def setter(self, value): print 'Set to {!r}!'.format(value)... >>>
 def deleter(self): print 'Delete!'... >>> prop = property(getter)>>> prop.fget is getterTrue>>> prop.fset is NoneTrue
 >>> prop.fdel is NoneTrue

接下来，我们使用.setter()方法添加一个setter：

>>> prop = prop.setter(setter)>>> prop.fget is getterTrue>>> prop.fset is setterTrue>>> prop.fdel is NoneTrue

最后，我们使用.deleter()方法：

>>> prop = prop.deleter(deleter)>>> prop.fget is getterTrue>>> prop.fset is setterTrue>>> prop.fdel is deleterTrue

最后但并非最不重要的是，property对象充当描述符对象，所以.__get__(), .__set__()和.__delete__()方法连接到实例属性获取、设置和删除：

>>> class Foo(object): pass... >>> prop.__get__(Foo(), Foo)Get!>>> prop.__set__(Foo(), 'bar')Set to 'bar'!>>> prop.__delete__(Foo())Delete!

描述符howto包括纯python示例实现.的.property()类型：

class Property(object):
    "Emulate PyProperty_Type() in Objects/descrobject.c"

    def __init__(self, fget=None, fset=None, fdel=None, doc=None):
        self.fget = fget
        self.fset = fset
        self.fdel = fdel        if doc is None and fget is not None:
            doc = fget.__doc__
        self.__doc__ = doc    def __get__(self, obj, objtype=None):
        if obj is None:
            return self        if self.fget is None:
            raise AttributeError("unreadable attribute")
        return self.fget(obj)

    def __set__(self, obj, value):
        if self.fset is None:
            raise AttributeError("can't set attribute")
        self.fset(obj, value)

    def __delete__(self, obj):
        if self.fdel is None:
            raise AttributeError("can't delete attribute")
        self.fdel(obj)

    def getter(self, fget):
        return type(self)(fget, self.fset, self.fdel, self.__doc__)

    def setter(self, fset):
        return type(self)(self.fget, fset, self.fdel, self.__doc__)

    def deleter(self, fdel):
        return type(self)(self.fget, self.fset, fdel, self.__doc__)

Answer 2

下面是一个很小的例子@property可执行：

class Thing:
    def __init__(self, my_word):
        self._word = my_word 
    @property
    def word(self):
        return self._word>>> print( Thing('ok').word )'ok'

不然的话word保留方法而不是属性。

class Thing:
    def __init__(self, my_word):
        self._word = my_word    def word(self):
        return self._word>>> print( Thing('ok').word() )'ok'

Answer 3

第一部分很简单：

@propertydef x(self): ...

是相同的

def x(self): ...x = property(x)

• 而这反过来又是创建

  property

  只需要一个吸气器。

下一步是使用setter和删除器扩展此属性。这种情况发生在适当的方法上：

@x.setterdef x(self, value): ...

返回继承旧属性中所有内容的新属性。x加上给定的策划人。

x.deleter同样的工作方式。