Correct way to use accessors in Python? [duplicate]

Question

Is this how you would define a class "Car" with attribute "Speed" in Python? My background is in Java, and it seems one does not use get/set methods in Python.

class Car(object):
    def __init__(self):
        self._speed = 100

    @property
    def speed(self):
        return self._speed

    @speed.setter
    def speed(self, value):
        self._speed = value

Answer 1

In Python we generally avoid getters and setters. Just have a .speed attribute:

class Car(object):
    speed = 0

    def __init__(self):
        self.speed = 100

See Python is not Java for motivations and more pitfalls to avoid:

In Java, you have to use getters and setters because using public fields gives you no opportunity to go back and change your mind later to using getters and setters. So in Java, you might as well get the chore out of the way up front. In Python, this is silly, because you can start with a normal attribute and change your mind at any time, without affecting any clients of the class. So, don't write getters and setters.

Use property when you have a genuine need to execute code when getting, setting or deleting an attribute. Validation, caching, side effects, etc. all are fair use-cases for properties. Just don't use them until necessary.

Answer 2

Since technically attributes are never private in Python, get/set methods are not considered "pythonic." This is the standard way to access object attributes:

class MyClass():
    def __init__(self):
        self.my_attr = 3

obj1 = MyClass()
print obj1.my_attr #will print 3
obj1.my_attr = 7
print obj1.my_attr #will print 7

You may, of course, still use getters and setters, and you can somewhat emulate private members by prepending __ to your attributes:

class MyClass():
    def __init__(self):
        self.__my_attr = 3
    def set_my_attr(self,val):
        self.__my_attr = val
    def get_my_attr(self):
        return self.__my_attr

obj1 = MyClass()
print obj1.get_my_attr() #will print 3
obj1.set_my_attr(7)
print obj1.get_my_attr() #will print 7

The __ "mangles" the variable name: from outside some class classname in which __attr is defined, __attr is renamed as _classname__attr; in the above example, instead of using the getters and setters, we could simply use obj1._MyClass__my_attr. So __ discourages external use of attributes, but it doesn't prohibit it in the same way that the Java private modifier does.

There are also, as you mention in your question, properties available in Python. The advantage of properties is that you can use them to implement functions that return or set values that, from outside the class, appear to be simply accessed as normal member attributes.