您可以使用访问器/突变器(即@attr。Setter和@property)或不是，但最重要的是保持一致!

如果你只是使用@property来访问一个属性，例如:

class myClass:
    def __init__(a):
        self._a = a

    @property
    def a(self):
        return self._a

使用它来访问每个*属性!使用@property访问某些属性，而将其他一些属性保留为公共(即名称不带下划线)而没有访问器，这将是一个糟糕的做法，例如do not do

class myClass:
    def __init__(a, b):
        self.a = a
        self.b = b

    @property
    def a(self):
        return self.a

注意那个自我。B在这里没有显式访问器，尽管它是公共的。

与setter(或mutators)类似，可以随意使用@attribute。Setter，但要一致!当你做的时候。

class myClass:
    def __init__(a, b):
        self.a = a
        self.b = b 

    @a.setter
    def a(self, value):
        return self.a = value

It's hard for me to guess your intention. On one hand you're saying that both a and b are public (no leading underscore in their names) so I should theoretically be allowed to access/mutate (get/set) both. But then you specify an explicit mutator only for a, which tells me that maybe I should not be able to set b. Since you've provided an explicit mutator I am not sure if the lack of explicit accessor (@property) means I should not be able to access either of those variables or you were simply being frugal in using @property.

*例外情况是，当你显式地想要使某些变量可访问或可变，但不是两者，或者你想在访问或改变一个属性时执行一些额外的逻辑。这是我个人使用@property和@attribute的时候。Setter(否则没有显式的公共属性访问器/变异器)。

最后，PEP8和谷歌风格指南建议:

PEP8，为传承而设计说:

对于简单的公共数据属性，最好只公开属性名，而不需要复杂的访问器/突变器方法。请记住，如果您发现一个简单的数据属性需要增长函数行为，Python为将来的增强提供了一个简单的途径。在这种情况下，使用属性将函数实现隐藏在简单的数据属性访问语法后面。

另一方面，根据谷歌风格指南Python语言规则/属性，建议如下:

在新代码中使用属性来访问或设置数据，而通常使用简单、轻量级的访问器或setter方法。属性应该使用@property装饰器创建。

这种方法的优点:

通过消除用于简单属性访问的显式get和set方法调用，提高了可读性。允许延迟计算。考虑了维护类接口的python方式。就性能而言，当直接变量访问是合理的时，允许属性绕过了需要简单的访问器方法。这也允许将来在不破坏接口的情况下添加访问器方法。

优缺点:

必须从Python 2中的对象继承。可以隐藏像操作符重载这样的副作用。子类可能会让人困惑。

In [1]: class test(object):
    def __init__(self):
        self.pants = 'pants'
    @property
    def p(self):
        return self.pants
    @p.setter
    def p(self, value):
        self.pants = value * 2
   ....: 
In [2]: t = test()
In [3]: t.p
Out[3]: 'pants'
In [4]: t.p = 10
In [5]: t.p
Out[5]: 20

试试这个:Python属性

示例代码如下:

class C(object):
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        print("getter of x called")
        return self._x

    @x.setter
    def x(self, value):
        print("setter of x called")
        self._x = value

    @x.deleter
    def x(self):
        print("deleter of x called")
        del self._x


c = C()
c.x = 'foo'  # setter called
foo = c.x    # getter called
del c.x      # deleter called

使用@property和@attribute。Setter不仅可以帮助您使用“pythonic”方式，还可以在创建对象和更改对象时检查属性的有效性。

class Person(object):
    def __init__(self, p_name=None):
        self.name = p_name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, new_name):
        if type(new_name) == str: #type checking for name property
            self._name = new_name
        else:
            raise Exception("Invalid value for name")

通过这种方式，您实际上可以向客户端开发人员“隐藏”_name属性，并对name属性类型进行检查。请注意，即使在初始化过程中也会调用setter。所以:

p = Person(12)

会导致:

Exception: Invalid value for name

But:

>>>p = person('Mike')
>>>print(p.name)
Mike
>>>p.name = 'George'
>>>print(p.name)
George
>>>p.name = 2.3 # Causes an exception

您可以使用访问器/突变器(即@attr。Setter和@property)或不是，但最重要的是保持一致!

如果你只是使用@property来访问一个属性，例如:

class myClass:
    def __init__(a):
        self._a = a

    @property
    def a(self):
        return self._a

使用它来访问每个*属性!使用@property访问某些属性，而将其他一些属性保留为公共(即名称不带下划线)而没有访问器，这将是一个糟糕的做法，例如do not do

class myClass:
    def __init__(a, b):
        self.a = a
        self.b = b

    @property
    def a(self):
        return self.a

注意那个自我。B在这里没有显式访问器，尽管它是公共的。

与setter(或mutators)类似，可以随意使用@attribute。Setter，但要一致!当你做的时候。

class myClass:
    def __init__(a, b):
        self.a = a
        self.b = b 

    @a.setter
    def a(self, value):
        return self.a = value

It's hard for me to guess your intention. On one hand you're saying that both a and b are public (no leading underscore in their names) so I should theoretically be allowed to access/mutate (get/set) both. But then you specify an explicit mutator only for a, which tells me that maybe I should not be able to set b. Since you've provided an explicit mutator I am not sure if the lack of explicit accessor (@property) means I should not be able to access either of those variables or you were simply being frugal in using @property.

*例外情况是，当你显式地想要使某些变量可访问或可变，但不是两者，或者你想在访问或改变一个属性时执行一些额外的逻辑。这是我个人使用@property和@attribute的时候。Setter(否则没有显式的公共属性访问器/变异器)。

最后，PEP8和谷歌风格指南建议:

PEP8，为传承而设计说:

对于简单的公共数据属性，最好只公开属性名，而不需要复杂的访问器/突变器方法。请记住，如果您发现一个简单的数据属性需要增长函数行为，Python为将来的增强提供了一个简单的途径。在这种情况下，使用属性将函数实现隐藏在简单的数据属性访问语法后面。

另一方面，根据谷歌风格指南Python语言规则/属性，建议如下:

在新代码中使用属性来访问或设置数据，而通常使用简单、轻量级的访问器或setter方法。属性应该使用@property装饰器创建。

这种方法的优点:

通过消除用于简单属性访问的显式get和set方法调用，提高了可读性。允许延迟计算。考虑了维护类接口的python方式。就性能而言，当直接变量访问是合理的时，允许属性绕过了需要简单的访问器方法。这也允许将来在不破坏接口的情况下添加访问器方法。

优缺点:

必须从Python 2中的对象继承。可以隐藏像操作符重载这样的副作用。子类可能会让人困惑。

你可以使用神奇的方法__getattribute__和__setattr__。

class MyClass:
    def __init__(self, attrvalue):
        self.myattr = attrvalue
    def __getattribute__(self, attr):
        if attr == "myattr":
            #Getter for myattr
    def __setattr__(self, attr):
        if attr == "myattr":
            #Setter for myattr

注意__getattr__和__getattribute__是不同的。__getattr__只在未找到属性时调用。