For example, in the code below, what is the benefit of the getName function?
class Node(object): def __init__(self, name): self.name = str(name) def getName(self): return self.name def __str__(self): return self.name
There is no benefit. People coming to Python from other languages (e.g., Java) sometimes do this because they’re used to it. In Python there is no point to creating these sorts of getters and setters that don’t do anything but directly get and set the underlying variable. Properties allow you to transparently swap in logic if at a later time you need to do something more complex than just get/set the value.
There can be a benefit in using getters/setters, but in Python there is no real reason to use trivial getters/setters instead of just getting/setting the attribute directly. The only reason I can think of would be if you have to maintain compatibility with an existing API that requires a certain set of methods to be available.
Don’t use a getter, just access the class attribute directly. Normally getters are used to access private/protected attributes but in python there is no such thing. Another reason to use a getter is so that you can do some work before returning a value, in your case your not, but that might change in the future right, no worries, when that time comes just start using the
def name(self): return self._name
you will still access it like this,
myObject.name, same as accessing it directly.
I would expect production code to use
@property. But since you asked, I’ll throw something out there.
Maybe the programmer will be making subclasses of
Node and thought it easier (or at least more explicit) to override
getName to do some special work. Just a thought!
But in general, like others have said, it’s not something you would commonly see.
There isn’t any. They’re unnecessary in Python and widely recommended against.