10

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
Chris
  • 9,603
  • 15
  • 46
  • 67
  • Did you find this example in real code or is it a hypothetical example ? – Ray Toal Dec 13 '12 at 03:15
  • It's in an example in the MITx 6.00x and i've seen similar things in other places. – Chris Dec 13 '12 at 03:16
  • possible duplicate of [Python @property versus getters and setters](http://stackoverflow.com/questions/6618002/python-property-versus-getters-and-setters) – Don Kirkby Jan 03 '13 at 20:59

4 Answers4

21

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.

BrenBarn
  • 242,874
  • 37
  • 412
  • 384
  • 5
    At least one other reason comes to mind: I've seen lots of people use explicit methods for expensive operations, since for most people the general assumption is that accessing a "variable" directly won't have a high cost associated. If you have to query some webpage halfway around the world you may want to make this more explicit. – Voo Dec 13 '12 at 04:03
  • 1
    @Voo: That's true, but that's not a *trivial* getter/setter. Like I said, it's not that using getters/setters is pointless, it's that using them *just to get/set a simple underlying attribute* is pointless. If they have something to actually do, it makes perfect sense. (If you have something that starts out as a simple attribute and then later you have to change it so it queries a webpage halfway around that world. . . well, that seems like a strange and unusual sort of design change.) – BrenBarn Dec 13 '12 at 04:21
4

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, you're not, but that might change in the future right, no worries. When that time comes just start using the property decorator.

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

You will still access it like this, myObject.name, same as accessing it directly.

Michael M.
  • 10,486
  • 9
  • 18
  • 34
vikki
  • 2,766
  • 1
  • 20
  • 26
2

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.

Ray Toal
  • 86,166
  • 18
  • 182
  • 232
  • 2
    Subclasses, if they want to do something akin to "overriding `getName`" can simply make `name` a property: this allows the subclass to do anything it needs when the `name` is accessed. They do not need a `getName()` method. – Eric O. Lebigot Dec 25 '12 at 06:48
1

There isn't any. They're unnecessary in Python and widely recommended against.

khagler
  • 3,996
  • 29
  • 40