对我来说，使用属性更直观，更适合大多数代码。

比较

o.x = 5
ox = o.x

vs.

o.setX(5)
ox = o.getX()

对我来说很明显，更容易理解。此外，属性允许私有变量更容易。

使用属性可以让您从普通的属性访问开始，然后在必要时使用getter和setter对其进行备份。

在大多数情况下，我宁愿两者都不使用。属性的问题是它们使类不那么透明。特别是，如果要从setter引发异常，这是一个问题。例如，如果您有一个帐户。电子邮件属性:

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.

结果，异常可能得不到处理，或者在调用链中传播得太高而无法正确处理，或者导致向程序用户提供非常无用的回溯(遗憾的是，这在python和java世界中太常见了)。

我也会避免使用getter和setter:

因为提前为所有属性定义它们非常耗时， 使代码的数量不必要地变长，这使得理解和维护代码更加困难， 如果只在需要时为属性定义它们，类的接口将会改变，损害类的所有用户

而不是属性和getter /setter，我更喜欢在定义良好的地方执行复杂的逻辑，例如在验证方法中:

class Account(object):
    ...
    def validate(self):
        if '@' not in self.email:
            raise ValueError('Invalid email address.')

或类似帐户。保存方法。

请注意，我并不是想说在任何情况下属性都是有用的，只是说如果您可以使您的类足够简单和透明，以至于您不需要它们，那么您可能会更好。

喜欢的属性。这就是他们存在的意义。

原因是Python中的所有属性都是公共的。以下划线或两个下划线开头的名称只是一个警告，说明给定的属性是一个实现细节，在将来的代码版本中可能不会保持相同。它不会阻止您实际获取或设置该属性。因此，标准属性访问是访问属性的正常的python方式。

属性的优点是它们在语法上与属性访问相同，因此您可以在不更改客户机代码的情况下从一个属性更改到另一个属性。您甚至可以有一个版本的类使用属性(例如，用于契约代码或调试)，而另一个版本的类不用于生产，而不需要更改使用它的代码。与此同时，您不必为所有内容编写getter和setter，以防以后可能需要更好地控制访问。

在复杂的项目中，我更喜欢使用带有显式setter函数的只读属性(或getter):

class MyClass(object):
...        
@property
def my_attr(self):
    ...

def set_my_attr(self, value):
    ...

在长期存在的项目中，调试和重构比编写代码本身花费更多的时间。使用@property有几个缺点。Setter，使调试更加困难:

1) python允许为现有对象创建新属性。这使得下面的打印错误很难追踪:

my_object.my_atttr = 4.

如果你的目标是一个复杂的算法，那么你将花费相当多的时间试图找出它不收敛的原因(注意上面一行中额外的“t”)

2) setter有时可能演变成一个复杂而缓慢的方法(例如击中数据库)。对于另一个开发人员来说，很难弄清楚为什么下面的函数非常慢。他可能会花很多时间分析do_something()方法，而my_object。My_attr = 4。其实是减速的原因:

def slow_function(my_object):
    my_object.my_attr = 4.
    my_object.do_something()

@property和传统的getter和setter都有各自的优点。这取决于您的用例。

@property的优点

You don't have to change the interface while changing the implementation of data access. When your project is small, you probably want to use direct attribute access to access a class member. For example, let's say you have an object foo of type Foo, which has a member num. Then you can simply get this member with num = foo.num. As your project grows, you may feel like there needs to be some checks or debugs on the simple attribute access. Then you can do that with a @property within the class. The data access interface remains the same so that there is no need to modify client code. Cited from PEP-8: For simple public data attributes, it is best to expose just the attribute name, without complicated accessor/mutator methods. Keep in mind that Python provides an easy path to future enhancement, should you find that a simple data attribute needs to grow functional behavior. In that case, use properties to hide functional implementation behind simple data attribute access syntax. Using @property for data access in Python is regarded as Pythonic: It can strengthen your self-identification as a Python (not Java) programmer. It can help your job interview if your interviewer thinks Java-style getters and setters are anti-patterns.

传统getter和setter的优点

Traditional getters and setters allow for more complicated data access than simple attribute access. For example, when you are setting a class member, sometimes you need a flag indicating where you would like to force this operation even if something doesn't look perfect. While it is not obvious how to augment a direct member access like foo.num = num, You can easily augment your traditional setter with an additional force parameter: def Foo: def set_num(self, num, force=False): ... Traditional getters and setters make it explicit that a class member access is through a method. This means: What you get as the result may not be the same as what is exactly stored within that class. Even if the access looks like a simple attribute access, the performance can vary greatly from that. Unless your class users expect a @property hiding behind every attribute access statement, making such things explicit can help minimize your class users surprises. As mentioned by @NeilenMarais and in this post, extending traditional getters and setters in subclasses is easier than extending properties. Traditional getters and setters have been widely used for a long time in different languages. If you have people from different backgrounds in your team, they look more familiar than @property. Also, as your project grows, if you may need to migrate from Python to another language that doesn't have @property, using traditional getters and setters would make the migration smoother.

警告

Neither @property nor traditional getters and setters makes the class member private, even if you use double underscore before its name: class Foo: def __init__(self): self.__num = 0 @property def num(self): return self.__num @num.setter def num(self, num): self.__num = num def get_num(self): return self.__num def set_num(self, num): self.__num = num foo = Foo() print(foo.num) # output: 0 print(foo.get_num()) # output: 0 print(foo._Foo__num) # output: 0