Pythonic accessors / mutators for "internal" lists

Question

I'm aware that attribute getters and setters are considered "unpythonic", and the pythonic way to do things is to simply use an normal attribute and use the property decorator if you later need to trigger some functionality when an attribute is accessed or set.

e.g. What's the pythonic way to use getters and setters?

But how does this apply when the value of an attribute is a list, for example?

class AnimalShelter(object):
    def __init__(self):
        dogs = []
        cats = []

class Cat(object):
    pass

class Dog(object):
    pass

Say that initially, the interface works like this:

# Create a new animal shelter
woodgreen = AnimalShelter()

# Add some animals to the shelter
dog1 = Dog()
woodgreen.dogs.append(dog1)

This would seem to be in line with the "pythonic" idea of just using straightforward attributes rather than creating getters, setters, mutators etc. I could have created an addDog method instead. But while not strictly speaking a setter (since it mutates the value of an attribute rather than setting an attribute), it still seems setter-like compared to my above solution.

But then, say that later on you need to trigger some functionality when dogs are added. You can't fall back on the using the property decorator, since adding a dog is not setting a property on the object, but retrieving a list which is the value of that attribute, and mutating that list.

What would be the "pythonic" way of dealing with such a situation?

Answer 1

What's unpythonic are useless getters and setters - since Python have a strong support for computed attributes. This doesn't mean you shouldn't properly encapsulate your implementation.

In your above exemple, the way your AnimalShelter class handles it's "owned" animals is an implementation detail and should not be exposed, so it's totally pythonic to use protected attribute and expose a relevant set of public methods / properties:

class AnimalShelter(object):
    def __init__(self):
        self._dogs = []
        self._cats = []

    def add_dog(self, dog):
        if dog not in self._dogs:     
            self._dogs.append(dog)

    def get_dogs(self):
        return self._dogs[:] # return a shallow copy

    # etc