@property标记与经典的getter+setter相比有哪些优势？在哪些特定情况下程序员应选择使用其中之一？
使用属性：
class MyClass(object):
@property
def my_attr(self):
return self._my_attr
@my_attr.setter
def my_attr(self, value):
self._my_attr = value
没有属性：
class MyClass(object):
def get_my_attr(self):
return self._my_attr
def set_my_attr(self, value):
self._my_attr = value
优先使用属性。它们就是为此而存在的。
原因在于Python中所有属性都是公开的。以下划线或两个下划线开头的名称只是一个警告，表示给定的属性是实现细节，可能在未来版本的代码中发生变化。但这并不妨碍您实际获取或设置该属性。因此，标准属性访问是正常的、符合Python风格的访问属性的方式。
属性的好处是它们在语法上与属性访问完全相同，因此您可以在不更改客户端代码的情况下从其中一个更改为另一个。您甚至可以拥有一个使用属性的类的版本（例如，用于按照约定编写代码或调试），另一个没有使用（用于生产），而不必更改使用它的代码。同时，您也不必为所有属性编写getter和setter，只有在需要对访问进行更好的控制时才需要。
__slots__的类。你同样可以定义方法，这样更加节省内存。 - johannestaas简短的回答是：属性总是更胜一筹。始终如此。
有时候需要使用getter和setter，但即使如此，我也会将它们“隐藏”起来，不让外部访问。在Python中有很多方法可以实现这一点（例如getattr，setattr，__getattribute__等），但非常简洁和清晰的方法是：
def set_email(self, value):
if '@' not in value:
raise Exception("This doesn't look like an email address.")
self._email = value
def get_email(self):
return self._email
email = property(get_email, set_email)
这篇简短的文章介绍了Python中getter和setter的主题。
property 相冲突。（它 看起来 像是一个简单的赋值，但实际上调用了一个函数。）因此，“Pythonic”本质上是一个无意义的术语，除非用诡辩的定义： “Pythonic规范是我们定义为Pythonic的东西。” - Stuart Berguser.email="..." 看起来似乎只是设置一个属性，不会引发异常，而 user.set_email("...") 明确表明可能存在异常等副作用。 - bluenote10[简而言之？ 你可以直接跳到结尾查看代码示例。]
实际上，我更喜欢使用不同的习语，如果您有更复杂的用例，这种方法会更好一些，但是如果您只需要使用一次，那么这种方法可能过于繁琐。
首先，让我们来了解一下背景。
属性很有用，因为它们允许我们以编程方式处理设置和获取值，但仍允许像属性一样访问属性。 我们可以将“获取”转换为“计算”（本质上），并将“设置”转换为“事件”。 因此，假设我们有以下类，我已经使用类似Java的getter和setter进行了编码。
class Example(object):
def __init__(self, x=None, y=None):
self.x = x
self.y = y
def getX(self):
return self.x or self.defaultX()
def getY(self):
return self.y or self.defaultY()
def setX(self, x):
self.x = x
def setY(self, y):
self.y = y
def defaultX(self):
return someDefaultComputationForX()
def defaultY(self):
return someDefaultComputationForY()
__init__方法中调用defaultX和defaultY。原因是，对于我们的情况，我想假设someDefaultComputation方法返回随时间变化的值，比如一个时间戳，并且每当x（或y）未设置时（在本例中，“未设置”意味着“设置为None”），我希望x（或y）的默认计算值被使用。class Example(object):
def __init__(self, x=None, y=None):
self._x = x
self._y = y
@property
def x(self):
return self.x or self.defaultX()
@x.setter
def x(self, value):
self._x = value
@property
def y(self):
return self.y or self.defaultY()
@y.setter
def y(self, value):
self._y = value
# default{XY} as before.
e.x[a,b,c] = 10
e.x[d,e,f] = 20
例如，我们能做到的最接近的方法就是覆盖赋值运算符，以暗示某些特殊语义：
e.x = [a,b,c,10]
e.x = [d,e,f,30]
def x(self, *args):
return defaultX()
并且能够随后执行：
print e.x -> The default at time T0
e.x = 1
print e.x -> 1
e.x = None
print e.x -> The default at time T1
等等，还有其他的内容。
我们还希望有一种方法来处理可参数化属性的特殊情况，但仍然允许默认分配的情况工作。你将看到我如何解决这个问题。
现在进入重点（耶！重点！）。 我提出的解决方案如下。
我们创建一个新对象来替换属性的概念。该对象旨在存储设置为其值的变量的值，并维护了一个知道如何计算默认值的代码的句柄。它的工作是存储设置的value，或者如果未设置该值，则运行method。
让我们称之为UberProperty。
class UberProperty(object):
def __init__(self, method):
self.method = method
self.value = None
self.isSet = False
def setValue(self, value):
self.value = value
self.isSet = True
def clearValue(self):
self.value = None
self.isSet = False
我假设这里的 method 是一个类方法，value 是 UberProperty 的值，并且我添加了 isSet ，因为 None 可能是一个真实的值，这样允许我们干净地声明没有真正的“值”。另一种方式是某种特殊的标记。
基本上，这给了我们一个可以完成我们想要的工作的对象，但我们如何将其实际放在我们的类上呢？那么，属性使用装饰器；我们为什么不能用呢？让我们看看它可能是什么样子的（从现在开始，我将仅使用一个“属性”，x）。
class Example(object):
@uberProperty
def x(self):
return defaultX()
当然，这实际上还没有起作用。我们必须实现uberProperty并确保它处理了获取和设置。
让我们从获取开始。
我的第一次尝试是简单地创建一个新的 UberProperty 对象并将其返回：
def uberProperty(f):
return UberProperty(f)
当然，我很快发现这样做行不通：Python从未将可调用项绑定到对象上，而我需要对象才能调用函数。即使在类中创建装饰器也不起作用，因为尽管现在我们有类，但我们仍然没有对象可以使用。
所以我们需要在这里做更多的工作。我们知道一个方法只需要被表示一次，因此让我们继续保留我们的装饰器，但修改UberProperty只存储method引用：
class UberProperty(object):
def __init__(self, method):
self.method = method
它也不可调用，所以目前什么都不起作用。
那么，当我们使用新的装饰器创建示例类时，最终会得到什么呢：
class Example(object):
@uberProperty
def x(self):
return defaultX()
print Example.x <__main__.UberProperty object at 0x10e1fb8d0>
print Example().x <__main__.UberProperty object at 0x10e1fb8d0>
UberProperty，它当然不是可调用的，所以这没有什么用。我们需要的是在类创建之后，在将对象返回给用户使用之前，以某种动态方式绑定由修饰符创建的UberProperty实例到类的对象。嗯，是的，这是一个__init__调用，伙计。
让我们首先编写我们想要的查找结果。我们将一个UberProperty绑定到一个实例上，因此一个明显的返回值将是BoundUberProperty。这是我们将实际维护x属性状态的地方。
class BoundUberProperty(object):
def __init__(self, obj, uberProperty):
self.obj = obj
self.uberProperty = uberProperty
self.isSet = False
def setValue(self, value):
self.value = value
self.isSet = True
def getValue(self):
return self.value if self.isSet else self.uberProperty.method(self.obj)
def clearValue(self):
del self.value
self.isSet = False
现在我们已经有了表示法，怎么把它们放到一个对象上呢？有一些方法，但最容易解释的方法就是使用__init__方法来进行映射。当调用__init__时，我们的装饰器已经运行过了，所以只需要查看对象的__dict__并更新任何属性，其中属性的值是UberProperty类型。
现在，超级属性很酷，我们可能会经常使用它们，因此最好为所有子类创建一个执行此操作的基类。我想你知道这个基类将被称为什么。
class UberObject(object):
def __init__(self):
for k in dir(self):
v = getattr(self, k)
if isinstance(v, UberProperty):
v = BoundUberProperty(self, v)
setattr(self, k, v)
我们添加了这个，将示例更改为继承自UberObject，并且...
e = Example()
print e.x -> <__main__.BoundUberProperty object at 0x104604c90>
修改后的x为:
@uberProperty
def x(self):
return *datetime.datetime.now()*
我们可以运行一个简单的测试：
print e.x.getValue()
print e.x.getValue()
e.x.setValue(datetime.date(2013, 5, 31))
print e.x.getValue()
e.x.clearValue()
print e.x.getValue()
我们得到了我们想要的输出：
2013-05-31 00:05:13.985813
2013-05-31 00:05:13.986290
2013-05-31
2013-05-31 00:05:13.986310
(哎呀，我工作到很晚了。)
请注意，此处使用了getValue、setValue和clearValue。这是因为我还没有链接自动返回这些的方式。
但我认为现在停下来是个好时机，因为我有点累了。你也可以看到我们想要的核心功能已经就位。其余的只是装饰性的东西。重要的用法装饰性的东西，但是在我有机会更新帖子之前，这可以等待。
在下一篇文章中，我将通过解决以下问题来完成示例：
我们需要确保UberObject的__init__始终由子类调用。
我们需要确保处理常见情况，即有人将函数“别名”为其他内容，例如：
class Example(object):
@uberProperty
def x(self):
...
y = x
e.x返回e.x.getValue()。
e.x.getValue()。（如果你还没有修复它，那么这很明显。）e.x，例如e.x = <newvalue>。我们也可以在父类中实现这个功能，但我们需要更新__init__代码来处理它。import datetime
class UberObject(object):
def uberSetter(self, value):
print 'setting'
def uberGetter(self):
return self
def __init__(self):
for k in dir(self):
v = getattr(self, k)
if isinstance(v, UberProperty):
v = BoundUberProperty(self, v)
setattr(self, k, v)
class UberProperty(object):
def __init__(self, method):
self.method = method
class BoundUberProperty(object):
def __init__(self, obj, uberProperty):
self.obj = obj
self.uberProperty = uberProperty
self.isSet = False
def setValue(self, value):
self.value = value
self.isSet = True
def getValue(self):
return self.value if self.isSet else self.uberProperty.method(self.obj)
def clearValue(self):
del self.value
self.isSet = False
def uberProperty(f):
return UberProperty(f)
class Example(UberObject):
@uberProperty
def x(self):
return datetime.datetime.now()
[1] 我可能对这是否仍然是事实落后了。
return self.x or self.defaultX() 这段代码存在潜在的风险。当 self.x == 0 时会发生什么？ - Kelly Thomas__getitem__方法。但这会很奇怪，因为你将使用完全非标准的Python。 - willo.x = 5
ox = o.x
vs.
o.setX(5)
ox = o.getX()
@property的一个问题是，在子类中使用标准类机制扩展getter或setter的行为很困难。问题在于实际的getter/setter函数被隐藏在属性中。class C(object):
_p = 1
@property
def p(self):
return self._p
@p.setter
def p(self, val):
self._p = val
你可以通过 C.p.fget 和 C.p.fset 访问 getter 和 setter 函数，但你不能轻松地使用普通的方法继承（例如 super）来扩展它们。经过一些对 super 的深入挖掘，你确实可以以这种方式使用 super：
# Using super():
class D(C):
# Cannot use super(D,D) here to define the property
# since D is not yet defined in this scope.
@property
def p(self):
return super(D,D).p.fget(self)
@p.setter
def p(self, val):
print 'Implement extra functionality here for D'
super(D,D).p.fset(self, val)
# Using a direct reference to C
class E(C):
p = C.p
@p.setter
def p(self, val):
print 'Implement extra functionality here for E'
C.p.fset(self, val)
使用super()的确有些笨拙，因为需要重新定义属性，并且您需要使用略微反直觉的super(cls,cls)机制来获得未绑定的p副本。
我认为属性是让你在实际需要时才编写getter和setter的开销。
Java编程文化强烈建议不要直接访问属性，而是通过getter和setter来访问，只使用真正需要的那些。 经常编写这些显然的代码有点冗长，并且注意到它们70%的时间从未被一些非平凡逻辑所替换。
在Python中，人们确实关心这种开销，因此您可以采用以下做法:
@property来实现它们，而不改变代码其余部分的语法。在大多数情况下，我更愿意都不使用。属性的问题是使类不够透明。特别是，如果您要从setter引发异常，则会出现此问题。例如，如果您有一个Account.email属性：
class Account(object):
@property
def email(self):
return self._email
@email.setter
def email(self, value):
if '@' not in value:
raise ValueError('Invalid email address.')
self._email = value
那么类的用户不会期望将一个值分配给属性可能会引发异常：
a = Account()
a.email = 'badaddress'
--> ValueError: Invalid email address.
class Account(object):
...
def validate(self):
if '@' not in self.email:
raise ValueError('Invalid email address.')
或者类似的Account.save方法。
请注意，我并不是在说属性从来没有用处，只是如果您能让您的类足够简单和透明，以至于您不需要它们，那么您可能会更好。
validate()的方法。当您在简单的obj.x = y赋值后面有复杂的逻辑时，就可以使用属性，具体取决于逻辑的实现方式。 - Zaur Nasibov我很惊讶地发现，没有人提到属性是描述符类的绑定方法。 Adam Donohue和NeilenMarais在他们的帖子中恰好涉及到了这个想法——获取器和设置器是函数，并且可以用于：
这提供了一种“聪明”的方式来隐藏实现细节和代码杂乱无章，例如常规表达式、类型转换、try...except块、断言或计算值。
通常，对对象执行CRUD操作可能会相当平凡，但考虑要持久化到关系数据库中的数据的例子。ORM可以隐藏特定SQL术语的实现细节，而这些细节包含在定义为属性类中的fget、fset、fdel方法中，这些方法将管理在面向对象代码中非常丑陋的if...elif...else梯子中的代码 - 暴露了简单优雅的self.variable = something并规避了使用ORM的开发人员的细节。
如果将属性仅视为奴役和纪律语言（即Java）的枯燥遗迹，那么他们就错过了描述符的要点。