Usage of property decorator for private attributes in classes in Python

Question

I've started learning Python recently, and there are some topics I cannot really understand. One is the usage of the decorators in user defined objects, or encapsulation more generally. I mean, let's consider for example:

class Dog:
   def __init__(self,name,age):
      self.name=name
      self.age=age

Ok so now I have the object 'Dog'. If I make its attribute privates by adding '__' in the constructor, I won't be able to access them. In order to do so, I will have to use, for example, the decorator 'property', which has attributes (not sure how to call them actually)'getter', 'setter' and 'deleter'. So I make, for example, the name private. I have:

class Dog:
   def __init__(self,name,age):
      self.__name=name
      self.age=age
   @property
   def name(self):
      return self.__name
   @name.setter
   def name(self,name)
      self.__name=name
   @name.deleter
   def name(self)
      del self.__name

Now the question is: how is this different from just letting name be public? I would understand if I could only read the name value, or don't delete it, but if I give the user the possibility to read, write and delete the attribute... why do I bother making it private in the first place?

I don't know, maybe this was just a "syntax exercise" and in fact you are meant to give the user only a proper subset of those abilities.

Answer 1

Here's a more thorough example of why you would want to have a private attribute: data type validation (as pointed out by the other answers).

Let's say that you've been using the Dog class for a few weeks, and a new bug has come up that happens when the name attribute is (for whatever reason) set to a value that's not a string. You now need to change the code in order to enforce that a Dog's name is indeed a string, by raising an informative Exception. How do you do that?

Your first idea may be to simply check the name's data type after creating a new Dog (using the isinstance builtin function):

my_dog = Dog(name='Max', age=5)
if not isinstance(my_dog.name, str):
    raise ValueError("The Dog's name is not a string")

This works, but there's a clear issue here: you need to 1) change every line of code where a Dog is created, and 2) you need to tell anyone who ever uses your Dog class that, by the way, remember to check for the name's data type. This is clearly a lot of work, and not future-proof by any means - what if you or another user forgets to do this check? What if no one ever reads your documentation on the Dog class?

You may then think to perform this check in the __init__ method:

def class Dog:
    def __init__(self, name, age):
        if not isinstance(name, str):
            raise ValueError("The Dog's name is not a string")
        self.__name = name
        self.age = age

This cuts down on the work, but it doesn't stop someone from modifying the Dog's name after it was instantiated:

my_dog = Dog(name='Max', age=5)
my_dog.name = 10  # oops, wrong value!

What we want to do is to actually move this type-checking functionality to a method that runs every time the name attribute gets set - which is exactly what the setter method (the one decorated with the @name.setter decorator) does:

def class Dog:
    def __init__(self, name, age):
        self.__name = name
        self.age = age

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

    @name.setter
    def name(self, new_name)
        if not isinstance(new_name, str):
            raise ValueError("The Dog's name is not a string")
        self.__name = new_name

Now the name's data type is always checked for, both during instantiation (in the __init__ method) and afterwards.

Data type validation is simply an example. The point of using private attributes and their getters/setters is to combine attribute access with some custom functionality. If you desire no functionality whatsoever when accessing/modifying the attribute, you're correct in your observation that you don't need to bother making it private and writing the getter/setter methods in the first place.

Answer 2

The advantage of properties is that from the viewpoint of the user of your class, it's syntactically the same as plain attribute access. So you can add logic (validation etc.) at any time without changing the class's interface and breaking the code that uses it. You can even swap in different versions of the class (e.g. with properties that do logging during development, without properties for production) and the caller won't even notice.

Contrast this to a language like Java where best practice is to always write getter/setter methods even if you don't need them, because you might need them later, but can't add them later without changing the API and thereby breaking code that uses the class.

BTW, there are no truly private attributes in Python. The leading __ is intended to keep names from conflicting among subclasses of the base class, where that might be a problem.