先看一个例子，@property。被@property修饰的成员函数，将变为一个描述符。这是最简单的创建描述符的方式。

class Foo:
  @property
  def attr(self):
    print('getting attr')
    return 'attr value'

  def bar(self): pass

foo = Foo()

上面这个例子中， attr 是类 Foo 的一个成员函数，可通过语句 foo.attr() 被调用。 但当它被 @property 修饰后，这个成员函数将不再是一个函数，而变为一个描述符。 bar 是一个未被修饰的成员函数。 type(Foo.attr) 与 type(Foo.bar) 的结果分别为：

<type 'property'>
<type 'instancemethod'>

attr 的类型为 property （注：一个 property 类型的对象总是一个描述符）， bar 的类型为 instancemethod ，也即一个常规的成员函数。

此时 attr 将无法再被调用，当尝试调用它时，语句 foo.attr() 将抛出错误：

TypeError: 'str' object is not callable

让我们来理解这个错误。

首先来看 foo.attr 的值：

attr value

其类型 type(foo.attr) ：

str

foo.attr 的类型为 str ，因此便有了以上的错误，一个 str 对象无法被调用。其值为'attr value'，正好是原始 attr 函数的返回值。 因此语句 foo.attr 实际上触发了原始 attr 函数的调用，并且将函数的返回值作为其值。实际上语句 print(foo.attr) 的输出为：

getting attr
attr value

进一步验证了执行语句 foo.attr 时，原始的 attr 函数被调用。

发生了什么？当执行一个访问对象属性的语句 foo.attr 时，结果一个函数调用被触发！这便是描述符的作用：将属性访问转变为函数调用，并由这个函数来控制这个属性的值（也即函数的返回值），以及在返回值前做定制化的操作。此时可以给描述符一个简要定义：

描述符是类的一个属性，控制类实例对象访问这个属性时如何返回值及做哪些额外操作

这留给程序员的空间是巨大的。。

class MyDescriptor:
  def __init__(self):
    self.data = None
  def __get__(self, obj, type):
    print('get called')
    return self.data
  def __set__(self, obj, value):
    print('set called')
    self.data = value
  def __delete__(self, obj):
    print('delete called')
    del self.data

class Foo:
  attr = MyDescriptor()

foo = Foo()

get called
None

set called

get called
new value

delete called

get called
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "1.py", line 6, in __get__
    return self.data
AttributeError: 'MyDescriptor' object has no attribute 'data'